Change most content::URLFetcher references to net::URLFetcher

content/common/net/url_fetcher_core.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/common/net/url_fetcher_core.h"
 
 #include "base/bind.h"
 #include "base/file_util_proxy.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
@@ skipping 224 matching lines @@
     base::FileUtilProxy::Delete(
         file_message_loop_proxy_, file_path_,
         false,  // No need to recurse, as the path is to a file.
         base::FileUtilProxy::StatusCallback());  // No callback: Ignore errors.
     DisownFile();
   }
 }
 
 static bool g_interception_enabled = false;
 
-URLFetcherCore::URLFetcherCore(URLFetcher* fetcher,
+URLFetcherCore::URLFetcherCore(net::URLFetcher* fetcher,
                                const GURL& original_url,
-                               URLFetcher::RequestType request_type,
+                               net::URLFetcher::RequestType request_type,
                                net::URLFetcherDelegate* d)
     : fetcher_(fetcher),
       original_url_(original_url),
       request_type_(request_type),
       delegate_(d),
       delegate_loop_proxy_(
           base::MessageLoopProxy::current()),
       request_(NULL),
       load_flags_(net::LOAD_NORMAL),
-      response_code_(URLFetcher::RESPONSE_CODE_INVALID),
+      response_code_(net::URLFetcher::RESPONSE_CODE_INVALID),
       buffer_(new net::IOBuffer(kBufferSize)),
       url_request_data_key_(NULL),
       was_fetched_via_proxy_(false),
       is_chunked_upload_(false),
       num_retries_(0),
       was_cancelled_(false),
       response_destination_(STRING),
       automatically_retry_on_5xx_(true),
       max_retries_(0),
       current_upload_bytes_(-1),
@@ skipping 132 matching lines @@
 }
 
 void URLFetcherCore::SetFirstPartyForCookies(
     const GURL& first_party_for_cookies) {
   DCHECK(first_party_for_cookies_.is_empty());
   first_party_for_cookies_ = first_party_for_cookies;
 }
 
 void URLFetcherCore::SetURLRequestUserData(
     const void* key,
-    const URLFetcher::CreateDataCallback& create_data_callback) {
+    const net::URLFetcher::CreateDataCallback& create_data_callback) {
   DCHECK(key);
   DCHECK(!create_data_callback.is_null());
   url_request_data_key_ = key;
   url_request_create_data_callback_ = create_data_callback;
 }
 
 void URLFetcherCore::SetAutomaticallyRetryOn5xx(bool retry) {
   automatically_retry_on_5xx_ = retry;
 }
 
@@ skipping 210 matching lines @@
     }
   } while (request_->Read(buffer_, kBufferSize, &bytes_read));
 
   const net::URLRequestStatus status = request_->status();
 
   if (status.is_success())
     request_->GetResponseCookies(&cookies_);
 
   // See comments re: HEAD requests in ReadResponse().
   if ((!status.is_io_pending() && !waiting_on_write) ||
-      (request_type_ == URLFetcher::HEAD)) {
+      (request_type_ == net::URLFetcher::HEAD)) {
     status_ = status;
     ReleaseRequest();
 
     // If a file is open, close it.
     if (file_writer_.get()) {
       // If the file is open, close it.  After closing the file,
       // RetryOrCompleteUrlFetch() will be called.
       file_writer_->CloseFileAndCompleteRequest();
     } else {
       // Otherwise, complete or retry the URL request directly.
@@ skipping 42 matching lines @@
   // should be gone too.
   DCHECK(posted || !delegate_);
 }
 
 void URLFetcherCore::ReadResponse() {
   // Some servers may treat HEAD requests as GET requests.  To free up the
   // network connection as soon as possible, signal that the request has
   // completed immediately, without trying to read any data back (all we care
   // about is the response code and headers, which we already have).
   int bytes_read = 0;
-  if (request_->status().is_success() && (request_type_ != URLFetcher::HEAD))
+  if (request_->status().is_success() &&
+      (request_type_ != net::URLFetcher::HEAD))
     request_->Read(buffer_, kBufferSize, &bytes_read);
   OnReadCompleted(request_.get(), bytes_read);
 }
 
 void URLFetcherCore::DisownFile() {
   file_writer_->DisownFile();
 }
 
 void URLFetcherCore::StartURLRequest() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
@@ skipping 21 matching lines @@
   request_->set_context(request_context_getter_->GetURLRequestContext());
   request_->set_referrer(referrer_);
   request_->set_first_party_for_cookies(first_party_for_cookies_.is_empty() ?
       original_url_ : first_party_for_cookies_);
   if (url_request_data_key_ && !url_request_create_data_callback_.is_null()) {
     request_->SetUserData(url_request_data_key_,
                           url_request_create_data_callback_.Run());
   }
 
   switch (request_type_) {
-    case URLFetcher::GET:
+    case net::URLFetcher::GET:
       break;
 
-    case URLFetcher::POST:
-    case URLFetcher::PUT:
+    case net::URLFetcher::POST:
+    case net::URLFetcher::PUT:
       DCHECK(!upload_content_.empty() || is_chunked_upload_);
       DCHECK(!upload_content_type_.empty());
 
-      request_->set_method(request_type_ == URLFetcher::POST ? "POST" : "PUT");
+      request_->set_method(
+          request_type_ == net::URLFetcher::POST ? "POST" : "PUT");
       extra_request_headers_.SetHeader(net::HttpRequestHeaders::kContentType,
                                        upload_content_type_);
       if (!upload_content_.empty()) {
         request_->AppendBytesToUpload(
             upload_content_.data(), static_cast<int>(upload_content_.length()));
       }
 
       current_upload_bytes_ = -1;
       // TODO(kinaba): http://crbug.com/118103. Implement upload callback in the
       // net:: layer and avoid using timer here.
       upload_progress_checker_timer_.reset(
           new base::RepeatingTimer<URLFetcherCore>());
       upload_progress_checker_timer_->Start(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kUploadProgressTimerInterval),
           this,
           &URLFetcherCore::InformDelegateUploadProgress);
       break;
 
-    case URLFetcher::HEAD:
+    case net::URLFetcher::HEAD:
       request_->set_method("HEAD");
       break;
 
-    case URLFetcher::DELETE_REQUEST:
+    case net::URLFetcher::DELETE_REQUEST:
       request_->set_method("DELETE");
       break;
 
     default:
       NOTREACHED();
   }
 
   if (!extra_request_headers_.IsEmpty())
     request_->SetExtraRequestHeaders(extra_request_headers_);
 
@@ skipping 132 matching lines @@
 void URLFetcherCore::InformDelegateFetchIsComplete() {
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchComplete(fetcher_);
 }
 
 void URLFetcherCore::NotifyMalformedContent() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   if (url_throttler_entry_ != NULL) {
     int status_code = response_code_;
-    if (status_code == URLFetcher::RESPONSE_CODE_INVALID) {
+    if (status_code == net::URLFetcher::RESPONSE_CODE_INVALID) {
       // The status code will generally be known by the time clients
       // call the |ReceivedContentWasMalformed()| function (which ends up
       // calling the current function) but if it's not, we need to assume
       // the response was successful so that the total failure count
       // used to calculate exponential back-off goes up.
       status_code = 200;
     }
     url_throttler_entry_->ReceivedContentWasMalformed(status_code);
   }
 }
@@ skipping 18 matching lines @@
     }
 
     return original_url_backoff > destination_url_backoff ?
         original_url_backoff : destination_url_backoff;
   } else {
     return base::TimeTicks();
   }
 }
 
 }  // namespace content