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