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