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 "ipc/IPCMessageUtils.h"
  10 #include "nsString.h"
  11
  12 struct SerializedURI
  13 {
  14   nsCString spec;
  15   nsCString charset;
  16
  17   bool operator ==(const SerializedURI& rhs) const
  18   {
  19       return spec.Equals(rhs.spec) &&
  20              charset.Equals(rhs.charset);
  21   }
  22 };
  23
  24 struct ChromePackage
  25 {
  26   nsCString package;
  27   SerializedURI contentBaseURI;
  28   SerializedURI localeBaseURI;
  29   SerializedURI skinBaseURI;
  30   uint32_t flags;
  31
  32   bool operator ==(const ChromePackage& rhs) const
  33   {
  34     return package.Equals(rhs.package) &&
  35            contentBaseURI == rhs.contentBaseURI &&
  36            localeBaseURI == rhs.localeBaseURI &&
  37            skinBaseURI == rhs.skinBaseURI &&
  38            flags == rhs.flags;
  39   }
  40 };
  41
  42 struct ResourceMapping
  43 {
  44   nsCString resource;
  45   SerializedURI resolvedURI;
  46
  47   bool operator ==(const ResourceMapping& rhs) const
  48   {
  49     return resource.Equals(rhs.resource) &&
  50            resolvedURI == rhs.resolvedURI;
  51   }
  52 };
  53
  54 struct OverrideMapping
  55 {
  56   SerializedURI originalURI;
  57   SerializedURI overrideURI;
  58
  59   bool operator==(const OverrideMapping& rhs) const
  60   {
  61       return originalURI == rhs.originalURI &&
  62              overrideURI == rhs.overrideURI;
  63   }
  64 };
  65
  66 namespace IPC {
  67
  68 template<>
  69 struct ParamTraits<SerializedURI>
  70 {
  71   typedef SerializedURI paramType;
  72
  73   static void Write(Message* aMsg, const paramType& aParam)
  74   {
  75     WriteParam(aMsg, aParam.spec);
  76     WriteParam(aMsg, aParam.charset);
  77   }
  78
  79   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
  80   {
  81     nsCString spec, charset;
  82     if (ReadParam(aMsg, aIter, &spec) &&
  83         ReadParam(aMsg, aIter, &charset)) {
  84       aResult->spec = spec;
  85       aResult->charset = charset;
  86       return true;
  87     }
  88     return false;
  89   }
  90 };
  91
  92 template <>
  93 struct ParamTraits<ChromePackage>
  94 {
  95   typedef ChromePackage paramType;
  96
  97   static void Write(Message* aMsg, const paramType& aParam)
  98   {
  99     WriteParam(aMsg, aParam.package);
 100     WriteParam(aMsg, aParam.contentBaseURI);
 101     WriteParam(aMsg, aParam.localeBaseURI);
 102     WriteParam(aMsg, aParam.skinBaseURI);
 103     WriteParam(aMsg, aParam.flags);
 104   }
 105
 106   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 107   {
 108     nsCString package;
 109     SerializedURI contentBaseURI, localeBaseURI, skinBaseURI;
 110     uint32_t flags;
 111
 112     if (ReadParam(aMsg, aIter, &package) &&
 113         ReadParam(aMsg, aIter, &contentBaseURI) &&
 114         ReadParam(aMsg, aIter, &localeBaseURI) &&
 115         ReadParam(aMsg, aIter, &skinBaseURI) &&
 116         ReadParam(aMsg, aIter, &flags)) {
 117       aResult->package = package;
 118       aResult->contentBaseURI = contentBaseURI;
 119       aResult->localeBaseURI = localeBaseURI;
 120       aResult->skinBaseURI = skinBaseURI;
 121       aResult->flags = flags;
 122       return true;
 123     }
 124     return false;
 125   }
 126
 127   static void Log(const paramType& aParam, std::wstring* aLog)
 128   {
 129     aLog->append(StringPrintf(L"[%s, %s, %s, %s, %u]", aParam.package.get(),
 130                              aParam.contentBaseURI.spec.get(),
 131                              aParam.localeBaseURI.spec.get(),
 132                              aParam.skinBaseURI.spec.get(), aParam.flags));
 133   }
 134 };
 135
 136 template <>
 137 struct ParamTraits<ResourceMapping>
 138 {
 139   typedef ResourceMapping paramType;
 140
 141   static void Write(Message* aMsg, const paramType& aParam)
 142   {
 143     WriteParam(aMsg, aParam.resource);
 144     WriteParam(aMsg, aParam.resolvedURI);
 145   }
 146
 147   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 148   {
 149     nsCString resource;
 150     SerializedURI resolvedURI;
 151
 152     if (ReadParam(aMsg, aIter, &resource) &&
 153         ReadParam(aMsg, aIter, &resolvedURI)) {
 154       aResult->resource = resource;
 155       aResult->resolvedURI = resolvedURI;
 156       return true;
 157     }
 158     return false;
 159   }
 160
 161   static void Log(const paramType& aParam, std::wstring* aLog)
 162   {
 163     aLog->append(StringPrintf(L"[%s, %s, %u]", aParam.resource.get(),
 164                              aParam.resolvedURI.spec.get()));
 165   }
 166 };
 167
 168 template <>
 169 struct ParamTraits<OverrideMapping>
 170 {
 171   typedef OverrideMapping paramType;
 172
 173   static void Write(Message* aMsg, const paramType& aParam)
 174   {
 175     WriteParam(aMsg, aParam.originalURI);
 176     WriteParam(aMsg, aParam.overrideURI);
 177   }
 178
 179   static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
 180   {
 181     SerializedURI originalURI;
 182     SerializedURI overrideURI;
 183
 184     if (ReadParam(aMsg, aIter, &originalURI) &&
 185         ReadParam(aMsg, aIter, &overrideURI)) {
 186       aResult->originalURI = originalURI;
 187       aResult->overrideURI = overrideURI;
 188       return true;
 189     }
 190     return false;
 191   }
 192
 193   static void Log(const paramType& aParam, std::wstring* aLog)
 194   {
 195     aLog->append(StringPrintf(L"[%s, %s, %u]", aParam.originalURI.spec.get(),
 196                              aParam.overrideURI.spec.get()));
 197   }
 198 };
 199
 200 }
 201
 202 #endif // RegistryMessageUtils_h