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 "WebURLRequest.h"
33
34#include "ResourceRequest.h"
35
36#include "WebHTTPBody.h"
37#include "WebHTTPHeaderVisitor.h"
38#include "WebURL.h"
39#include "WebURLRequestPrivate.h"
40
41using namespace WebCore;
42
43namespace WebKit {
44
45// The standard implementation of WebURLRequestPrivate, which maintains
46// ownership of a ResourceRequest instance.
47class WebURLRequestPrivateImpl : public WebURLRequestPrivate {
48public:
49    WebURLRequestPrivateImpl()
50    {
51        m_resourceRequest = &m_resourceRequestAllocation;
52    }
53
54    WebURLRequestPrivateImpl(const WebURLRequestPrivate* p)
55        : m_resourceRequestAllocation(*p->m_resourceRequest)
56    {
57        m_resourceRequest = &m_resourceRequestAllocation;
58        m_allowStoredCredentials = p->m_allowStoredCredentials;
59    }
60
61    virtual void dispose() { delete this; }
62
63    ResourceRequest m_resourceRequestAllocation;
64};
65
66void WebURLRequest::initialize()
67{
68    assign(new WebURLRequestPrivateImpl());
69}
70
71void WebURLRequest::reset()
72{
73    assign(0);
74}
75
76void WebURLRequest::assign(const WebURLRequest& r)
77{
78    if (&r != this)
79        assign(r.m_private ? new WebURLRequestPrivateImpl(r.m_private) : 0);
80}
81
82bool WebURLRequest::isNull() const
83{
84    return !m_private || m_private->m_resourceRequest->isNull();
85}
86
87WebURL WebURLRequest::url() const
88{
89    return m_private->m_resourceRequest->url();
90}
91
92void WebURLRequest::setURL(const WebURL& url)
93{
94    m_private->m_resourceRequest->setURL(url);
95}
96
97WebURL WebURLRequest::firstPartyForCookies() const
98{
99    return m_private->m_resourceRequest->firstPartyForCookies();
100}
101
102void WebURLRequest::setFirstPartyForCookies(const WebURL& firstPartyForCookies)
103{
104    m_private->m_resourceRequest->setFirstPartyForCookies(firstPartyForCookies);
105}
106
107bool WebURLRequest::allowCookies() const
108{
109    return m_private->m_resourceRequest->allowCookies();
110}
111
112void WebURLRequest::setAllowCookies(bool allowCookies)
113{
114    m_private->m_resourceRequest->setAllowCookies(allowCookies);
115}
116
117bool WebURLRequest::allowStoredCredentials() const
118{
119    return m_private->m_allowStoredCredentials;
120}
121
122void WebURLRequest::setAllowStoredCredentials(bool allowStoredCredentials)
123{
124    m_private->m_allowStoredCredentials = allowStoredCredentials;
125}
126
127WebURLRequest::CachePolicy WebURLRequest::cachePolicy() const
128{
129    return static_cast<WebURLRequest::CachePolicy>(
130        m_private->m_resourceRequest->cachePolicy());
131}
132
133void WebURLRequest::setCachePolicy(CachePolicy cachePolicy)
134{
135    m_private->m_resourceRequest->setCachePolicy(
136        static_cast<ResourceRequestCachePolicy>(cachePolicy));
137}
138
139WebString WebURLRequest::httpMethod() const
140{
141    return m_private->m_resourceRequest->httpMethod();
142}
143
144void WebURLRequest::setHTTPMethod(const WebString& httpMethod)
145{
146    m_private->m_resourceRequest->setHTTPMethod(httpMethod);
147}
148
149WebString WebURLRequest::httpHeaderField(const WebString& name) const
150{
151    return m_private->m_resourceRequest->httpHeaderField(name);
152}
153
154void WebURLRequest::setHTTPHeaderField(const WebString& name, const WebString& value)
155{
156    m_private->m_resourceRequest->setHTTPHeaderField(name, value);
157}
158
159void WebURLRequest::addHTTPHeaderField(const WebString& name, const WebString& value)
160{
161    m_private->m_resourceRequest->addHTTPHeaderField(name, value);
162}
163
164void WebURLRequest::clearHTTPHeaderField(const WebString& name)
165{
166    // FIXME: Add a clearHTTPHeaderField method to ResourceRequest.
167    const HTTPHeaderMap& map = m_private->m_resourceRequest->httpHeaderFields();
168    const_cast<HTTPHeaderMap*>(&map)->remove(name);
169}
170
171void WebURLRequest::visitHTTPHeaderFields(WebHTTPHeaderVisitor* visitor) const
172{
173    const HTTPHeaderMap& map = m_private->m_resourceRequest->httpHeaderFields();
174    for (HTTPHeaderMap::const_iterator it = map.begin(); it != map.end(); ++it)
175        visitor->visitHeader(it->first, it->second);
176}
177
178WebHTTPBody WebURLRequest::httpBody() const
179{
180    return WebHTTPBody(m_private->m_resourceRequest->httpBody());
181}
182
183void WebURLRequest::setHTTPBody(const WebHTTPBody& httpBody)
184{
185    m_private->m_resourceRequest->setHTTPBody(httpBody);
186}
187
188bool WebURLRequest::reportUploadProgress() const
189{
190    return m_private->m_resourceRequest->reportUploadProgress();
191}
192
193void WebURLRequest::setReportUploadProgress(bool reportUploadProgress)
194{
195    m_private->m_resourceRequest->setReportUploadProgress(reportUploadProgress);
196}
197
198bool WebURLRequest::reportLoadTiming() const
199{
200    return m_private->m_resourceRequest->reportLoadTiming();
201}
202
203void WebURLRequest::setReportRawHeaders(bool reportRawHeaders)
204{
205    m_private->m_resourceRequest->setReportRawHeaders(reportRawHeaders);
206}
207
208bool WebURLRequest::reportRawHeaders() const
209{
210    return m_private->m_resourceRequest->reportRawHeaders();
211}
212
213void WebURLRequest::setReportLoadTiming(bool reportLoadTiming)
214{
215    m_private->m_resourceRequest->setReportLoadTiming(reportLoadTiming);
216}
217
218WebURLRequest::TargetType WebURLRequest::targetType() const
219{
220    return static_cast<TargetType>(m_private->m_resourceRequest->targetType());
221}
222
223bool WebURLRequest::hasUserGesture() const
224{
225    return m_private->m_resourceRequest->hasUserGesture();
226}
227
228void WebURLRequest::setHasUserGesture(bool hasUserGesture)
229{
230    m_private->m_resourceRequest->setHasUserGesture(hasUserGesture);
231}
232
233void WebURLRequest::setTargetType(TargetType targetType)
234{
235    m_private->m_resourceRequest->setTargetType(
236        static_cast<ResourceRequest::TargetType>(targetType));
237}
238
239int WebURLRequest::requestorID() const
240{
241    return m_private->m_resourceRequest->requestorID();
242}
243
244void WebURLRequest::setRequestorID(int requestorID)
245{
246    m_private->m_resourceRequest->setRequestorID(requestorID);
247}
248
249int WebURLRequest::requestorProcessID() const
250{
251    return m_private->m_resourceRequest->requestorProcessID();
252}
253
254void WebURLRequest::setRequestorProcessID(int requestorProcessID)
255{
256    m_private->m_resourceRequest->setRequestorProcessID(requestorProcessID);
257}
258
259int WebURLRequest::appCacheHostID() const
260{
261    return m_private->m_resourceRequest->appCacheHostID();
262}
263
264void WebURLRequest::setAppCacheHostID(int appCacheHostID)
265{
266    m_private->m_resourceRequest->setAppCacheHostID(appCacheHostID);
267}
268
269bool WebURLRequest::downloadToFile() const
270{
271    return m_private->m_resourceRequest->downloadToFile();
272}
273
274void WebURLRequest::setDownloadToFile(bool downloadToFile)
275{
276    m_private->m_resourceRequest->setDownloadToFile(downloadToFile);
277}
278
279ResourceRequest& WebURLRequest::toMutableResourceRequest()
280{
281    ASSERT(m_private);
282    ASSERT(m_private->m_resourceRequest);
283
284    return *m_private->m_resourceRequest;
285}
286
287const ResourceRequest& WebURLRequest::toResourceRequest() const
288{
289    ASSERT(m_private);
290    ASSERT(m_private->m_resourceRequest);
291
292    return *m_private->m_resourceRequest;
293}
294
295void WebURLRequest::assign(WebURLRequestPrivate* p)
296{
297    // Subclasses may call this directly so a self-assignment check is needed
298    // here as well as in the public assign method.
299    if (m_private == p)
300        return;
301    if (m_private)
302        m_private->dispose();
303    m_private = p;
304}
305
306} // namespace WebKit
307