net/url_request/url_fetcher_impl.cc

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