Line data Source code
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 "nsHttp.h"
15 : #include "nsHttpHeaderArray.h"
16 : #include "nsHttpResponseHead.h"
17 :
18 : #include "nsIClassInfo.h"
19 :
20 : namespace mozilla {
21 : namespace net {
22 :
23 55 : struct RequestHeaderTuple {
24 : nsCString mHeader;
25 : nsCString mValue;
26 : bool mMerge;
27 : bool mEmpty;
28 :
29 0 : bool operator ==(const RequestHeaderTuple &other) const {
30 0 : return mHeader.Equals(other.mHeader) &&
31 0 : mValue.Equals(other.mValue) &&
32 0 : mMerge == other.mMerge &&
33 0 : mEmpty == other.mEmpty;
34 : }
35 : };
36 :
37 : typedef nsTArray<RequestHeaderTuple> RequestHeaderTuples;
38 :
39 : } // namespace net
40 : } // namespace mozilla
41 :
42 : namespace IPC {
43 :
44 : template<>
45 : struct ParamTraits<mozilla::net::RequestHeaderTuple>
46 : {
47 : typedef mozilla::net::RequestHeaderTuple paramType;
48 :
49 7 : static void Write(Message* aMsg, const paramType& aParam)
50 : {
51 7 : WriteParam(aMsg, aParam.mHeader);
52 7 : WriteParam(aMsg, aParam.mValue);
53 7 : WriteParam(aMsg, aParam.mMerge);
54 7 : WriteParam(aMsg, aParam.mEmpty);
55 7 : }
56 :
57 7 : static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
58 : {
59 21 : if (!ReadParam(aMsg, aIter, &aResult->mHeader) ||
60 14 : !ReadParam(aMsg, aIter, &aResult->mValue) ||
61 21 : !ReadParam(aMsg, aIter, &aResult->mMerge) ||
62 7 : !ReadParam(aMsg, aIter, &aResult->mEmpty))
63 0 : return false;
64 :
65 7 : return true;
66 : }
67 : };
68 :
69 : template<>
70 : struct ParamTraits<mozilla::net::nsHttpAtom>
71 : {
72 : typedef mozilla::net::nsHttpAtom paramType;
73 :
74 36 : static void Write(Message* aMsg, const paramType& aParam)
75 : {
76 : // aParam.get() cannot be null.
77 36 : MOZ_ASSERT(aParam.get(), "null nsHTTPAtom value");
78 72 : nsAutoCString value(aParam.get());
79 36 : WriteParam(aMsg, value);
80 36 : }
81 :
82 : static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
83 : {
84 : nsAutoCString value;
85 : if (!ReadParam(aMsg, aIter, &value))
86 : return false;
87 :
88 : *aResult = mozilla::net::nsHttp::ResolveAtom(value.get());
89 : MOZ_ASSERT(aResult->get(), "atom table not initialized");
90 : return true;
91 : }
92 : };
93 :
94 : template<>
95 : struct ParamTraits<mozilla::net::nsHttpHeaderArray::nsEntry>
96 : {
97 : typedef mozilla::net::nsHttpHeaderArray::nsEntry paramType;
98 :
99 39 : static void Write(Message* aMsg, const paramType& aParam)
100 : {
101 39 : if (aParam.headerNameOriginal.IsEmpty()) {
102 36 : WriteParam(aMsg, aParam.header);
103 : } else {
104 3 : WriteParam(aMsg, aParam.headerNameOriginal);
105 : }
106 39 : WriteParam(aMsg, aParam.value);
107 39 : switch (aParam.variety) {
108 : case mozilla::net::nsHttpHeaderArray::eVarietyUnknown:
109 0 : WriteParam(aMsg, (uint8_t)0);
110 0 : break;
111 : case mozilla::net::nsHttpHeaderArray::eVarietyRequestOverride:
112 15 : WriteParam(aMsg, (uint8_t)1);
113 15 : break;
114 : case mozilla::net::nsHttpHeaderArray::eVarietyRequestDefault:
115 6 : WriteParam(aMsg, (uint8_t)2);
116 6 : break;
117 : case mozilla::net::nsHttpHeaderArray::eVarietyResponseNetOriginalAndResponse:
118 15 : WriteParam(aMsg, (uint8_t)3);
119 15 : break;
120 : case mozilla::net::nsHttpHeaderArray::eVarietyResponseNetOriginal:
121 0 : WriteParam(aMsg, (uint8_t)4);
122 0 : break;
123 : case mozilla::net::nsHttpHeaderArray::eVarietyResponse:
124 3 : WriteParam(aMsg, (uint8_t)5);
125 : }
126 39 : }
127 :
128 39 : static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
129 : {
130 : uint8_t variety;
131 78 : nsAutoCString header;
132 117 : if (!ReadParam(aMsg, aIter, &header) ||
133 78 : !ReadParam(aMsg, aIter, &aResult->value) ||
134 39 : !ReadParam(aMsg, aIter, &variety))
135 0 : return false;
136 :
137 39 : mozilla::net::nsHttpAtom atom = mozilla::net::nsHttp::ResolveAtom(header);
138 39 : aResult->header = atom;
139 39 : if (!header.Equals(atom.get())) {
140 3 : aResult->headerNameOriginal = header;
141 : }
142 :
143 39 : switch (variety) {
144 : case 0:
145 0 : aResult->variety = mozilla::net::nsHttpHeaderArray::eVarietyUnknown;
146 0 : break;
147 : case 1:
148 15 : aResult->variety = mozilla::net::nsHttpHeaderArray::eVarietyRequestOverride;
149 15 : break;
150 : case 2:
151 6 : aResult->variety = mozilla::net::nsHttpHeaderArray::eVarietyRequestDefault;
152 6 : break;
153 : case 3:
154 15 : aResult->variety = mozilla::net::nsHttpHeaderArray::eVarietyResponseNetOriginalAndResponse;
155 15 : break;
156 : case 4:
157 0 : aResult->variety = mozilla::net::nsHttpHeaderArray::eVarietyResponseNetOriginal;
158 0 : break;
159 : case 5:
160 3 : aResult->variety = mozilla::net::nsHttpHeaderArray::eVarietyResponse;
161 3 : break;
162 : default:
163 0 : return false;
164 : }
165 :
166 39 : return true;
167 : }
168 : };
169 :
170 :
171 : template<>
172 : struct ParamTraits<mozilla::net::nsHttpHeaderArray>
173 : {
174 : typedef mozilla::net::nsHttpHeaderArray paramType;
175 :
176 6 : static void Write(Message* aMsg, const paramType& aParam)
177 : {
178 6 : paramType& p = const_cast<paramType&>(aParam);
179 :
180 6 : WriteParam(aMsg, p.mHeaders);
181 6 : }
182 :
183 6 : static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
184 : {
185 6 : if (!ReadParam(aMsg, aIter, &aResult->mHeaders))
186 0 : return false;
187 :
188 6 : return true;
189 : }
190 : };
191 :
192 : template<>
193 : struct ParamTraits<mozilla::net::nsHttpResponseHead>
194 : {
195 : typedef mozilla::net::nsHttpResponseHead paramType;
196 :
197 3 : static void Write(Message* aMsg, const paramType& aParam)
198 : {
199 3 : WriteParam(aMsg, aParam.mHeaders);
200 3 : WriteParam(aMsg, aParam.mVersion);
201 3 : WriteParam(aMsg, aParam.mStatus);
202 3 : WriteParam(aMsg, aParam.mStatusText);
203 3 : WriteParam(aMsg, aParam.mContentLength);
204 3 : WriteParam(aMsg, aParam.mContentType);
205 3 : WriteParam(aMsg, aParam.mContentCharset);
206 3 : WriteParam(aMsg, aParam.mCacheControlPrivate);
207 3 : WriteParam(aMsg, aParam.mCacheControlNoStore);
208 3 : WriteParam(aMsg, aParam.mCacheControlNoCache);
209 3 : WriteParam(aMsg, aParam.mPragmaNoCache);
210 3 : }
211 :
212 3 : static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
213 : {
214 9 : if (!ReadParam(aMsg, aIter, &aResult->mHeaders) ||
215 6 : !ReadParam(aMsg, aIter, &aResult->mVersion) ||
216 6 : !ReadParam(aMsg, aIter, &aResult->mStatus) ||
217 6 : !ReadParam(aMsg, aIter, &aResult->mStatusText) ||
218 6 : !ReadParam(aMsg, aIter, &aResult->mContentLength) ||
219 6 : !ReadParam(aMsg, aIter, &aResult->mContentType) ||
220 6 : !ReadParam(aMsg, aIter, &aResult->mContentCharset) ||
221 6 : !ReadParam(aMsg, aIter, &aResult->mCacheControlPrivate) ||
222 6 : !ReadParam(aMsg, aIter, &aResult->mCacheControlNoStore) ||
223 9 : !ReadParam(aMsg, aIter, &aResult->mCacheControlNoCache) ||
224 3 : !ReadParam(aMsg, aIter, &aResult->mPragmaNoCache))
225 0 : return false;
226 :
227 3 : return true;
228 : }
229 : };
230 :
231 : } // namespace IPC
232 :
233 : #endif // mozilla_net_PHttpChannelParams_h
|
