chrome/RegistryMessageUtils.h
author L10n Bumper Bot <release+l10nbumper@mozilla.com>
Mon, 17 Dec 2018 05:00:11 -0800
changeset 506261 e8f9d8975d0f9702b320f8cfcd989bd88db6273d
parent 505383 6f3709b3878117466168c40affa7bca0b60cf75b
permissions -rw-r--r--
no bug - Bumping Fennec l10n changesets r=release a=l10n-bump DONTBUILD an -> 176758dc0404 dsb -> 4614a05cf396 fy-NL -> 329815f0d288 gd -> 3d6b27ee5e58 hi-IN -> a886e2b55636 hsb -> a1da7baaac2c hy-AM -> 6f231310c387 kab -> 2cbdc076a185 kk -> 1753bd996be6 lo -> 18b2a9d5cd35 mai -> 0de2b15a802b mr -> 69f8bd0a8e45 ru -> 49be174d9b2b sv-SE -> 4eb4d6069f79 tr -> ace765b25800 trs -> ccc0b3063a5b uk -> 4013e6bffec1 ur -> 8df00f58a967 uz -> a36b000cfbb4

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_RegistryMessageUtils_h
#define mozilla_RegistryMessageUtils_h

#include "ipc/IPCMessageUtils.h"
#include "nsString.h"

struct SerializedURI {
  nsCString spec;

  bool operator==(const SerializedURI& rhs) const {
    return spec.Equals(rhs.spec);
  }
};

struct ChromePackage {
  nsCString package;
  SerializedURI contentBaseURI;
  SerializedURI localeBaseURI;
  SerializedURI skinBaseURI;
  uint32_t flags;

  bool operator==(const ChromePackage& rhs) const {
    return package.Equals(rhs.package) &&
           contentBaseURI == rhs.contentBaseURI &&
           localeBaseURI == rhs.localeBaseURI &&
           skinBaseURI == rhs.skinBaseURI && flags == rhs.flags;
  }
};

struct SubstitutionMapping {
  nsCString scheme;
  nsCString path;
  SerializedURI resolvedURI;
  uint32_t flags;

  bool operator==(const SubstitutionMapping& rhs) const {
    return scheme.Equals(rhs.scheme) && path.Equals(rhs.path) &&
           resolvedURI == rhs.resolvedURI && flags == rhs.flags;
  }
};

struct OverrideMapping {
  SerializedURI originalURI;
  SerializedURI overrideURI;

  bool operator==(const OverrideMapping& rhs) const {
    return originalURI == rhs.originalURI && overrideURI == rhs.overrideURI;
  }
};

namespace IPC {

template <>
struct ParamTraits<SerializedURI> {
  typedef SerializedURI paramType;

  static void Write(Message* aMsg, const paramType& aParam) {
    WriteParam(aMsg, aParam.spec);
  }

  static bool Read(const Message* aMsg, PickleIterator* aIter,
                   paramType* aResult) {
    nsCString spec;
    if (ReadParam(aMsg, aIter, &spec)) {
      aResult->spec = spec;
      return true;
    }
    return false;
  }
};

template <>
struct ParamTraits<ChromePackage> {
  typedef ChromePackage paramType;

  static void Write(Message* aMsg, const paramType& aParam) {
    WriteParam(aMsg, aParam.package);
    WriteParam(aMsg, aParam.contentBaseURI);
    WriteParam(aMsg, aParam.localeBaseURI);
    WriteParam(aMsg, aParam.skinBaseURI);
    WriteParam(aMsg, aParam.flags);
  }

  static bool Read(const Message* aMsg, PickleIterator* aIter,
                   paramType* aResult) {
    nsCString package;
    SerializedURI contentBaseURI, localeBaseURI, skinBaseURI;
    uint32_t flags;

    if (ReadParam(aMsg, aIter, &package) &&
        ReadParam(aMsg, aIter, &contentBaseURI) &&
        ReadParam(aMsg, aIter, &localeBaseURI) &&
        ReadParam(aMsg, aIter, &skinBaseURI) &&
        ReadParam(aMsg, aIter, &flags)) {
      aResult->package = package;
      aResult->contentBaseURI = contentBaseURI;
      aResult->localeBaseURI = localeBaseURI;
      aResult->skinBaseURI = skinBaseURI;
      aResult->flags = flags;
      return true;
    }
    return false;
  }

  static void Log(const paramType& aParam, std::wstring* aLog) {
    aLog->append(StringPrintf(L"[%s, %s, %s, %s, %u]", aParam.package.get(),
                              aParam.contentBaseURI.spec.get(),
                              aParam.localeBaseURI.spec.get(),
                              aParam.skinBaseURI.spec.get(), aParam.flags));
  }
};

template <>
struct ParamTraits<SubstitutionMapping> {
  typedef SubstitutionMapping paramType;

  static void Write(Message* aMsg, const paramType& aParam) {
    WriteParam(aMsg, aParam.scheme);
    WriteParam(aMsg, aParam.path);
    WriteParam(aMsg, aParam.resolvedURI);
    WriteParam(aMsg, aParam.flags);
  }

  static bool Read(const Message* aMsg, PickleIterator* aIter,
                   paramType* aResult) {
    nsCString scheme, path;
    SerializedURI resolvedURI;
    uint32_t flags;

    if (ReadParam(aMsg, aIter, &scheme) && ReadParam(aMsg, aIter, &path) &&
        ReadParam(aMsg, aIter, &resolvedURI) &&
        ReadParam(aMsg, aIter, &flags)) {
      aResult->scheme = scheme;
      aResult->path = path;
      aResult->resolvedURI = resolvedURI;
      aResult->flags = flags;
      return true;
    }
    return false;
  }

  static void Log(const paramType& aParam, std::wstring* aLog) {
    aLog->append(StringPrintf(L"[%s://%s, %s, %u]", aParam.scheme.get(),
                              aParam.path.get(),
                              aParam.resolvedURI.spec.get()));
  }
};

template <>
struct ParamTraits<OverrideMapping> {
  typedef OverrideMapping paramType;

  static void Write(Message* aMsg, const paramType& aParam) {
    WriteParam(aMsg, aParam.originalURI);
    WriteParam(aMsg, aParam.overrideURI);
  }

  static bool Read(const Message* aMsg, PickleIterator* aIter,
                   paramType* aResult) {
    SerializedURI originalURI;
    SerializedURI overrideURI;

    if (ReadParam(aMsg, aIter, &originalURI) &&
        ReadParam(aMsg, aIter, &overrideURI)) {
      aResult->originalURI = originalURI;
      aResult->overrideURI = overrideURI;
      return true;
    }
    return false;
  }

  static void Log(const paramType& aParam, std::wstring* aLog) {
    aLog->append(StringPrintf(L"[%s, %s, %u]", aParam.originalURI.spec.get(),
                              aParam.overrideURI.spec.get()));
  }
};

}  // namespace IPC

#endif  // RegistryMessageUtils_h