google_apis: Clean up base_operations.h

chrome/browser/google_apis/base_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/google_apis/base_operations.h"
 
 #include "base/json/json_reader.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/task_runner_util.h"
@@ skipping 28 matching lines @@
   scoped_ptr<base::Value> value(base::JSONReader::ReadAndReturnError(
       data, base::JSON_PARSE_RFC, &error_code, &error_message));
 
   if (!value.get()) {
     LOG(ERROR) << "Error while parsing entry response: " << error_message
                << ", code: " << error_code << ", data:\n" << data;
   }
   return value.Pass();
 }
 
+// Returns response headers as a string. Returns a warning message if
+// |url_fetcher| does not contain a valid response. Used only for debugging.
+std::string GetResponseHeadersAsString(
+    const 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!!");
+  } else {
+    url_fetcher->GetResponseHeaders()->GetNormalizedHeaders(&headers);
+  }
+  return headers;
+}
+
 }  // namespace
 
 namespace google_apis {
 
 //============================ UrlFetchOperationBase ===========================
 
 UrlFetchOperationBase::UrlFetchOperationBase(OperationRegistry* registry)
     : OperationRegistry::Operation(registry),
+      save_temp_file_(false),
       re_authenticate_count_(0),
-      save_temp_file_(false),
       started_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 UrlFetchOperationBase::UrlFetchOperationBase(OperationRegistry* registry,
                                              OperationType type,
                                              const FilePath& path)
     : OperationRegistry::Operation(registry, type, path),
+      save_temp_file_(false),
       re_authenticate_count_(0),
-      save_temp_file_(false),
       started_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 UrlFetchOperationBase::~UrlFetchOperationBase() {}
 
 void UrlFetchOperationBase::Start(const std::string& auth_token,
                                   const std::string& custom_user_agent) {
   DCHECK(!auth_token.empty());
@@ skipping 64 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);
 }
 
-GDataErrorCode UrlFetchOperationBase::GetErrorCode(
-    const URLFetcher* source) const {
+// static
+GDataErrorCode UrlFetchOperationBase::GetErrorCode(const URLFetcher* source) {
   GDataErrorCode code = static_cast<GDataErrorCode>(source->GetResponseCode());
   if (code == HTTP_SUCCESS && !source->GetStatus().is_success()) {
     // If the HTTP response code is SUCCESS yet the URL request failed, it is
     // likely that the failure is due to loss of connection.
     code = GDATA_NO_CONNECTION;
   }
   return code;
 }
 
 void UrlFetchOperationBase::OnProcessURLFetchResultsComplete(bool result) {
@@ skipping 41 matching lines @@
   if (!started_)
     NotifyStart();
 
   // Note: NotifyFinish() must be invoked at the end, after all other callbacks
   // and notifications. Once NotifyFinish() is called, the current instance of
   // gdata operation will be deleted from the OperationRegistry and become
   // invalid.
   NotifyFinish(OPERATION_FAILED);
 }
 
-std::string UrlFetchOperationBase::GetResponseHeadersAsString(
-    const 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!!");
-  } else {
-    url_fetcher->GetResponseHeaders()->GetNormalizedHeaders(&headers);
-  }
-  return headers;
-}
-
 base::WeakPtr<AuthenticatedOperationInterface>
 UrlFetchOperationBase::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 
 //============================ EntryActionOperation ============================
 
 EntryActionOperation::EntryActionOperation(OperationRegistry* registry,
                                            const EntryActionCallback& callback)
@@ skipping 87 matching lines @@
 }
 
 void GetDataOperation::RunCallback(GDataErrorCode fetch_error_code,
                                    scoped_ptr<base::Value> value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!callback_.is_null())
     callback_.Run(fetch_error_code, value.Pass());
 }
 
 }  // namespace google_apis