Get rid of RequestRegistry (part 3): remove Drive path from request objects.

chrome/browser/google_apis/base_requests.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/google_apis/base_requests.h"
 
 #include "base/json/json_reader.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
@@ skipping 86 matching lines @@
     net::URLRequestContextGetter* url_request_context_getter)
     : RequestRegistry::Request(runner->request_registry()),
       url_request_context_getter_(url_request_context_getter),
       re_authenticate_count_(0),
       started_(false),
       save_temp_file_(false),
       weak_ptr_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
-UrlFetchRequestBase::UrlFetchRequestBase(
-    RequestSender* runner,
-    net::URLRequestContextGetter* url_request_context_getter,
-    const base::FilePath& path)
-    : RequestRegistry::Request(runner->request_registry(), path),
-      url_request_context_getter_(url_request_context_getter),
-      re_authenticate_count_(0),
-      started_(false),
-      save_temp_file_(false),
-      weak_ptr_factory_(this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-}
-
 UrlFetchRequestBase::~UrlFetchRequestBase() {}
 
 void UrlFetchRequestBase::Start(const std::string& access_token,
                                 const std::string& custom_user_agent,
                                 const ReAuthenticateCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(url_request_context_getter_);
   DCHECK(!access_token.empty());
   DCHECK(!callback.is_null());
   DCHECK(re_authenticate_callback_.is_null());
@@ skipping 265 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   callback_.Run(fetch_error_code, value.Pass());
 }
 
 //========================= InitiateUploadRequestBase ========================
 
 InitiateUploadRequestBase::InitiateUploadRequestBase(
     RequestSender* runner,
     net::URLRequestContextGetter* url_request_context_getter,
     const InitiateUploadCallback& callback,
-    const base::FilePath& drive_file_path,
     const std::string& content_type,
     int64 content_length)
-    : UrlFetchRequestBase(runner,
-                          url_request_context_getter,
-                          drive_file_path),
+    : UrlFetchRequestBase(runner, url_request_context_getter),
       callback_(callback),
-      drive_file_path_(drive_file_path),
       content_type_(content_type),
       content_length_(content_length) {
   DCHECK(!callback_.is_null());
   DCHECK(!content_type_.empty());
   DCHECK_GE(content_length_, 0);
 }
 
 InitiateUploadRequestBase::~InitiateUploadRequestBase() {}
 
 void InitiateUploadRequestBase::ProcessURLFetchResults(
     const URLFetcher* source) {
   GDataErrorCode code = GetErrorCode(source);
 
   std::string upload_location;
   if (code == HTTP_SUCCESS) {
     // Retrieve value of the first "Location" header.
     source->GetResponseHeaders()->EnumerateHeader(NULL,
                                                   kUploadResponseLocation,
                                                   &upload_location);
   }
-  VLOG(1) << "Got response for [" << drive_file_path_.value()
-          << "]: code=" << code
-          << ", location=[" << upload_location << "]";
 
   callback_.Run(code, GURL(upload_location));
   OnProcessURLFetchResultsComplete(code == HTTP_SUCCESS);
 }
 
 void InitiateUploadRequestBase::RunCallbackOnPrematureFailure(
     GDataErrorCode code) {
   callback_.Run(code, GURL());
 }
 
@@ skipping 23 matching lines @@
 }
 
 UploadRangeResponse::~UploadRangeResponse() {
 }
 
 //========================== UploadRangeRequestBase ==========================
 
 UploadRangeRequestBase::UploadRangeRequestBase(
     RequestSender* runner,
     net::URLRequestContextGetter* url_request_context_getter,
-    const base::FilePath& drive_file_path,
     const GURL& upload_url)
-    : UrlFetchRequestBase(runner,
-                          url_request_context_getter,
-                          drive_file_path),
-      drive_file_path_(drive_file_path),
+    : UrlFetchRequestBase(runner, url_request_context_getter),
       upload_url_(upload_url),
       weak_ptr_factory_(this) {
 }
 
 UploadRangeRequestBase::~UploadRangeRequestBase() {}
 
 GURL UploadRangeRequestBase::GetURL() const {
   // This is very tricky to get json from this request. To do that, &alt=json
   // has to be appended not here but in InitiateUploadRequestBase::GetURL().
   return upload_url_;
@@ skipping 26 matching lines @@
         // Range header represents the range inclusively, while we are treating
         // ranges exclusively (i.e., end_position_received should be one passed
         // the last valid index). So "+ 1" is added.
         start_position_received = ranges[0].first_byte_position();
         end_position_received = ranges[0].last_byte_position() + 1;
       }
     }
     // The Range header has the received data range, so the start position
     // should be always 0.
     DCHECK_EQ(start_position_received, 0);
-    DVLOG(1) << "Got response for [" << drive_file_path_.value()
-             << "]: code=" << code
-             << ", range_hdr=[" << range_received
-             << "], range_parsed=" << start_position_received
-             << "," << end_position_received;
 
     OnRangeRequestComplete(UploadRangeResponse(code,
                                                start_position_received,
                                                end_position_received),
                            scoped_ptr<base::Value>());
 
     OnProcessURLFetchResultsComplete(true);
   } else {
     // There might be explanation of unexpected error code in response.
     std::string response_content;
     source->GetResponseAsString(&response_content);
-    DVLOG(1) << "Got response for [" << drive_file_path_.value()
-             << "]: code=" << code
-             << ", content=[\n" << response_content << "\n]";
 
     ParseJson(response_content,
               base::Bind(&UploadRangeRequestBase::OnDataParsed,
                          weak_ptr_factory_.GetWeakPtr(),
                          code));
   }
 }
 
 void UploadRangeRequestBase::OnDataParsed(GDataErrorCode code,
                                           scoped_ptr<base::Value> value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   OnRangeRequestComplete(UploadRangeResponse(code, -1, -1), value.Pass());
   OnProcessURLFetchResultsComplete(
       code == HTTP_CREATED || code == HTTP_SUCCESS);
 }
 
 void UploadRangeRequestBase::RunCallbackOnPrematureFailure(
     GDataErrorCode code) {
   OnRangeRequestComplete(
       UploadRangeResponse(code, 0, 0), scoped_ptr<base::Value>());
 }
 
 //========================== ResumeUploadRequestBase =========================
 
 ResumeUploadRequestBase::ResumeUploadRequestBase(
     RequestSender* runner,
     net::URLRequestContextGetter* url_request_context_getter,
-    const base::FilePath& drive_file_path,
     const GURL& upload_location,
     int64 start_position,
     int64 end_position,
     int64 content_length,
     const std::string& content_type,
     const base::FilePath& local_file_path)
     : UploadRangeRequestBase(runner,
                              url_request_context_getter,
-                             drive_file_path,
                              upload_location),
       start_position_(start_position),
       end_position_(end_position),
       content_length_(content_length),
       content_type_(content_type),
       local_file_path_(local_file_path) {
   DCHECK_LE(start_position_, end_position_);
 }
 
 ResumeUploadRequestBase::~ResumeUploadRequestBase() {}
@@ skipping 40 matching lines @@
   *range_length = end_position_ - start_position_;
   *upload_content_type = content_type_;
   return true;
 }
 
 //======================== GetUploadStatusRequestBase ========================
 
 GetUploadStatusRequestBase::GetUploadStatusRequestBase(
     RequestSender* runner,
     net::URLRequestContextGetter* url_request_context_getter,
-    const base::FilePath& drive_file_path,
     const GURL& upload_url,
     int64 content_length)
     : UploadRangeRequestBase(runner,
                              url_request_context_getter,
-                             drive_file_path,
                              upload_url),
       content_length_(content_length) {}
 
 GetUploadStatusRequestBase::~GetUploadStatusRequestBase() {}
 
 std::vector<std::string>
 GetUploadStatusRequestBase::GetExtraRequestHeaders() const {
   // The header looks like
   // Content-Range: bytes */<content_length>
   // for example:
   // Content-Range: bytes */13851821
   DCHECK_GE(content_length_, 0);
 
   std::vector<std::string> headers;
   headers.push_back(
       std::string(kUploadContentRange) + "*/" +
       base::Int64ToString(content_length_));
   return headers;
 }
 
 //============================ DownloadFileRequest ===========================
 
 DownloadFileRequest::DownloadFileRequest(
     RequestSender* runner,
     net::URLRequestContextGetter* url_request_context_getter,
     const DownloadActionCallback& download_action_callback,
     const GetContentCallback& get_content_callback,
     const ProgressCallback& progress_callback,
     const GURL& download_url,
-    const base::FilePath& drive_file_path,
     const base::FilePath& output_file_path)
-    : UrlFetchRequestBase(runner,
-                          url_request_context_getter,
-                          drive_file_path),
+    : UrlFetchRequestBase(runner, url_request_context_getter),
       download_action_callback_(download_action_callback),
       get_content_callback_(get_content_callback),
       progress_callback_(progress_callback),
       download_url_(download_url) {
   DCHECK(!download_action_callback_.is_null());
   // get_content_callback may be null.
 
   // Make sure we download the content into a temp file.
   if (output_file_path.empty())
     set_save_temp_file(true);
@@ skipping 39 matching lines @@
 
   download_action_callback_.Run(code, temp_file);
   OnProcessURLFetchResultsComplete(code == HTTP_SUCCESS);
 }
 
 void DownloadFileRequest::RunCallbackOnPrematureFailure(GDataErrorCode code) {
   download_action_callback_.Run(code, base::FilePath());
 }
 
 }  // namespace google_apis