Move URLFetcherDelegate to net/ and split URLFetcher between net/ and content/

chrome/browser/chromeos/gdata/gdata_operations.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 "chrome/browser/chromeos/gdata/gdata_operations.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
@@ skipping 291 matching lines @@
 bool UrlFetchOperationBase::GetContentData(std::string* upload_content_type,
                                            std::string* upload_content) {
   return false;
 }
 
 void UrlFetchOperationBase::DoCancel() {
   url_fetcher_.reset(NULL);
   RunCallbackOnPrematureFailure(GDATA_CANCELLED);
 }
 
-void UrlFetchOperationBase::OnURLFetchComplete(const URLFetcher* source) {
+void UrlFetchOperationBase::OnURLFetchComplete(const net::URLFetcher* source) {
   GDataErrorCode code =
       static_cast<GDataErrorCode>(source->GetResponseCode());
   DVLOG(1) << "Response headers:\n" << GetResponseHeadersAsString(source);
 
   if (code == HTTP_UNAUTHORIZED) {
     if (!re_authenticate_callback_.is_null() &&
         ++re_authenticate_count_ <= kMaxReAuthenticateAttemptsPerOperation) {
       re_authenticate_callback_.Run(this);
       return;
     }
@@ skipping 22 matching lines @@
   RunCallbackOnPrematureFailure(code);
   // Check if this failed before we even started fetching. If so, register
   // for start so we can properly unregister with finish.
   if (!started_)
     NotifyStart();
 
   NotifyFinish(GDataOperationRegistry::OPERATION_FAILED);
 }
 
 std::string UrlFetchOperationBase::GetResponseHeadersAsString(
-    const URLFetcher* url_fetcher) {
+    const net::URLFetcher* url_fetcher) {
   // net::HttpResponseHeaders::raw_headers(), as the name implies, stores
   // all headers in their raw format, i.e each header is null-terminated.
   // So logging raw_headers() only shows the first header, which is probably
   // the status line.  GetNormalizedHeaders, on the other hand, will show all
   // the headers, one per line, which is probably what we want.
   std::string headers;
   // Check that response code indicates response headers are valid (i.e. not
   // malformed) before we retrieve the headers.
   if (url_fetcher->GetResponseCode() == URLFetcher::RESPONSE_CODE_INVALID) {
     headers.assign("Response headers are malformed!!");
@@ skipping 14 matching lines @@
       document_url_(document_url) {
 }
 
 EntryActionOperation::~EntryActionOperation() {}
 
 // Overridden from UrlFetchOperationBase.
 GURL EntryActionOperation::GetURL() const {
   return AddStandardUrlParams(document_url_);
 }
 
-bool EntryActionOperation::ProcessURLFetchResults(const URLFetcher* source) {
+bool EntryActionOperation::ProcessURLFetchResults(
+    const net::URLFetcher* source) {
   if (!callback_.is_null()) {
     GDataErrorCode code =
         static_cast<GDataErrorCode>(source->GetResponseCode());
     callback_.Run(code, document_url_);
   }
   return true;
 }
 
 void EntryActionOperation::RunCallbackOnPrematureFailure(GDataErrorCode code) {
   if (!callback_.is_null())
     callback_.Run(code, document_url_);
 }
 
 //============================== GetDataOperation ==============================
 
 GetDataOperation::GetDataOperation(GDataOperationRegistry* registry,
                                    Profile* profile,
                                    const GetDataCallback& callback)
     : UrlFetchOperationBase(registry, profile), callback_(callback) {
 }
 
 GetDataOperation::~GetDataOperation() {}
 
-bool GetDataOperation::ProcessURLFetchResults(const URLFetcher* source) {
+bool GetDataOperation::ProcessURLFetchResults(const net::URLFetcher* source) {
   std::string data;
   source->GetResponseAsString(&data);
   scoped_ptr<base::Value> root_value;
   GDataErrorCode code = static_cast<GDataErrorCode>(source->GetResponseCode());
 
   switch (code) {
     case HTTP_SUCCESS:
     case HTTP_CREATED: {
       root_value.reset(ParseResponse(data));
       if (!root_value.get())
@@ skipping 112 matching lines @@
     output_file_path_ = output_file_path;
 }
 
 DownloadFileOperation::~DownloadFileOperation() {}
 
 // Overridden from UrlFetchOperationBase.
 GURL DownloadFileOperation::GetURL() const {
   return document_url_;
 }
 
-void DownloadFileOperation::OnURLFetchDownloadProgress(const URLFetcher* source,
-                                                       int64 current,
-                                                       int64 total) {
+void DownloadFileOperation::OnURLFetchDownloadProgress(
+    const net::URLFetcher* source,
+    int64 current,
+    int64 total) {
   NotifyProgress(current, total);
 }
 
 bool DownloadFileOperation::ShouldSendDownloadData() {
   return !get_download_data_callback_.is_null();
 }
 
 void DownloadFileOperation::OnURLFetchDownloadData(
-    const URLFetcher* source,
+    const net::URLFetcher* source,
     scoped_ptr<std::string> download_data) {
   if (!get_download_data_callback_.is_null())
     get_download_data_callback_.Run(HTTP_SUCCESS, download_data.Pass());
 }
 
-bool DownloadFileOperation::ProcessURLFetchResults(const URLFetcher* source) {
+bool DownloadFileOperation::ProcessURLFetchResults(
+    const net::URLFetcher* source) {
   GDataErrorCode code = static_cast<GDataErrorCode>(source->GetResponseCode());
 
   // Take over the ownership of the the downloaded temp file.
   FilePath temp_file;
   if (code == HTTP_SUCCESS &&
       !source->GetResponseAsFilePath(true,  // take_ownership
                                      &temp_file)) {
     code = GDATA_FILE_ERROR;
   }
 
@@ skipping 266 matching lines @@
           kUploadParamConvertKey,
           kUploadParamConvertValue)) {
 }
 
 InitiateUploadOperation::~InitiateUploadOperation() {}
 
 GURL InitiateUploadOperation::GetURL() const {
   return initiate_upload_url_;
 }
 
-bool InitiateUploadOperation::ProcessURLFetchResults(const URLFetcher* source) {
+bool InitiateUploadOperation::ProcessURLFetchResults(
+    const net::URLFetcher* source) {
   GDataErrorCode code =
       static_cast<GDataErrorCode>(source->GetResponseCode());
 
   std::string upload_location;
   if (code == HTTP_SUCCESS) {
     // Retrieve value of the first "Location" header.
     source->GetResponseHeaders()->EnumerateHeader(NULL,
                                                   kUploadResponseLocation,
                                                   &upload_location);
   }
@@ skipping 64 matching lines @@
       params_(params),
       last_chunk_completed_(false) {
 }
 
 ResumeUploadOperation::~ResumeUploadOperation() {}
 
 GURL ResumeUploadOperation::GetURL() const {
   return params_.upload_location;
 }
 
-bool ResumeUploadOperation::ProcessURLFetchResults(const URLFetcher* source) {
+bool ResumeUploadOperation::ProcessURLFetchResults(
+    const net::URLFetcher* source) {
   GDataErrorCode code = static_cast<GDataErrorCode>(source->GetResponseCode());
   net::HttpResponseHeaders* hdrs = source->GetResponseHeaders();
   int64 start_range_received = -1;
   int64 end_range_received = -1;
   scoped_ptr<DocumentEntry> entry;
 
   if (code == HTTP_RESUME_INCOMPLETE) {
     // Retrieve value of the first "Range" header.
     std::string range_received;
     hdrs->EnumerateHeader(NULL, kUploadResponseRange, &range_received);
@@ skipping 89 matching lines @@
 
 bool ResumeUploadOperation::GetContentData(std::string* upload_content_type,
                                            std::string* upload_content) {
   *upload_content_type = params_.content_type;
   *upload_content = std::string(params_.buf->data(),
                                 params_.end_range - params_.start_range + 1);
   return true;
 }
 
 void ResumeUploadOperation::OnURLFetchUploadProgress(
-    const content::URLFetcher* source, int64 current, int64 total) {
+    const net::URLFetcher* source, int64 current, int64 total) {
   // Adjust the progress values according to the range currently uploaded.
   NotifyProgress(params_.start_range + current, params_.content_length);
 }
 
 }  // namespace gdata