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 "sky/engine/public/platform/WebURLRequest.h" | |
32 | |
33 #include "sky/engine/platform/exported/WebURLRequestPrivate.h" | |
34 #include "sky/engine/platform/network/ResourceRequest.h" | |
35 #include "sky/engine/public/platform/WebHTTPBody.h" | |
36 #include "sky/engine/public/platform/WebHTTPHeaderVisitor.h" | |
37 #include "sky/engine/public/platform/WebURL.h" | |
38 | |
39 namespace blink { | |
40 | |
41 namespace { | |
42 | |
43 class ExtraDataContainer : public ResourceRequest::ExtraData { | |
44 public: | |
45 static PassRefPtr<ExtraDataContainer> create(WebURLRequest::ExtraData* extra
Data) { return adoptRef(new ExtraDataContainer(extraData)); } | |
46 | |
47 virtual ~ExtraDataContainer() { } | |
48 | |
49 WebURLRequest::ExtraData* extraData() const { return m_extraData.get(); } | |
50 | |
51 private: | |
52 explicit ExtraDataContainer(WebURLRequest::ExtraData* extraData) | |
53 : m_extraData(adoptPtr(extraData)) | |
54 { | |
55 } | |
56 | |
57 OwnPtr<WebURLRequest::ExtraData> m_extraData; | |
58 }; | |
59 | |
60 } // namespace | |
61 | |
62 // The standard implementation of WebURLRequestPrivate, which maintains | |
63 // ownership of a ResourceRequest instance. | |
64 class WebURLRequestPrivateImpl : public WebURLRequestPrivate { | |
65 public: | |
66 WebURLRequestPrivateImpl() | |
67 { | |
68 m_resourceRequest = &m_resourceRequestAllocation; | |
69 } | |
70 | |
71 WebURLRequestPrivateImpl(const WebURLRequestPrivate* p) | |
72 : m_resourceRequestAllocation(*p->m_resourceRequest) | |
73 { | |
74 m_resourceRequest = &m_resourceRequestAllocation; | |
75 } | |
76 | |
77 virtual void dispose() { delete this; } | |
78 | |
79 private: | |
80 virtual ~WebURLRequestPrivateImpl() { } | |
81 | |
82 ResourceRequest m_resourceRequestAllocation; | |
83 }; | |
84 | |
85 void WebURLRequest::initialize() | |
86 { | |
87 assign(new WebURLRequestPrivateImpl()); | |
88 } | |
89 | |
90 void WebURLRequest::reset() | |
91 { | |
92 assign(0); | |
93 } | |
94 | |
95 void WebURLRequest::assign(const WebURLRequest& r) | |
96 { | |
97 if (&r != this) | |
98 assign(r.m_private ? new WebURLRequestPrivateImpl(r.m_private) : 0); | |
99 } | |
100 | |
101 bool WebURLRequest::isNull() const | |
102 { | |
103 return !m_private || m_private->m_resourceRequest->isNull(); | |
104 } | |
105 | |
106 WebURL WebURLRequest::url() const | |
107 { | |
108 return m_private->m_resourceRequest->url(); | |
109 } | |
110 | |
111 void WebURLRequest::setURL(const WebURL& url) | |
112 { | |
113 m_private->m_resourceRequest->setURL(url); | |
114 } | |
115 | |
116 bool WebURLRequest::allowStoredCredentials() const | |
117 { | |
118 return m_private->m_resourceRequest->allowStoredCredentials(); | |
119 } | |
120 | |
121 void WebURLRequest::setAllowStoredCredentials(bool allowStoredCredentials) | |
122 { | |
123 m_private->m_resourceRequest->setAllowStoredCredentials(allowStoredCredentia
ls); | |
124 } | |
125 | |
126 WebURLRequest::CachePolicy WebURLRequest::cachePolicy() const | |
127 { | |
128 return static_cast<WebURLRequest::CachePolicy>( | |
129 m_private->m_resourceRequest->cachePolicy()); | |
130 } | |
131 | |
132 void WebURLRequest::setCachePolicy(CachePolicy cachePolicy) | |
133 { | |
134 m_private->m_resourceRequest->setCachePolicy( | |
135 static_cast<ResourceRequestCachePolicy>(cachePolicy)); | |
136 } | |
137 | |
138 WebString WebURLRequest::httpMethod() const | |
139 { | |
140 return m_private->m_resourceRequest->httpMethod(); | |
141 } | |
142 | |
143 void WebURLRequest::setHTTPMethod(const WebString& httpMethod) | |
144 { | |
145 m_private->m_resourceRequest->setHTTPMethod(httpMethod); | |
146 } | |
147 | |
148 WebString WebURLRequest::httpHeaderField(const WebString& name) const | |
149 { | |
150 return m_private->m_resourceRequest->httpHeaderField(name); | |
151 } | |
152 | |
153 void WebURLRequest::setHTTPHeaderField(const WebString& name, const WebString& v
alue) | |
154 { | |
155 RELEASE_ASSERT(!equalIgnoringCase(name, "referer")); | |
156 m_private->m_resourceRequest->setHTTPHeaderField(name, value); | |
157 } | |
158 | |
159 void WebURLRequest::setHTTPReferrer(const WebString& referrer, WebReferrerPolicy
referrerPolicy) | |
160 { | |
161 if (referrer.isEmpty()) | |
162 m_private->m_resourceRequest->clearHTTPReferrer(); | |
163 else | |
164 m_private->m_resourceRequest->setHTTPReferrer(Referrer(referrer, static_
cast<ReferrerPolicy>(referrerPolicy))); | |
165 } | |
166 | |
167 void WebURLRequest::addHTTPHeaderField(const WebString& name, const WebString& v
alue) | |
168 { | |
169 m_private->m_resourceRequest->addHTTPHeaderField(name, value); | |
170 } | |
171 | |
172 void WebURLRequest::clearHTTPHeaderField(const WebString& name) | |
173 { | |
174 m_private->m_resourceRequest->clearHTTPHeaderField(name); | |
175 } | |
176 | |
177 void WebURLRequest::visitHTTPHeaderFields(WebHTTPHeaderVisitor* visitor) const | |
178 { | |
179 const HTTPHeaderMap& map = m_private->m_resourceRequest->httpHeaderFields(); | |
180 for (HTTPHeaderMap::const_iterator it = map.begin(); it != map.end(); ++it) | |
181 visitor->visitHeader(it->key, it->value); | |
182 } | |
183 | |
184 WebHTTPBody WebURLRequest::httpBody() const | |
185 { | |
186 return WebHTTPBody(m_private->m_resourceRequest->httpBody()); | |
187 } | |
188 | |
189 void WebURLRequest::setHTTPBody(const WebHTTPBody& httpBody) | |
190 { | |
191 m_private->m_resourceRequest->setHTTPBody(httpBody); | |
192 } | |
193 | |
194 bool WebURLRequest::reportUploadProgress() const | |
195 { | |
196 return m_private->m_resourceRequest->reportUploadProgress(); | |
197 } | |
198 | |
199 void WebURLRequest::setReportUploadProgress(bool reportUploadProgress) | |
200 { | |
201 m_private->m_resourceRequest->setReportUploadProgress(reportUploadProgress); | |
202 } | |
203 | |
204 void WebURLRequest::setReportRawHeaders(bool reportRawHeaders) | |
205 { | |
206 m_private->m_resourceRequest->setReportRawHeaders(reportRawHeaders); | |
207 } | |
208 | |
209 bool WebURLRequest::reportRawHeaders() const | |
210 { | |
211 return m_private->m_resourceRequest->reportRawHeaders(); | |
212 } | |
213 | |
214 WebURLRequest::RequestContext WebURLRequest::requestContext() const | |
215 { | |
216 return m_private->m_resourceRequest->requestContext(); | |
217 } | |
218 | |
219 WebURLRequest::FrameType WebURLRequest::frameType() const | |
220 { | |
221 return m_private->m_resourceRequest->frameType(); | |
222 } | |
223 | |
224 WebReferrerPolicy WebURLRequest::referrerPolicy() const | |
225 { | |
226 return static_cast<WebReferrerPolicy>(m_private->m_resourceRequest->referrer
Policy()); | |
227 } | |
228 | |
229 void WebURLRequest::addHTTPOriginIfNeeded(const WebString& origin) | |
230 { | |
231 m_private->m_resourceRequest->addHTTPOriginIfNeeded(origin); | |
232 } | |
233 | |
234 void WebURLRequest::setRequestContext(RequestContext requestContext) | |
235 { | |
236 m_private->m_resourceRequest->setRequestContext(requestContext); | |
237 } | |
238 | |
239 void WebURLRequest::setFrameType(FrameType frameType) | |
240 { | |
241 m_private->m_resourceRequest->setFrameType(frameType); | |
242 } | |
243 | |
244 int WebURLRequest::requestorID() const | |
245 { | |
246 return m_private->m_resourceRequest->requestorID(); | |
247 } | |
248 | |
249 void WebURLRequest::setRequestorID(int requestorID) | |
250 { | |
251 m_private->m_resourceRequest->setRequestorID(requestorID); | |
252 } | |
253 | |
254 int WebURLRequest::requestorProcessID() const | |
255 { | |
256 return m_private->m_resourceRequest->requestorProcessID(); | |
257 } | |
258 | |
259 void WebURLRequest::setRequestorProcessID(int requestorProcessID) | |
260 { | |
261 m_private->m_resourceRequest->setRequestorProcessID(requestorProcessID); | |
262 } | |
263 | |
264 bool WebURLRequest::downloadToFile() const | |
265 { | |
266 return m_private->m_resourceRequest->downloadToFile(); | |
267 } | |
268 | |
269 void WebURLRequest::setDownloadToFile(bool downloadToFile) | |
270 { | |
271 m_private->m_resourceRequest->setDownloadToFile(downloadToFile); | |
272 } | |
273 | |
274 bool WebURLRequest::skipServiceWorker() const | |
275 { | |
276 return true; | |
277 } | |
278 | |
279 void WebURLRequest::setSkipServiceWorker(bool skipServiceWorker) | |
280 { | |
281 } | |
282 | |
283 WebURLRequest::ExtraData* WebURLRequest::extraData() const | |
284 { | |
285 RefPtr<ResourceRequest::ExtraData> data = m_private->m_resourceRequest->extr
aData(); | |
286 if (!data) | |
287 return 0; | |
288 return static_cast<ExtraDataContainer*>(data.get())->extraData(); | |
289 } | |
290 | |
291 void WebURLRequest::setExtraData(WebURLRequest::ExtraData* extraData) | |
292 { | |
293 m_private->m_resourceRequest->setExtraData(ExtraDataContainer::create(extraD
ata)); | |
294 } | |
295 | |
296 ResourceRequest& WebURLRequest::toMutableResourceRequest() | |
297 { | |
298 ASSERT(m_private); | |
299 ASSERT(m_private->m_resourceRequest); | |
300 | |
301 return *m_private->m_resourceRequest; | |
302 } | |
303 | |
304 WebURLRequest::Priority WebURLRequest::priority() const | |
305 { | |
306 return static_cast<WebURLRequest::Priority>( | |
307 m_private->m_resourceRequest->priority()); | |
308 } | |
309 | |
310 void WebURLRequest::setPriority(WebURLRequest::Priority priority) | |
311 { | |
312 m_private->m_resourceRequest->setPriority( | |
313 static_cast<ResourceLoadPriority>(priority)); | |
314 } | |
315 | |
316 const ResourceRequest& WebURLRequest::toResourceRequest() const | |
317 { | |
318 ASSERT(m_private); | |
319 ASSERT(m_private->m_resourceRequest); | |
320 | |
321 return *m_private->m_resourceRequest; | |
322 } | |
323 | |
324 void WebURLRequest::assign(WebURLRequestPrivate* p) | |
325 { | |
326 // Subclasses may call this directly so a self-assignment check is needed | |
327 // here as well as in the public assign method. | |
328 if (m_private == p) | |
329 return; | |
330 if (m_private) | |
331 m_private->dispose(); | |
332 m_private = p; | |
333 } | |
334 | |
335 } // namespace blink | |
OLD | NEW |