netwerk/protocol/http/PHttpChannelParams.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set sw=2 ts=8 et tw=80 : */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_net_PHttpChannelParams_h
   8 #define mozilla_net_PHttpChannelParams_h
   9
  10 #define ALLOW_LATE_NSHTTP_H_INCLUDE 1
  11 #include "base/basictypes.h"
  12
  13 #include "ipc/IPCMessageUtils.h"
  14 #include "ipc/IPCMessageUtilsSpecializations.h"
  15 #include "nsHttp.h"
  16 #include "nsHttpHeaderArray.h"
  17 #include "nsHttpRequestHead.h"
  18 #include "nsHttpResponseHead.h"
  19
  20 namespace mozilla {
  21 namespace net {
  22
  23 struct RequestHeaderTuple {
  24   nsCString mHeader;
  25   nsCString mValue;
  26   bool mMerge;
  27   bool mEmpty;
  28
  29   bool operator==(const RequestHeaderTuple& other) const {
  30     return mHeader.Equals(other.mHeader) && mValue.Equals(other.mValue) &&
  31            mMerge == other.mMerge && mEmpty == other.mEmpty;
  32   }
  33 };
  34
  35 typedef CopyableTArray<RequestHeaderTuple> RequestHeaderTuples;
  36
  37 }  // namespace net
  38 }  // namespace mozilla
  39
  40 namespace IPC {
  41
  42 template <>
  43 struct ParamTraits<mozilla::net::RequestHeaderTuple> {
  44   typedef mozilla::net::RequestHeaderTuple paramType;
  45
  46   static void Write(MessageWriter* aWriter, const paramType& aParam) {
  47     WriteParam(aWriter, aParam.mHeader);
  48     WriteParam(aWriter, aParam.mValue);
  49     WriteParam(aWriter, aParam.mMerge);
  50     WriteParam(aWriter, aParam.mEmpty);
  51   }
  52
  53   static bool Read(MessageReader* aReader, paramType* aResult) {
  54     if (!ReadParam(aReader, &aResult->mHeader) ||
  55         !ReadParam(aReader, &aResult->mValue) ||
  56         !ReadParam(aReader, &aResult->mMerge) ||
  57         !ReadParam(aReader, &aResult->mEmpty))
  58       return false;
  59
  60     return true;
  61   }
  62 };
  63
  64 template <>
  65 struct ParamTraits<mozilla::net::nsHttpAtom> {
  66   typedef mozilla::net::nsHttpAtom paramType;
  67
  68   static void Write(MessageWriter* aWriter, const paramType& aParam) {
  69     // aParam.get() cannot be null.
  70     MOZ_ASSERT(aParam.get(), "null nsHTTPAtom value");
  71     nsAutoCString value(aParam.get());
  72     WriteParam(aWriter, value);
  73   }
  74
  75   static bool Read(MessageReader* aReader, paramType* aResult) {
  76     nsAutoCString value;
  77     if (!ReadParam(aReader, &value)) return false;
  78
  79     *aResult = mozilla::net::nsHttp::ResolveAtom(value);
  80     MOZ_ASSERT(aResult->get(), "atom table not initialized");
  81     return true;
  82   }
  83 };
  84
  85 template <>
  86 struct ParamTraits<mozilla::net::nsHttpHeaderArray::nsEntry> {
  87   typedef mozilla::net::nsHttpHeaderArray::nsEntry paramType;
  88
  89   static void Write(MessageWriter* aWriter, const paramType& aParam) {
  90     if (aParam.headerNameOriginal.IsEmpty()) {
  91       WriteParam(aWriter, aParam.header);
  92     } else {
  93       WriteParam(aWriter, aParam.headerNameOriginal);
  94     }
  95     WriteParam(aWriter, aParam.value);
  96     switch (aParam.variety) {
  97       case mozilla::net::nsHttpHeaderArray::eVarietyUnknown:
  98         WriteParam(aWriter, (uint8_t)0);
  99         break;
 100       case mozilla::net::nsHttpHeaderArray::eVarietyRequestOverride:
 101         WriteParam(aWriter, (uint8_t)1);
 102         break;
 103       case mozilla::net::nsHttpHeaderArray::eVarietyRequestDefault:
 104         WriteParam(aWriter, (uint8_t)2);
 105         break;
 106       case mozilla::net::nsHttpHeaderArray::eVarietyRequestEnforceDefault:
 107         WriteParam(aWriter, (uint8_t)3);
 108         break;
 109       case mozilla::net::nsHttpHeaderArray::
 110           eVarietyResponseNetOriginalAndResponse:
 111         WriteParam(aWriter, (uint8_t)4);
 112         break;
 113       case mozilla::net::nsHttpHeaderArray::eVarietyResponseNetOriginal:
 114         WriteParam(aWriter, (uint8_t)5);
 115         break;
 116       case mozilla::net::nsHttpHeaderArray::eVarietyResponse:
 117         WriteParam(aWriter, (uint8_t)6);
 118     }
 119   }
 120
 121   static bool Read(MessageReader* aReader, paramType* aResult) {
 122     uint8_t variety;
 123     nsAutoCString header;
 124     if (!ReadParam(aReader, &header) || !ReadParam(aReader, &aResult->value) ||
 125         !ReadParam(aReader, &variety))
 126       return false;
 127
 128     mozilla::net::nsHttpAtom atom = mozilla::net::nsHttp::ResolveAtom(header);
 129     aResult->header = atom;
 130     if (!header.Equals(atom.get())) {
 131       aResult->headerNameOriginal = header;
 132     }
 133
 134     switch (variety) {
 135       case 0:
 136         aResult->variety = mozilla::net::nsHttpHeaderArray::eVarietyUnknown;
 137         break;
 138       case 1:
 139         aResult->variety =
 140             mozilla::net::nsHttpHeaderArray::eVarietyRequestOverride;
 141         break;
 142       case 2:
 143         aResult->variety =
 144             mozilla::net::nsHttpHeaderArray::eVarietyRequestDefault;
 145         break;
 146       case 3:
 147         aResult->variety =
 148             mozilla::net::nsHttpHeaderArray::eVarietyRequestEnforceDefault;
 149         break;
 150       case 4:
 151         aResult->variety = mozilla::net::nsHttpHeaderArray::
 152             eVarietyResponseNetOriginalAndResponse;
 153         break;
 154       case 5:
 155         aResult->variety =
 156             mozilla::net::nsHttpHeaderArray::eVarietyResponseNetOriginal;
 157         break;
 158       case 6:
 159         aResult->variety = mozilla::net::nsHttpHeaderArray::eVarietyResponse;
 160         break;
 161       default:
 162         return false;
 163     }
 164
 165     return true;
 166   }
 167 };
 168
 169 template <>
 170 struct ParamTraits<mozilla::net::nsHttpHeaderArray> {
 171   typedef mozilla::net::nsHttpHeaderArray paramType;
 172
 173   static void Write(MessageWriter* aWriter, const paramType& aParam) {
 174     paramType& p = const_cast<paramType&>(aParam);
 175
 176     WriteParam(aWriter, p.mHeaders);
 177   }
 178
 179   static bool Read(MessageReader* aReader, paramType* aResult) {
 180     if (!ReadParam(aReader, &aResult->mHeaders)) return false;
 181
 182     return true;
 183   }
 184 };
 185
 186 template <>
 187 struct ParamTraits<mozilla::net::nsHttpRequestHead> {
 188   typedef mozilla::net::nsHttpRequestHead paramType;
 189
 190   static void Write(MessageWriter* aWriter,
 191                     const paramType& aParam) MOZ_NO_THREAD_SAFETY_ANALYSIS {
 192     aParam.Enter();
 193     WriteParam(aWriter, aParam.mHeaders);
 194     WriteParam(aWriter, aParam.mMethod);
 195     WriteParam(aWriter, static_cast<uint32_t>(aParam.mVersion));
 196     WriteParam(aWriter, aParam.mRequestURI);
 197     WriteParam(aWriter, aParam.mPath);
 198     WriteParam(aWriter, aParam.mOrigin);
 199     WriteParam(aWriter, static_cast<uint8_t>(aParam.mParsedMethod));
 200     WriteParam(aWriter, aParam.mHTTPS);
 201     aParam.Exit();
 202   }
 203
 204   static bool Read(MessageReader* aReader, paramType* aResult) {
 205     uint32_t version;
 206     uint8_t method;
 207     aResult->Enter();
 208     if (!ReadParam(aReader, &aResult->mHeaders) ||
 209         !ReadParam(aReader, &aResult->mMethod) ||
 210         !ReadParam(aReader, &version) ||
 211         !ReadParam(aReader, &aResult->mRequestURI) ||
 212         !ReadParam(aReader, &aResult->mPath) ||
 213         !ReadParam(aReader, &aResult->mOrigin) ||
 214         !ReadParam(aReader, &method) || !ReadParam(aReader, &aResult->mHTTPS)) {
 215       aResult->Exit();
 216       return false;
 217     }
 218
 219     aResult->mVersion = static_cast<mozilla::net::HttpVersion>(version);
 220     aResult->mParsedMethod =
 221         static_cast<mozilla::net::nsHttpRequestHead::ParsedMethodType>(method);
 222     aResult->Exit();
 223     return true;
 224   }
 225 };
 226
 227 // Note that the code below MUST be synchronized with the code in
 228 // nsHttpRequestHead's copy constructor.
 229 template <>
 230 struct ParamTraits<mozilla::net::nsHttpResponseHead> {
 231   typedef mozilla::net::nsHttpResponseHead paramType;
 232
 233   static void Write(MessageWriter* aWriter,
 234                     const paramType& aParam) MOZ_NO_THREAD_SAFETY_ANALYSIS {
 235     aParam.Enter();
 236     WriteParam(aWriter, aParam.mHeaders);
 237     WriteParam(aWriter, static_cast<uint32_t>(aParam.mVersion));
 238     WriteParam(aWriter, aParam.mStatus);
 239     WriteParam(aWriter, aParam.mStatusText);
 240     WriteParam(aWriter, aParam.mContentLength);
 241     WriteParam(aWriter, aParam.mContentType);
 242     WriteParam(aWriter, aParam.mContentCharset);
 243     WriteParam(aWriter, aParam.mHasCacheControl);
 244     WriteParam(aWriter, aParam.mCacheControlPublic);
 245     WriteParam(aWriter, aParam.mCacheControlPrivate);
 246     WriteParam(aWriter, aParam.mCacheControlNoStore);
 247     WriteParam(aWriter, aParam.mCacheControlNoCache);
 248     WriteParam(aWriter, aParam.mCacheControlImmutable);
 249     WriteParam(aWriter, aParam.mCacheControlStaleWhileRevalidateSet);
 250     WriteParam(aWriter, aParam.mCacheControlStaleWhileRevalidate);
 251     WriteParam(aWriter, aParam.mCacheControlMaxAgeSet);
 252     WriteParam(aWriter, aParam.mCacheControlMaxAge);
 253     WriteParam(aWriter, aParam.mPragmaNoCache);
 254     aParam.Exit();
 255   }
 256
 257   static bool Read(MessageReader* aReader, paramType* aResult) {
 258     uint32_t version;
 259     aResult->Enter();
 260     if (!ReadParam(aReader, &aResult->mHeaders) ||
 261         !ReadParam(aReader, &version) ||
 262         !ReadParam(aReader, &aResult->mStatus) ||
 263         !ReadParam(aReader, &aResult->mStatusText) ||
 264         !ReadParam(aReader, &aResult->mContentLength) ||
 265         !ReadParam(aReader, &aResult->mContentType) ||
 266         !ReadParam(aReader, &aResult->mContentCharset) ||
 267         !ReadParam(aReader, &aResult->mHasCacheControl) ||
 268         !ReadParam(aReader, &aResult->mCacheControlPublic) ||
 269         !ReadParam(aReader, &aResult->mCacheControlPrivate) ||
 270         !ReadParam(aReader, &aResult->mCacheControlNoStore) ||
 271         !ReadParam(aReader, &aResult->mCacheControlNoCache) ||
 272         !ReadParam(aReader, &aResult->mCacheControlImmutable) ||
 273         !ReadParam(aReader, &aResult->mCacheControlStaleWhileRevalidateSet) ||
 274         !ReadParam(aReader, &aResult->mCacheControlStaleWhileRevalidate) ||
 275         !ReadParam(aReader, &aResult->mCacheControlMaxAgeSet) ||
 276         !ReadParam(aReader, &aResult->mCacheControlMaxAge) ||
 277         !ReadParam(aReader, &aResult->mPragmaNoCache)) {
 278       aResult->Exit();
 279       return false;
 280     }
 281
 282     aResult->mVersion = static_cast<mozilla::net::HttpVersion>(version);
 283     aResult->Exit();
 284     return true;
 285   }
 286 };
 287
 288 }  // namespace IPC
 289
 290 #endif  // mozilla_net_PHttpChannelParams_h