gdata cleanup: stop passing Profile* around GData operations.

chrome/browser/chromeos/gdata/operations_base.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/operations_base.h"
 
 #include "base/json/json_reader.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
@@ skipping 63 matching lines @@
   }
 }
 
 }  // namespace
 
 namespace gdata {
 
 //================================ AuthOperation ===============================
 
 AuthOperation::AuthOperation(GDataOperationRegistry* registry,
-                             Profile* profile,
                              const AuthStatusCallback& callback,
                              const std::string& refresh_token)
     : GDataOperationRegistry::Operation(registry),
-      profile_(profile), refresh_token_(refresh_token), callback_(callback) {
+      refresh_token_(refresh_token), callback_(callback) {
 }
 
 AuthOperation::~AuthOperation() {}
 
 void AuthOperation::Start() {
   DCHECK(!refresh_token_.empty());
   std::vector<std::string> scopes;
   scopes.push_back(kDocsListScope);
   scopes.push_back(kSpreadsheetsScope);
   scopes.push_back(kUserContentScope);
@@ skipping 49 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("GData.AuthSuccess",
                               kSuccessRatioHistogramFailure,
                               kSuccessRatioHistogramMaxValue);
     callback_.Run(HTTP_UNAUTHORIZED, std::string());
   }
   NotifyFinish(GDataOperationRegistry::OPERATION_FAILED);
 }
 
 //============================ UrlFetchOperationBase ===========================
 
-UrlFetchOperationBase::UrlFetchOperationBase(GDataOperationRegistry* registry,
-                                             Profile* profile)
+UrlFetchOperationBase::UrlFetchOperationBase(GDataOperationRegistry* registry)
     : GDataOperationRegistry::Operation(registry),
-      profile_(profile),
       re_authenticate_count_(0),
       save_temp_file_(false),
       started_(false) {
 }
 
 UrlFetchOperationBase::UrlFetchOperationBase(
     GDataOperationRegistry* registry,
     GDataOperationRegistry::OperationType type,
-    const FilePath& path,
-    Profile* profile)
+    const FilePath& path)
     : GDataOperationRegistry::Operation(registry, type, path),
-      profile_(profile),
       re_authenticate_count_(0),
       save_temp_file_(false) {
 }
 
 UrlFetchOperationBase::~UrlFetchOperationBase() {}
 
 void UrlFetchOperationBase::Start(const std::string& auth_token) {
   DCHECK(!auth_token.empty());
 
   GURL url = GetURL();
@@ skipping 144 matching lines @@
     headers.assign("Response headers are malformed!!");
   } else {
     url_fetcher->GetResponseHeaders()->GetNormalizedHeaders(&headers);
   }
   return headers;
 }
 
 //============================ EntryActionOperation ============================
 
 EntryActionOperation::EntryActionOperation(GDataOperationRegistry* registry,
-                                           Profile* profile,
                                            const EntryActionCallback& callback,
                                            const GURL& document_url)
-    : UrlFetchOperationBase(registry, profile),
+    : UrlFetchOperationBase(registry),
       callback_(callback),
       document_url_(document_url) {
 }
 
 EntryActionOperation::~EntryActionOperation() {}
 
 void EntryActionOperation::ProcessURLFetchResults(const URLFetcher* source) {
   if (!callback_.is_null()) {
     GDataErrorCode code = GetErrorCode(source);
     callback_.Run(code, document_url_);
   }
   const bool success = true;
   OnProcessURLFetchResultsComplete(success);
 }
 
 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),
+    : UrlFetchOperationBase(registry),
       callback_(callback),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
 }
 
 GetDataOperation::~GetDataOperation() {}
 
 void GetDataOperation::ProcessURLFetchResults(const URLFetcher* source) {
   std::string data;
   source->GetResponseAsString(&data);
   scoped_ptr<base::Value> root_value;
@@ skipping 51 matching lines @@
     success = false;
   }
 
   // The ownership of the parsed json object is transfered to RunCallBack(),
   // keeping the ownership of the |value| here.
   RunCallback(fetch_error_code, value->Pass());
 
   DCHECK(!value->get());
 
   OnProcessURLFetchResultsComplete(success);
-  // |value| will be deleted after return beause it is base::Owned()'d.
+  // |value| will be deleted after return because it is base::Owned()'d.
 }
 
 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 gdata