Remove unused parameter from a google_api::Request method.

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/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ skipping 230 matching lines @@
 }
 
 bool UrlFetchRequestBase::CalledOnValidThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
 base::TaskRunner* UrlFetchRequestBase::blocking_task_runner() const {
   return sender_->blocking_task_runner();
 }
 
-void UrlFetchRequestBase::OnProcessURLFetchResultsComplete(bool result) {
+void UrlFetchRequestBase::OnProcessURLFetchResultsComplete() {
   sender_->RequestFinished(this);
 }
 
 void UrlFetchRequestBase::OnURLFetchComplete(const URLFetcher* source) {
   GDataErrorCode code = GetErrorCode(source);
   DVLOG(1) << "Response headers:\n" << GetResponseHeadersAsString(source);
 
   if (code == HTTP_UNAUTHORIZED) {
     if (++re_authenticate_count_ <= kMaxReAuthenticateAttemptsPerRequest) {
       // Reset re_authenticate_callback_ so Start() can be called again.
@@ skipping 26 matching lines @@
 EntryActionRequest::EntryActionRequest(RequestSender* sender,
                                        const EntryActionCallback& callback)
     : UrlFetchRequestBase(sender),
       callback_(callback) {
   DCHECK(!callback_.is_null());
 }
 
 EntryActionRequest::~EntryActionRequest() {}
 
 void EntryActionRequest::ProcessURLFetchResults(const URLFetcher* source) {
-  GDataErrorCode code = GetErrorCode(source);
-  callback_.Run(code);
-  const bool success = true;
-  OnProcessURLFetchResultsComplete(success);
+  callback_.Run(GetErrorCode(source));
+  OnProcessURLFetchResultsComplete();
 }
 
 void EntryActionRequest::RunCallbackOnPrematureFailure(GDataErrorCode code) {
   callback_.Run(code);
 }
 
 //============================== GetDataRequest ==============================
 
 GetDataRequest::GetDataRequest(RequestSender* sender,
                                const GetDataCallback& callback)
@@ skipping 24 matching lines @@
   scoped_ptr<base::Value> root_value;
   GDataErrorCode fetch_error_code = GetErrorCode(source);
 
   switch (fetch_error_code) {
     case HTTP_SUCCESS:
     case HTTP_CREATED:
       ParseResponse(fetch_error_code, data);
       break;
     default:
       RunCallbackOnPrematureFailure(fetch_error_code);
-      const bool success = false;
-      OnProcessURLFetchResultsComplete(success);
+      OnProcessURLFetchResultsComplete();
       break;
   }
 }
 
 void GetDataRequest::RunCallbackOnPrematureFailure(
     GDataErrorCode fetch_error_code) {
   callback_.Run(fetch_error_code, scoped_ptr<base::Value>());
 }
 
 void GetDataRequest::OnDataParsed(GDataErrorCode fetch_error_code,
                                   scoped_ptr<base::Value> value) {
   DCHECK(CalledOnValidThread());
 
-  bool success = true;
-  if (!value.get()) {
+  if (!value.get())
     fetch_error_code = GDATA_PARSE_ERROR;
-    success = false;
-  }
 
-  RunCallbackOnSuccess(fetch_error_code, value.Pass());
-
-  DCHECK(!value.get());
-  OnProcessURLFetchResultsComplete(success);
-}
-
-void GetDataRequest::RunCallbackOnSuccess(GDataErrorCode fetch_error_code,
-                                          scoped_ptr<base::Value> value) {
-  DCHECK(CalledOnValidThread());
   callback_.Run(fetch_error_code, value.Pass());
+  OnProcessURLFetchResultsComplete();
 }
 
 //========================= InitiateUploadRequestBase ========================
 
 InitiateUploadRequestBase::InitiateUploadRequestBase(
     RequestSender* sender,
     const InitiateUploadCallback& callback,
     const std::string& content_type,
     int64 content_length)
     : UrlFetchRequestBase(sender),
@@ skipping 13 matching lines @@
 
   std::string upload_location;
   if (code == HTTP_SUCCESS) {
     // Retrieve value of the first "Location" header.
     source->GetResponseHeaders()->EnumerateHeader(NULL,
                                                   kUploadResponseLocation,
                                                   &upload_location);
   }
 
   callback_.Run(code, GURL(upload_location));
-  OnProcessURLFetchResultsComplete(code == HTTP_SUCCESS);
+  OnProcessURLFetchResultsComplete();
 }
 
 void InitiateUploadRequestBase::RunCallbackOnPrematureFailure(
     GDataErrorCode code) {
   callback_.Run(code, GURL());
 }
 
 std::vector<std::string>
 InitiateUploadRequestBase::GetExtraRequestHeaders() const {
   std::vector<std::string> headers;
@@ skipping 72 matching lines @@
     }
     // The Range header has the received data range, so the start position
     // should be always 0.
     DCHECK_EQ(start_position_received, 0);
 
     OnRangeRequestComplete(UploadRangeResponse(code,
                                                start_position_received,
                                                end_position_received),
                            scoped_ptr<base::Value>());
 
-    OnProcessURLFetchResultsComplete(true);
+    OnProcessURLFetchResultsComplete();
   } else if (code == HTTP_CREATED || code == HTTP_SUCCESS) {
     // The upload is successfully done. Parse the response which should be
     // the entry's metadata.
     std::string response_content;
     source->GetResponseAsString(&response_content);
 
     ParseJson(blocking_task_runner(),
               response_content,
               base::Bind(&UploadRangeRequestBase::OnDataParsed,
                          weak_ptr_factory_.GetWeakPtr(),
                          code));
   } else {
     // Failed to upload. Run callbacks to notify the error.
     OnRangeRequestComplete(
         UploadRangeResponse(code, -1, -1), scoped_ptr<base::Value>());
-    OnProcessURLFetchResultsComplete(false);
+    OnProcessURLFetchResultsComplete();
   }
 }
 
 void UploadRangeRequestBase::OnDataParsed(GDataErrorCode code,
                                           scoped_ptr<base::Value> value) {
   DCHECK(CalledOnValidThread());
   DCHECK(code == HTTP_CREATED || code == HTTP_SUCCESS);
 
   OnRangeRequestComplete(UploadRangeResponse(code, -1, -1), value.Pass());
-  OnProcessURLFetchResultsComplete(true);
+  OnProcessURLFetchResultsComplete();
 }
 
 void UploadRangeRequestBase::RunCallbackOnPrematureFailure(
     GDataErrorCode code) {
   OnRangeRequestComplete(
       UploadRangeResponse(code, 0, 0), scoped_ptr<base::Value>());
 }
 
 //========================== ResumeUploadRequestBase =========================
 
@@ skipping 143 matching lines @@
 
   // Take over the ownership of the the downloaded temp file.
   base::FilePath temp_file;
   if (code == HTTP_SUCCESS &&
       !source->GetResponseAsFilePath(true,  // take_ownership
                                      &temp_file)) {
     code = GDATA_FILE_ERROR;
   }
 
   download_action_callback_.Run(code, temp_file);
-  OnProcessURLFetchResultsComplete(code == HTTP_SUCCESS);
+  OnProcessURLFetchResultsComplete();
 }
 
 void DownloadFileRequestBase::RunCallbackOnPrematureFailure(
     GDataErrorCode code) {
   download_action_callback_.Run(code, base::FilePath());
 }
 
 }  // namespace google_apis