url_fetcher_impl.cc revision 4e180b6a0b4720a9b8e9e959a882386f690f08ff 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "net/url_request/url_fetcher_impl.h"
6
7#include "base/bind.h"
8#include "base/message_loop/message_loop_proxy.h"
9#include "net/url_request/url_fetcher_core.h"
10#include "net/url_request/url_fetcher_factory.h"
11#include "net/url_request/url_fetcher_response_writer.h"
12
13namespace net {
14
15static URLFetcherFactory* g_factory = NULL;
16
17URLFetcherImpl::URLFetcherImpl(const GURL& url,
18                               RequestType request_type,
19                               URLFetcherDelegate* d)
20    : core_(new URLFetcherCore(this, url, request_type, d)) {
21}
22
23URLFetcherImpl::~URLFetcherImpl() {
24  core_->Stop();
25}
26
27void URLFetcherImpl::SetUploadData(const std::string& upload_content_type,
28                                   const std::string& upload_content) {
29  core_->SetUploadData(upload_content_type, upload_content);
30}
31
32void URLFetcherImpl::SetUploadFilePath(
33    const std::string& upload_content_type,
34    const base::FilePath& file_path,
35    uint64 range_offset,
36    uint64 range_length,
37    scoped_refptr<base::TaskRunner> file_task_runner) {
38  core_->SetUploadFilePath(upload_content_type,
39                           file_path,
40                           range_offset,
41                           range_length,
42                           file_task_runner);
43}
44
45void URLFetcherImpl::SetChunkedUpload(const std::string& content_type) {
46  core_->SetChunkedUpload(content_type);
47}
48
49void URLFetcherImpl::AppendChunkToUpload(const std::string& data,
50                                         bool is_last_chunk) {
51  DCHECK(data.length());
52  core_->AppendChunkToUpload(data, is_last_chunk);
53}
54
55void URLFetcherImpl::SetReferrer(const std::string& referrer) {
56  core_->SetReferrer(referrer);
57}
58
59void URLFetcherImpl::SetLoadFlags(int load_flags) {
60  core_->SetLoadFlags(load_flags);
61}
62
63int URLFetcherImpl::GetLoadFlags() const {
64  return core_->GetLoadFlags();
65}
66
67void URLFetcherImpl::SetExtraRequestHeaders(
68    const std::string& extra_request_headers) {
69  core_->SetExtraRequestHeaders(extra_request_headers);
70}
71
72void URLFetcherImpl::AddExtraRequestHeader(const std::string& header_line) {
73  core_->AddExtraRequestHeader(header_line);
74}
75
76void URLFetcherImpl::GetExtraRequestHeaders(
77    HttpRequestHeaders* headers) const {
78  GetExtraRequestHeaders(headers);
79}
80
81void URLFetcherImpl::SetRequestContext(
82    URLRequestContextGetter* request_context_getter) {
83  core_->SetRequestContext(request_context_getter);
84}
85
86void URLFetcherImpl::SetFirstPartyForCookies(
87    const GURL& first_party_for_cookies) {
88  core_->SetFirstPartyForCookies(first_party_for_cookies);
89}
90
91void URLFetcherImpl::SetURLRequestUserData(
92    const void* key,
93    const CreateDataCallback& create_data_callback) {
94  core_->SetURLRequestUserData(key, create_data_callback);
95}
96
97void URLFetcherImpl::SetStopOnRedirect(bool stop_on_redirect) {
98  core_->SetStopOnRedirect(stop_on_redirect);
99}
100
101void URLFetcherImpl::SetAutomaticallyRetryOn5xx(bool retry) {
102  core_->SetAutomaticallyRetryOn5xx(retry);
103}
104
105void URLFetcherImpl::SetMaxRetriesOn5xx(int max_retries) {
106  core_->SetMaxRetriesOn5xx(max_retries);
107}
108
109int URLFetcherImpl::GetMaxRetriesOn5xx() const {
110  return core_->GetMaxRetriesOn5xx();
111}
112
113
114base::TimeDelta URLFetcherImpl::GetBackoffDelay() const {
115  return core_->GetBackoffDelay();
116}
117
118void URLFetcherImpl::SetAutomaticallyRetryOnNetworkChanges(int max_retries) {
119  core_->SetAutomaticallyRetryOnNetworkChanges(max_retries);
120}
121
122void URLFetcherImpl::SaveResponseToFileAtPath(
123    const base::FilePath& file_path,
124    scoped_refptr<base::TaskRunner> file_task_runner) {
125  core_->SaveResponseToFileAtPath(file_path, file_task_runner);
126}
127
128void URLFetcherImpl::SaveResponseToTemporaryFile(
129    scoped_refptr<base::TaskRunner> file_task_runner) {
130  core_->SaveResponseToTemporaryFile(file_task_runner);
131}
132
133void URLFetcherImpl::SaveResponseWithWriter(
134    scoped_ptr<URLFetcherResponseWriter> response_writer) {
135  core_->SaveResponseWithWriter(response_writer.Pass());
136}
137
138HttpResponseHeaders* URLFetcherImpl::GetResponseHeaders() const {
139  return core_->GetResponseHeaders();
140}
141
142HostPortPair URLFetcherImpl::GetSocketAddress() const {
143  return core_->GetSocketAddress();
144}
145
146bool URLFetcherImpl::WasFetchedViaProxy() const {
147  return core_->WasFetchedViaProxy();
148}
149
150void URLFetcherImpl::Start() {
151  core_->Start();
152}
153
154const GURL& URLFetcherImpl::GetOriginalURL() const {
155  return core_->GetOriginalURL();
156}
157
158const GURL& URLFetcherImpl::GetURL() const {
159  return core_->GetURL();
160}
161
162const URLRequestStatus& URLFetcherImpl::GetStatus() const {
163  return core_->GetStatus();
164}
165
166int URLFetcherImpl::GetResponseCode() const {
167  return core_->GetResponseCode();
168}
169
170const ResponseCookies& URLFetcherImpl::GetCookies() const {
171  return core_->GetCookies();
172}
173
174void URLFetcherImpl::ReceivedContentWasMalformed() {
175  core_->ReceivedContentWasMalformed();
176}
177
178bool URLFetcherImpl::GetResponseAsString(
179    std::string* out_response_string) const {
180  return core_->GetResponseAsString(out_response_string);
181}
182
183bool URLFetcherImpl::GetResponseAsFilePath(
184    bool take_ownership,
185    base::FilePath* out_response_path) const {
186  return core_->GetResponseAsFilePath(take_ownership, out_response_path);
187}
188
189// static
190void URLFetcherImpl::CancelAll() {
191  URLFetcherCore::CancelAll();
192}
193
194// static
195void URLFetcherImpl::SetEnableInterceptionForTests(bool enabled) {
196  URLFetcherCore::SetEnableInterceptionForTests(enabled);
197}
198
199// static
200void URLFetcherImpl::SetIgnoreCertificateRequests(bool ignored) {
201  URLFetcherCore::SetIgnoreCertificateRequests(ignored);
202}
203
204// static
205int URLFetcherImpl::GetNumFetcherCores() {
206  return URLFetcherCore::GetNumFetcherCores();
207}
208
209URLFetcherDelegate* URLFetcherImpl::delegate() const {
210  return core_->delegate();
211}
212
213// static
214URLFetcherFactory* URLFetcherImpl::factory() {
215  return g_factory;
216}
217
218// static
219void URLFetcherImpl::set_factory(URLFetcherFactory* factory) {
220  g_factory = factory;
221}
222
223}  // namespace net
224