OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright (C) 2009 Google Inc. All rights reserved. | |
3 * | |
4 * Redistribution and use in source and binary forms, with or without | |
5 * modification, are permitted provided that the following conditions are | |
6 * met: | |
7 * | |
8 * * Redistributions of source code must retain the above copyright | |
9 * notice, this list of conditions and the following disclaimer. | |
10 * * Redistributions in binary form must reproduce the above | |
11 * copyright notice, this list of conditions and the following disclaimer | |
12 * in the documentation and/or other materials provided with the | |
13 * distribution. | |
14 * * Neither the name of Google Inc. nor the names of its | |
15 * contributors may be used to endorse or promote products derived from | |
16 * this software without specific prior written permission. | |
17 * | |
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
29 */ | |
30 | |
31 #include "config.h" | |
32 #include "public/platform/WebURLRequest.h" | |
33 | |
34 #include "core/platform/chromium/support/WebURLRequestPrivate.h" | |
35 #include "core/platform/network/ResourceRequest.h" | |
36 #include "public/platform/WebHTTPBody.h" | |
37 #include "public/platform/WebHTTPHeaderVisitor.h" | |
38 #include "public/platform/WebURL.h" | |
39 | |
40 using namespace WebCore; | |
41 | |
42 namespace WebKit { | |
43 | |
44 namespace { | |
45 | |
46 class ExtraDataContainer : public ResourceRequest::ExtraData { | |
47 public: | |
48 static PassRefPtr<ExtraDataContainer> create(WebURLRequest::ExtraData* extra
Data) { return adoptRef(new ExtraDataContainer(extraData)); } | |
49 | |
50 virtual ~ExtraDataContainer() { } | |
51 | |
52 WebURLRequest::ExtraData* extraData() const { return m_extraData.get(); } | |
53 | |
54 private: | |
55 explicit ExtraDataContainer(WebURLRequest::ExtraData* extraData) | |
56 : m_extraData(adoptPtr(extraData)) | |
57 { | |
58 } | |
59 | |
60 OwnPtr<WebURLRequest::ExtraData> m_extraData; | |
61 }; | |
62 | |
63 } // namespace | |
64 | |
65 // The standard implementation of WebURLRequestPrivate, which maintains | |
66 // ownership of a ResourceRequest instance. | |
67 class WebURLRequestPrivateImpl : public WebURLRequestPrivate { | |
68 public: | |
69 WebURLRequestPrivateImpl() | |
70 { | |
71 m_resourceRequest = &m_resourceRequestAllocation; | |
72 } | |
73 | |
74 WebURLRequestPrivateImpl(const WebURLRequestPrivate* p) | |
75 : m_resourceRequestAllocation(*p->m_resourceRequest) | |
76 { | |
77 m_resourceRequest = &m_resourceRequestAllocation; | |
78 m_allowStoredCredentials = p->m_allowStoredCredentials; | |
79 } | |
80 | |
81 virtual void dispose() { delete this; } | |
82 | |
83 private: | |
84 virtual ~WebURLRequestPrivateImpl() { } | |
85 | |
86 ResourceRequest m_resourceRequestAllocation; | |
87 }; | |
88 | |
89 void WebURLRequest::initialize() | |
90 { | |
91 assign(new WebURLRequestPrivateImpl()); | |
92 } | |
93 | |
94 void WebURLRequest::reset() | |
95 { | |
96 assign(0); | |
97 } | |
98 | |
99 void WebURLRequest::assign(const WebURLRequest& r) | |
100 { | |
101 if (&r != this) | |
102 assign(r.m_private ? new WebURLRequestPrivateImpl(r.m_private) : 0); | |
103 } | |
104 | |
105 bool WebURLRequest::isNull() const | |
106 { | |
107 return !m_private || m_private->m_resourceRequest->isNull(); | |
108 } | |
109 | |
110 WebURL WebURLRequest::url() const | |
111 { | |
112 return m_private->m_resourceRequest->url(); | |
113 } | |
114 | |
115 void WebURLRequest::setURL(const WebURL& url) | |
116 { | |
117 m_private->m_resourceRequest->setURL(url); | |
118 } | |
119 | |
120 WebURL WebURLRequest::firstPartyForCookies() const | |
121 { | |
122 return m_private->m_resourceRequest->firstPartyForCookies(); | |
123 } | |
124 | |
125 void WebURLRequest::setFirstPartyForCookies(const WebURL& firstPartyForCookies) | |
126 { | |
127 m_private->m_resourceRequest->setFirstPartyForCookies(firstPartyForCookies); | |
128 } | |
129 | |
130 bool WebURLRequest::allowCookies() const | |
131 { | |
132 return m_private->m_resourceRequest->allowCookies(); | |
133 } | |
134 | |
135 void WebURLRequest::setAllowCookies(bool allowCookies) | |
136 { | |
137 m_private->m_resourceRequest->setAllowCookies(allowCookies); | |
138 } | |
139 | |
140 bool WebURLRequest::allowStoredCredentials() const | |
141 { | |
142 return m_private->m_allowStoredCredentials; | |
143 } | |
144 | |
145 void WebURLRequest::setAllowStoredCredentials(bool allowStoredCredentials) | |
146 { | |
147 m_private->m_allowStoredCredentials = allowStoredCredentials; | |
148 } | |
149 | |
150 WebURLRequest::CachePolicy WebURLRequest::cachePolicy() const | |
151 { | |
152 return static_cast<WebURLRequest::CachePolicy>( | |
153 m_private->m_resourceRequest->cachePolicy()); | |
154 } | |
155 | |
156 void WebURLRequest::setCachePolicy(CachePolicy cachePolicy) | |
157 { | |
158 m_private->m_resourceRequest->setCachePolicy( | |
159 static_cast<ResourceRequestCachePolicy>(cachePolicy)); | |
160 } | |
161 | |
162 WebString WebURLRequest::httpMethod() const | |
163 { | |
164 return m_private->m_resourceRequest->httpMethod(); | |
165 } | |
166 | |
167 void WebURLRequest::setHTTPMethod(const WebString& httpMethod) | |
168 { | |
169 m_private->m_resourceRequest->setHTTPMethod(httpMethod); | |
170 } | |
171 | |
172 WebString WebURLRequest::httpHeaderField(const WebString& name) const | |
173 { | |
174 return m_private->m_resourceRequest->httpHeaderField(name); | |
175 } | |
176 | |
177 void WebURLRequest::setHTTPHeaderField(const WebString& name, const WebString& v
alue) | |
178 { | |
179 m_private->m_resourceRequest->setHTTPHeaderField(name, value); | |
180 } | |
181 | |
182 void WebURLRequest::addHTTPHeaderField(const WebString& name, const WebString& v
alue) | |
183 { | |
184 m_private->m_resourceRequest->addHTTPHeaderField(name, value); | |
185 } | |
186 | |
187 void WebURLRequest::clearHTTPHeaderField(const WebString& name) | |
188 { | |
189 m_private->m_resourceRequest->clearHTTPHeaderField(name); | |
190 } | |
191 | |
192 void WebURLRequest::visitHTTPHeaderFields(WebHTTPHeaderVisitor* visitor) const | |
193 { | |
194 const HTTPHeaderMap& map = m_private->m_resourceRequest->httpHeaderFields(); | |
195 for (HTTPHeaderMap::const_iterator it = map.begin(); it != map.end(); ++it) | |
196 visitor->visitHeader(it->key, it->value); | |
197 } | |
198 | |
199 WebHTTPBody WebURLRequest::httpBody() const | |
200 { | |
201 return WebHTTPBody(m_private->m_resourceRequest->httpBody()); | |
202 } | |
203 | |
204 void WebURLRequest::setHTTPBody(const WebHTTPBody& httpBody) | |
205 { | |
206 m_private->m_resourceRequest->setHTTPBody(httpBody); | |
207 } | |
208 | |
209 bool WebURLRequest::reportUploadProgress() const | |
210 { | |
211 return m_private->m_resourceRequest->reportUploadProgress(); | |
212 } | |
213 | |
214 void WebURLRequest::setReportUploadProgress(bool reportUploadProgress) | |
215 { | |
216 m_private->m_resourceRequest->setReportUploadProgress(reportUploadProgress); | |
217 } | |
218 | |
219 bool WebURLRequest::reportLoadTiming() const | |
220 { | |
221 return m_private->m_resourceRequest->reportLoadTiming(); | |
222 } | |
223 | |
224 void WebURLRequest::setReportRawHeaders(bool reportRawHeaders) | |
225 { | |
226 m_private->m_resourceRequest->setReportRawHeaders(reportRawHeaders); | |
227 } | |
228 | |
229 bool WebURLRequest::reportRawHeaders() const | |
230 { | |
231 return m_private->m_resourceRequest->reportRawHeaders(); | |
232 } | |
233 | |
234 void WebURLRequest::setReportLoadTiming(bool reportLoadTiming) | |
235 { | |
236 m_private->m_resourceRequest->setReportLoadTiming(reportLoadTiming); | |
237 } | |
238 | |
239 WebURLRequest::TargetType WebURLRequest::targetType() const | |
240 { | |
241 // FIXME: Temporary special case until downstream chromium.org knows of the
new TargetTypes. | |
242 TargetType targetType = static_cast<TargetType>(m_private->m_resourceRequest
->targetType()); | |
243 if (targetType == TargetIsTextTrack || targetType == TargetIsUnspecified) | |
244 return TargetIsSubresource; | |
245 return targetType; | |
246 } | |
247 | |
248 bool WebURLRequest::hasUserGesture() const | |
249 { | |
250 return m_private->m_resourceRequest->hasUserGesture(); | |
251 } | |
252 | |
253 void WebURLRequest::setHasUserGesture(bool hasUserGesture) | |
254 { | |
255 m_private->m_resourceRequest->setHasUserGesture(hasUserGesture); | |
256 } | |
257 | |
258 void WebURLRequest::setTargetType(TargetType targetType) | |
259 { | |
260 m_private->m_resourceRequest->setTargetType( | |
261 static_cast<ResourceRequest::TargetType>(targetType)); | |
262 } | |
263 | |
264 int WebURLRequest::requestorID() const | |
265 { | |
266 return m_private->m_resourceRequest->requestorID(); | |
267 } | |
268 | |
269 void WebURLRequest::setRequestorID(int requestorID) | |
270 { | |
271 m_private->m_resourceRequest->setRequestorID(requestorID); | |
272 } | |
273 | |
274 int WebURLRequest::requestorProcessID() const | |
275 { | |
276 return m_private->m_resourceRequest->requestorProcessID(); | |
277 } | |
278 | |
279 void WebURLRequest::setRequestorProcessID(int requestorProcessID) | |
280 { | |
281 m_private->m_resourceRequest->setRequestorProcessID(requestorProcessID); | |
282 } | |
283 | |
284 int WebURLRequest::appCacheHostID() const | |
285 { | |
286 return m_private->m_resourceRequest->appCacheHostID(); | |
287 } | |
288 | |
289 void WebURLRequest::setAppCacheHostID(int appCacheHostID) | |
290 { | |
291 m_private->m_resourceRequest->setAppCacheHostID(appCacheHostID); | |
292 } | |
293 | |
294 bool WebURLRequest::downloadToFile() const | |
295 { | |
296 return m_private->m_resourceRequest->downloadToFile(); | |
297 } | |
298 | |
299 void WebURLRequest::setDownloadToFile(bool downloadToFile) | |
300 { | |
301 m_private->m_resourceRequest->setDownloadToFile(downloadToFile); | |
302 } | |
303 | |
304 WebURLRequest::ExtraData* WebURLRequest::extraData() const | |
305 { | |
306 RefPtr<ResourceRequest::ExtraData> data = m_private->m_resourceRequest->extr
aData(); | |
307 if (!data) | |
308 return 0; | |
309 return static_cast<ExtraDataContainer*>(data.get())->extraData(); | |
310 } | |
311 | |
312 void WebURLRequest::setExtraData(WebURLRequest::ExtraData* extraData) | |
313 { | |
314 m_private->m_resourceRequest->setExtraData(ExtraDataContainer::create(extraD
ata)); | |
315 } | |
316 | |
317 ResourceRequest& WebURLRequest::toMutableResourceRequest() | |
318 { | |
319 ASSERT(m_private); | |
320 ASSERT(m_private->m_resourceRequest); | |
321 | |
322 return *m_private->m_resourceRequest; | |
323 } | |
324 | |
325 WebURLRequest::Priority WebURLRequest::priority() const | |
326 { | |
327 return static_cast<WebURLRequest::Priority>( | |
328 m_private->m_resourceRequest->priority()); | |
329 } | |
330 | |
331 const ResourceRequest& WebURLRequest::toResourceRequest() const | |
332 { | |
333 ASSERT(m_private); | |
334 ASSERT(m_private->m_resourceRequest); | |
335 | |
336 return *m_private->m_resourceRequest; | |
337 } | |
338 | |
339 void WebURLRequest::assign(WebURLRequestPrivate* p) | |
340 { | |
341 // Subclasses may call this directly so a self-assignment check is needed | |
342 // here as well as in the public assign method. | |
343 if (m_private == p) | |
344 return; | |
345 if (m_private) | |
346 m_private->dispose(); | |
347 m_private = p; | |
348 } | |
349 | |
350 } // namespace WebKit | |
OLD | NEW |