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/WebURLResponse.h" | |
32 | |
33 #include "sky/engine/platform/exported/WebURLResponsePrivate.h" | |
34 #include "sky/engine/platform/network/ResourceLoadTiming.h" | |
35 #include "sky/engine/platform/network/ResourceResponse.h" | |
36 #include "sky/engine/public/platform/WebHTTPHeaderVisitor.h" | |
37 #include "sky/engine/public/platform/WebHTTPLoadInfo.h" | |
38 #include "sky/engine/public/platform/WebString.h" | |
39 #include "sky/engine/public/platform/WebURL.h" | |
40 #include "sky/engine/public/platform/WebURLLoadTiming.h" | |
41 #include "sky/engine/wtf/RefPtr.h" | |
42 | |
43 namespace blink { | |
44 | |
45 namespace { | |
46 | |
47 class ExtraDataContainer : public ResourceResponse::ExtraData { | |
48 public: | |
49 static PassRefPtr<ExtraDataContainer> create(WebURLResponse::ExtraData* extr
aData) { return adoptRef(new ExtraDataContainer(extraData)); } | |
50 | |
51 virtual ~ExtraDataContainer() { } | |
52 | |
53 WebURLResponse::ExtraData* extraData() const { return m_extraData.get(); } | |
54 | |
55 private: | |
56 explicit ExtraDataContainer(WebURLResponse::ExtraData* extraData) | |
57 : m_extraData(adoptPtr(extraData)) | |
58 { | |
59 } | |
60 | |
61 OwnPtr<WebURLResponse::ExtraData> m_extraData; | |
62 }; | |
63 | |
64 } // namespace | |
65 | |
66 // The standard implementation of WebURLResponsePrivate, which maintains | |
67 // ownership of a ResourceResponse instance. | |
68 class WebURLResponsePrivateImpl : public WebURLResponsePrivate { | |
69 public: | |
70 WebURLResponsePrivateImpl() | |
71 { | |
72 m_resourceResponse = &m_resourceResponseAllocation; | |
73 } | |
74 | |
75 WebURLResponsePrivateImpl(const WebURLResponsePrivate* p) | |
76 : m_resourceResponseAllocation(*p->m_resourceResponse) | |
77 { | |
78 m_resourceResponse = &m_resourceResponseAllocation; | |
79 } | |
80 | |
81 virtual void dispose() { delete this; } | |
82 | |
83 private: | |
84 virtual ~WebURLResponsePrivateImpl() { } | |
85 | |
86 ResourceResponse m_resourceResponseAllocation; | |
87 }; | |
88 | |
89 void WebURLResponse::initialize() | |
90 { | |
91 assign(new WebURLResponsePrivateImpl()); | |
92 } | |
93 | |
94 void WebURLResponse::reset() | |
95 { | |
96 assign(0); | |
97 } | |
98 | |
99 void WebURLResponse::assign(const WebURLResponse& r) | |
100 { | |
101 if (&r != this) | |
102 assign(r.m_private ? new WebURLResponsePrivateImpl(r.m_private) : 0); | |
103 } | |
104 | |
105 bool WebURLResponse::isNull() const | |
106 { | |
107 return !m_private || m_private->m_resourceResponse->isNull(); | |
108 } | |
109 | |
110 WebURL WebURLResponse::url() const | |
111 { | |
112 return m_private->m_resourceResponse->url(); | |
113 } | |
114 | |
115 void WebURLResponse::setURL(const WebURL& url) | |
116 { | |
117 m_private->m_resourceResponse->setURL(url); | |
118 } | |
119 | |
120 unsigned WebURLResponse::connectionID() const | |
121 { | |
122 return m_private->m_resourceResponse->connectionID(); | |
123 } | |
124 | |
125 void WebURLResponse::setConnectionID(unsigned connectionID) | |
126 { | |
127 m_private->m_resourceResponse->setConnectionID(connectionID); | |
128 } | |
129 | |
130 bool WebURLResponse::connectionReused() const | |
131 { | |
132 return m_private->m_resourceResponse->connectionReused(); | |
133 } | |
134 | |
135 void WebURLResponse::setConnectionReused(bool connectionReused) | |
136 { | |
137 m_private->m_resourceResponse->setConnectionReused(connectionReused); | |
138 } | |
139 | |
140 WebURLLoadTiming WebURLResponse::loadTiming() | |
141 { | |
142 return WebURLLoadTiming(m_private->m_resourceResponse->resourceLoadTiming())
; | |
143 } | |
144 | |
145 void WebURLResponse::setLoadTiming(const WebURLLoadTiming& timing) | |
146 { | |
147 RefPtr<ResourceLoadTiming> loadTiming = PassRefPtr<ResourceLoadTiming>(timin
g); | |
148 m_private->m_resourceResponse->setResourceLoadTiming(loadTiming.release()); | |
149 } | |
150 | |
151 WebHTTPLoadInfo WebURLResponse::httpLoadInfo() | |
152 { | |
153 return WebHTTPLoadInfo(m_private->m_resourceResponse->resourceLoadInfo()); | |
154 } | |
155 | |
156 void WebURLResponse::setHTTPLoadInfo(const WebHTTPLoadInfo& value) | |
157 { | |
158 m_private->m_resourceResponse->setResourceLoadInfo(value); | |
159 } | |
160 | |
161 double WebURLResponse::responseTime() const | |
162 { | |
163 return m_private->m_resourceResponse->responseTime(); | |
164 } | |
165 | |
166 void WebURLResponse::setResponseTime(double responseTime) | |
167 { | |
168 m_private->m_resourceResponse->setResponseTime(responseTime); | |
169 } | |
170 | |
171 WebString WebURLResponse::mimeType() const | |
172 { | |
173 return m_private->m_resourceResponse->mimeType(); | |
174 } | |
175 | |
176 void WebURLResponse::setMIMEType(const WebString& mimeType) | |
177 { | |
178 m_private->m_resourceResponse->setMimeType(mimeType); | |
179 } | |
180 | |
181 long long WebURLResponse::expectedContentLength() const | |
182 { | |
183 return m_private->m_resourceResponse->expectedContentLength(); | |
184 } | |
185 | |
186 void WebURLResponse::setExpectedContentLength(long long expectedContentLength) | |
187 { | |
188 m_private->m_resourceResponse->setExpectedContentLength(expectedContentLengt
h); | |
189 } | |
190 | |
191 WebString WebURLResponse::textEncodingName() const | |
192 { | |
193 return m_private->m_resourceResponse->textEncodingName(); | |
194 } | |
195 | |
196 void WebURLResponse::setTextEncodingName(const WebString& textEncodingName) | |
197 { | |
198 m_private->m_resourceResponse->setTextEncodingName(textEncodingName); | |
199 } | |
200 | |
201 WebString WebURLResponse::suggestedFileName() const | |
202 { | |
203 return m_private->m_resourceResponse->suggestedFilename(); | |
204 } | |
205 | |
206 void WebURLResponse::setSuggestedFileName(const WebString& suggestedFileName) | |
207 { | |
208 m_private->m_resourceResponse->setSuggestedFilename(suggestedFileName); | |
209 } | |
210 | |
211 WebURLResponse::HTTPVersion WebURLResponse::httpVersion() const | |
212 { | |
213 return static_cast<HTTPVersion>(m_private->m_resourceResponse->httpVersion()
); | |
214 } | |
215 | |
216 void WebURLResponse::setHTTPVersion(HTTPVersion version) | |
217 { | |
218 m_private->m_resourceResponse->setHTTPVersion(static_cast<ResourceResponse::
HTTPVersion>(version)); | |
219 } | |
220 | |
221 int WebURLResponse::httpStatusCode() const | |
222 { | |
223 return m_private->m_resourceResponse->httpStatusCode(); | |
224 } | |
225 | |
226 void WebURLResponse::setHTTPStatusCode(int httpStatusCode) | |
227 { | |
228 m_private->m_resourceResponse->setHTTPStatusCode(httpStatusCode); | |
229 } | |
230 | |
231 WebString WebURLResponse::httpStatusText() const | |
232 { | |
233 return m_private->m_resourceResponse->httpStatusText(); | |
234 } | |
235 | |
236 void WebURLResponse::setHTTPStatusText(const WebString& httpStatusText) | |
237 { | |
238 m_private->m_resourceResponse->setHTTPStatusText(httpStatusText); | |
239 } | |
240 | |
241 WebString WebURLResponse::httpHeaderField(const WebString& name) const | |
242 { | |
243 return m_private->m_resourceResponse->httpHeaderField(name); | |
244 } | |
245 | |
246 void WebURLResponse::setHTTPHeaderField(const WebString& name, const WebString&
value) | |
247 { | |
248 m_private->m_resourceResponse->setHTTPHeaderField(name, value); | |
249 } | |
250 | |
251 void WebURLResponse::addHTTPHeaderField(const WebString& name, const WebString&
value) | |
252 { | |
253 if (name.isNull() || value.isNull()) | |
254 return; | |
255 | |
256 m_private->m_resourceResponse->addHTTPHeaderField(name, value); | |
257 } | |
258 | |
259 void WebURLResponse::clearHTTPHeaderField(const WebString& name) | |
260 { | |
261 m_private->m_resourceResponse->clearHTTPHeaderField(name); | |
262 } | |
263 | |
264 void WebURLResponse::visitHTTPHeaderFields(WebHTTPHeaderVisitor* visitor) const | |
265 { | |
266 const HTTPHeaderMap& map = m_private->m_resourceResponse->httpHeaderFields()
; | |
267 for (HTTPHeaderMap::const_iterator it = map.begin(); it != map.end(); ++it) | |
268 visitor->visitHeader(it->key, it->value); | |
269 } | |
270 | |
271 double WebURLResponse::lastModifiedDate() const | |
272 { | |
273 return static_cast<double>(m_private->m_resourceResponse->lastModifiedDate()
); | |
274 } | |
275 | |
276 void WebURLResponse::setLastModifiedDate(double lastModifiedDate) | |
277 { | |
278 m_private->m_resourceResponse->setLastModifiedDate(static_cast<time_t>(lastM
odifiedDate)); | |
279 } | |
280 | |
281 WebCString WebURLResponse::securityInfo() const | |
282 { | |
283 // FIXME: getSecurityInfo is misnamed. | |
284 return m_private->m_resourceResponse->getSecurityInfo(); | |
285 } | |
286 | |
287 void WebURLResponse::setSecurityInfo(const WebCString& securityInfo) | |
288 { | |
289 m_private->m_resourceResponse->setSecurityInfo(securityInfo); | |
290 } | |
291 | |
292 ResourceResponse& WebURLResponse::toMutableResourceResponse() | |
293 { | |
294 ASSERT(m_private); | |
295 ASSERT(m_private->m_resourceResponse); | |
296 | |
297 return *m_private->m_resourceResponse; | |
298 } | |
299 | |
300 const ResourceResponse& WebURLResponse::toResourceResponse() const | |
301 { | |
302 ASSERT(m_private); | |
303 ASSERT(m_private->m_resourceResponse); | |
304 | |
305 return *m_private->m_resourceResponse; | |
306 } | |
307 | |
308 bool WebURLResponse::wasCached() const | |
309 { | |
310 return m_private->m_resourceResponse->wasCached(); | |
311 } | |
312 | |
313 void WebURLResponse::setWasCached(bool value) | |
314 { | |
315 m_private->m_resourceResponse->setWasCached(value); | |
316 } | |
317 | |
318 bool WebURLResponse::wasFetchedViaSPDY() const | |
319 { | |
320 return m_private->m_resourceResponse->wasFetchedViaSPDY(); | |
321 } | |
322 | |
323 void WebURLResponse::setWasFetchedViaSPDY(bool value) | |
324 { | |
325 m_private->m_resourceResponse->setWasFetchedViaSPDY(value); | |
326 } | |
327 | |
328 bool WebURLResponse::wasNpnNegotiated() const | |
329 { | |
330 return m_private->m_resourceResponse->wasNpnNegotiated(); | |
331 } | |
332 | |
333 void WebURLResponse::setWasNpnNegotiated(bool value) | |
334 { | |
335 m_private->m_resourceResponse->setWasNpnNegotiated(value); | |
336 } | |
337 | |
338 bool WebURLResponse::wasAlternateProtocolAvailable() const | |
339 { | |
340 return m_private->m_resourceResponse->wasAlternateProtocolAvailable(); | |
341 } | |
342 | |
343 void WebURLResponse::setWasAlternateProtocolAvailable(bool value) | |
344 { | |
345 m_private->m_resourceResponse->setWasAlternateProtocolAvailable(value); | |
346 } | |
347 | |
348 bool WebURLResponse::wasFetchedViaProxy() const | |
349 { | |
350 return m_private->m_resourceResponse->wasFetchedViaProxy(); | |
351 } | |
352 | |
353 void WebURLResponse::setWasFetchedViaProxy(bool value) | |
354 { | |
355 m_private->m_resourceResponse->setWasFetchedViaProxy(value); | |
356 } | |
357 | |
358 bool WebURLResponse::wasFetchedViaServiceWorker() const | |
359 { | |
360 return false; | |
361 } | |
362 | |
363 void WebURLResponse::setWasFetchedViaServiceWorker(bool value) | |
364 { | |
365 } | |
366 | |
367 bool WebURLResponse::isMultipartPayload() const | |
368 { | |
369 return m_private->m_resourceResponse->isMultipartPayload(); | |
370 } | |
371 | |
372 void WebURLResponse::setIsMultipartPayload(bool value) | |
373 { | |
374 m_private->m_resourceResponse->setIsMultipartPayload(value); | |
375 } | |
376 | |
377 WebString WebURLResponse::downloadFilePath() const | |
378 { | |
379 return m_private->m_resourceResponse->downloadedFilePath(); | |
380 } | |
381 | |
382 void WebURLResponse::setDownloadFilePath(const WebString& downloadFilePath) | |
383 { | |
384 m_private->m_resourceResponse->setDownloadedFilePath(downloadFilePath); | |
385 } | |
386 | |
387 WebString WebURLResponse::remoteIPAddress() const | |
388 { | |
389 return m_private->m_resourceResponse->remoteIPAddress(); | |
390 } | |
391 | |
392 void WebURLResponse::setRemoteIPAddress(const WebString& remoteIPAddress) | |
393 { | |
394 m_private->m_resourceResponse->setRemoteIPAddress(remoteIPAddress); | |
395 } | |
396 | |
397 unsigned short WebURLResponse::remotePort() const | |
398 { | |
399 return m_private->m_resourceResponse->remotePort(); | |
400 } | |
401 | |
402 void WebURLResponse::setRemotePort(unsigned short remotePort) | |
403 { | |
404 m_private->m_resourceResponse->setRemotePort(remotePort); | |
405 } | |
406 | |
407 WebURLResponse::ExtraData* WebURLResponse::extraData() const | |
408 { | |
409 RefPtr<ResourceResponse::ExtraData> data = m_private->m_resourceResponse->ex
traData(); | |
410 if (!data) | |
411 return 0; | |
412 return static_cast<ExtraDataContainer*>(data.get())->extraData(); | |
413 } | |
414 | |
415 void WebURLResponse::setExtraData(WebURLResponse::ExtraData* extraData) | |
416 { | |
417 m_private->m_resourceResponse->setExtraData(ExtraDataContainer::create(extra
Data)); | |
418 } | |
419 | |
420 void WebURLResponse::assign(WebURLResponsePrivate* p) | |
421 { | |
422 // Subclasses may call this directly so a self-assignment check is needed | |
423 // here as well as in the public assign method. | |
424 if (m_private == p) | |
425 return; | |
426 if (m_private) | |
427 m_private->dispose(); | |
428 m_private = p; | |
429 } | |
430 | |
431 } // namespace blink | |
OLD | NEW |