chrome/RegistryMessageUtils.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef mozilla_RegistryMessageUtils_h
   7 #define mozilla_RegistryMessageUtils_h
   8
   9 #include "mozilla/ipc/IPDLParamTraits.h"
  10 #include "nsString.h"
  11
  12 struct SerializedURI {
  13   nsCString spec;
  14
  15   bool operator==(const SerializedURI& rhs) const {
  16     return spec.Equals(rhs.spec);
  17   }
  18 };
  19
  20 struct ChromePackage {
  21   nsCString package;
  22   SerializedURI contentBaseURI;
  23   SerializedURI localeBaseURI;
  24   SerializedURI skinBaseURI;
  25   uint32_t flags;
  26
  27   bool operator==(const ChromePackage& rhs) const {
  28     return package.Equals(rhs.package) &&
  29            contentBaseURI == rhs.contentBaseURI &&
  30            localeBaseURI == rhs.localeBaseURI &&
  31            skinBaseURI == rhs.skinBaseURI && flags == rhs.flags;
  32   }
  33 };
  34
  35 struct SubstitutionMapping {
  36   nsCString scheme;
  37   nsCString path;
  38   SerializedURI resolvedURI;
  39   uint32_t flags;
  40
  41   bool operator==(const SubstitutionMapping& rhs) const {
  42     return scheme.Equals(rhs.scheme) && path.Equals(rhs.path) &&
  43            resolvedURI == rhs.resolvedURI && flags == rhs.flags;
  44   }
  45 };
  46
  47 struct OverrideMapping {
  48   SerializedURI originalURI;
  49   SerializedURI overrideURI;
  50
  51   bool operator==(const OverrideMapping& rhs) const {
  52     return originalURI == rhs.originalURI && overrideURI == rhs.overrideURI;
  53   }
  54 };
  55
  56 namespace IPC {
  57
  58 template <>
  59 struct ParamTraits<SerializedURI> {
  60   typedef SerializedURI paramType;
  61
  62   static void Write(MessageWriter* aWriter, const paramType& aParam) {
  63     WriteParam(aWriter, aParam.spec);
  64   }
  65
  66   static bool Read(MessageReader* aReader, paramType* aResult) {
  67     nsCString spec;
  68     if (ReadParam(aReader, &spec)) {
  69       aResult->spec = spec;
  70       return true;
  71     }
  72     return false;
  73   }
  74 };
  75
  76 template <>
  77 struct ParamTraits<ChromePackage> {
  78   typedef ChromePackage paramType;
  79
  80   static void Write(MessageWriter* aWriter, const paramType& aParam) {
  81     WriteParam(aWriter, aParam.package);
  82     WriteParam(aWriter, aParam.contentBaseURI);
  83     WriteParam(aWriter, aParam.localeBaseURI);
  84     WriteParam(aWriter, aParam.skinBaseURI);
  85     WriteParam(aWriter, aParam.flags);
  86   }
  87
  88   static bool Read(MessageReader* aReader, paramType* aResult) {
  89     nsCString package;
  90     SerializedURI contentBaseURI, localeBaseURI, skinBaseURI;
  91     uint32_t flags;
  92
  93     if (ReadParam(aReader, &package) && ReadParam(aReader, &contentBaseURI) &&
  94         ReadParam(aReader, &localeBaseURI) &&
  95         ReadParam(aReader, &skinBaseURI) && ReadParam(aReader, &flags)) {
  96       aResult->package = package;
  97       aResult->contentBaseURI = contentBaseURI;
  98       aResult->localeBaseURI = localeBaseURI;
  99       aResult->skinBaseURI = skinBaseURI;
 100       aResult->flags = flags;
 101       return true;
 102     }
 103     return false;
 104   }
 105 };
 106
 107 template <>
 108 struct ParamTraits<SubstitutionMapping> {
 109   typedef SubstitutionMapping paramType;
 110
 111   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 112     WriteParam(aWriter, aParam.scheme);
 113     WriteParam(aWriter, aParam.path);
 114     WriteParam(aWriter, aParam.resolvedURI);
 115     WriteParam(aWriter, aParam.flags);
 116   }
 117
 118   static bool Read(MessageReader* aReader, paramType* aResult) {
 119     nsCString scheme, path;
 120     SerializedURI resolvedURI;
 121     uint32_t flags;
 122
 123     if (ReadParam(aReader, &scheme) && ReadParam(aReader, &path) &&
 124         ReadParam(aReader, &resolvedURI) && ReadParam(aReader, &flags)) {
 125       aResult->scheme = scheme;
 126       aResult->path = path;
 127       aResult->resolvedURI = resolvedURI;
 128       aResult->flags = flags;
 129       return true;
 130     }
 131     return false;
 132   }
 133 };
 134
 135 template <>
 136 struct ParamTraits<OverrideMapping> {
 137   typedef OverrideMapping paramType;
 138
 139   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 140     WriteParam(aWriter, aParam.originalURI);
 141     WriteParam(aWriter, aParam.overrideURI);
 142   }
 143
 144   static bool Read(MessageReader* aReader, paramType* aResult) {
 145     SerializedURI originalURI;
 146     SerializedURI overrideURI;
 147
 148     if (ReadParam(aReader, &originalURI) && ReadParam(aReader, &overrideURI)) {
 149       aResult->originalURI = originalURI;
 150       aResult->overrideURI = overrideURI;
 151       return true;
 152     }
 153     return false;
 154   }
 155 };
 156
 157 }  // namespace IPC
 158
 159 #endif  // RegistryMessageUtils_h