← Back to branch summary

~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

« back to all changes in this revision

Viewing changes to Source/WebCore/platform/chromium/support/WebURLRequest.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-02-18 14:24:18 UTC
  • Revision ID: package-import@ubuntu.com-20130218142418-eon0jmjg3nj438uy
Tags: upstream-2.3
Import upstream version 2.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/WebCore/platform/chromium/support/WebURLRequest.cpp
 
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/WebURLRequest.h>
 
33
 
 
34
#include "ResourceRequest.h"
 
35
#include "WebURLRequestPrivate.h"
 
36
#include <public/WebHTTPBody.h>
 
37
#include <public/WebHTTPHeaderVisitor.h>
 
38
#include <public/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* extraData) { 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& value)
 
178
{
 
179
    m_private->m_resourceRequest->setHTTPHeaderField(name, value);
 
180
}
 
181
 
 
182
void WebURLRequest::addHTTPHeaderField(const WebString& name, const WebString& value)
 
183
{
 
184
    m_private->m_resourceRequest->addHTTPHeaderField(name, value);
 
185
}
 
186
 
 
187
void WebURLRequest::clearHTTPHeaderField(const WebString& name)
 
188
{
 
189
    // FIXME: Add a clearHTTPHeaderField method to ResourceRequest.
 
190
    const HTTPHeaderMap& map = m_private->m_resourceRequest->httpHeaderFields();
 
191
    const_cast<HTTPHeaderMap*>(&map)->remove(name);
 
192
}
 
193
 
 
194
void WebURLRequest::visitHTTPHeaderFields(WebHTTPHeaderVisitor* visitor) const
 
195
{
 
196
    const HTTPHeaderMap& map = m_private->m_resourceRequest->httpHeaderFields();
 
197
    for (HTTPHeaderMap::const_iterator it = map.begin(); it != map.end(); ++it)
 
198
        visitor->visitHeader(it->key, it->value);
 
199
}
 
200
 
 
201
WebHTTPBody WebURLRequest::httpBody() const
 
202
{
 
203
    return WebHTTPBody(m_private->m_resourceRequest->httpBody());
 
204
}
 
205
 
 
206
void WebURLRequest::setHTTPBody(const WebHTTPBody& httpBody)
 
207
{
 
208
    m_private->m_resourceRequest->setHTTPBody(httpBody);
 
209
}
 
210
 
 
211
bool WebURLRequest::reportUploadProgress() const
 
212
{
 
213
    return m_private->m_resourceRequest->reportUploadProgress();
 
214
}
 
215
 
 
216
void WebURLRequest::setReportUploadProgress(bool reportUploadProgress)
 
217
{
 
218
    m_private->m_resourceRequest->setReportUploadProgress(reportUploadProgress);
 
219
}
 
220
 
 
221
bool WebURLRequest::reportLoadTiming() const
 
222
{
 
223
    return m_private->m_resourceRequest->reportLoadTiming();
 
224
}
 
225
 
 
226
void WebURLRequest::setReportRawHeaders(bool reportRawHeaders)
 
227
{
 
228
    m_private->m_resourceRequest->setReportRawHeaders(reportRawHeaders);
 
229
}
 
230
 
 
231
bool WebURLRequest::reportRawHeaders() const
 
232
{
 
233
    return m_private->m_resourceRequest->reportRawHeaders();
 
234
}
 
235
 
 
236
void WebURLRequest::setReportLoadTiming(bool reportLoadTiming)
 
237
{
 
238
    m_private->m_resourceRequest->setReportLoadTiming(reportLoadTiming);
 
239
}
 
240
 
 
241
WebURLRequest::TargetType WebURLRequest::targetType() const
 
242
{
 
243
    // FIXME: Temporary special case until downstream chromium.org knows of the new TargetTypes.
 
244
    TargetType targetType = static_cast<TargetType>(m_private->m_resourceRequest->targetType());
 
245
    if (targetType == TargetIsTextTrack || targetType == TargetIsUnspecified)
 
246
        return TargetIsSubresource;
 
247
    return targetType;
 
248
}
 
249
 
 
250
bool WebURLRequest::hasUserGesture() const
 
251
{
 
252
    return m_private->m_resourceRequest->hasUserGesture();
 
253
}
 
254
 
 
255
void WebURLRequest::setHasUserGesture(bool hasUserGesture)
 
256
{
 
257
    m_private->m_resourceRequest->setHasUserGesture(hasUserGesture);
 
258
}
 
259
 
 
260
void WebURLRequest::setTargetType(TargetType targetType)
 
261
{
 
262
    m_private->m_resourceRequest->setTargetType(
 
263
        static_cast<ResourceRequest::TargetType>(targetType));
 
264
}
 
265
 
 
266
int WebURLRequest::requestorID() const
 
267
{
 
268
    return m_private->m_resourceRequest->requestorID();
 
269
}
 
270
 
 
271
void WebURLRequest::setRequestorID(int requestorID)
 
272
{
 
273
    m_private->m_resourceRequest->setRequestorID(requestorID);
 
274
}
 
275
 
 
276
int WebURLRequest::requestorProcessID() const
 
277
{
 
278
    return m_private->m_resourceRequest->requestorProcessID();
 
279
}
 
280
 
 
281
void WebURLRequest::setRequestorProcessID(int requestorProcessID)
 
282
{
 
283
    m_private->m_resourceRequest->setRequestorProcessID(requestorProcessID);
 
284
}
 
285
 
 
286
int WebURLRequest::appCacheHostID() const
 
287
{
 
288
    return m_private->m_resourceRequest->appCacheHostID();
 
289
}
 
290
 
 
291
void WebURLRequest::setAppCacheHostID(int appCacheHostID)
 
292
{
 
293
    m_private->m_resourceRequest->setAppCacheHostID(appCacheHostID);
 
294
}
 
295
 
 
296
bool WebURLRequest::downloadToFile() const
 
297
{
 
298
    return m_private->m_resourceRequest->downloadToFile();
 
299
}
 
300
 
 
301
void WebURLRequest::setDownloadToFile(bool downloadToFile)
 
302
{
 
303
    m_private->m_resourceRequest->setDownloadToFile(downloadToFile);
 
304
}
 
305
 
 
306
WebURLRequest::ExtraData* WebURLRequest::extraData() const
 
307
{
 
308
    RefPtr<ResourceRequest::ExtraData> data = m_private->m_resourceRequest->extraData();
 
309
    if (!data)
 
310
        return 0;
 
311
    return static_cast<ExtraDataContainer*>(data.get())->extraData();
 
312
}
 
313
 
 
314
void WebURLRequest::setExtraData(WebURLRequest::ExtraData* extraData)
 
315
{
 
316
    m_private->m_resourceRequest->setExtraData(ExtraDataContainer::create(extraData));
 
317
}
 
318
 
 
319
ResourceRequest& WebURLRequest::toMutableResourceRequest()
 
320
{
 
321
    ASSERT(m_private);
 
322
    ASSERT(m_private->m_resourceRequest);
 
323
 
 
324
    return *m_private->m_resourceRequest;
 
325
}
 
326
 
 
327
const ResourceRequest& WebURLRequest::toResourceRequest() const
 
328
{
 
329
    ASSERT(m_private);
 
330
    ASSERT(m_private->m_resourceRequest);
 
331
 
 
332
    return *m_private->m_resourceRequest;
 
333
}
 
334
 
 
335
void WebURLRequest::assign(WebURLRequestPrivate* p)
 
336
{
 
337
    // Subclasses may call this directly so a self-assignment check is needed
 
338
    // here as well as in the public assign method.
 
339
    if (m_private == p)
 
340
        return;
 
341
    if (m_private)
 
342
        m_private->dispose();
 
343
    m_private = p;
 
344
}
 
345
 
 
346
} // namespace WebKit