gdata cleanup: stop passing Profile* around GData operations.

chrome/browser/chromeos/gdata/gdata_documents_service.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_documents_service.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/message_loop_proxy.h"
@@ skipping 85 matching lines @@
 
 void DocumentsService::GetDocuments(const GURL& url,
                                     int start_changestamp,
                                     const std::string& search_query,
                                     const std::string& directory_resource_id,
                                     const GetDataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GetDocumentsOperation* operation =
       new GetDocumentsOperation(operation_registry(),
-                                profile_,
                                 start_changestamp,
                                 search_query,
                                 directory_resource_id,
                                 callback);
   if (!url.is_empty())
     operation->SetUrl(url);
   runner_->StartOperationWithRetry(operation);
 }
 
 void DocumentsService::GetDocumentEntry(const std::string& resource_id,
                                         const GetDataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GetDocumentEntryOperation* operation =
       new GetDocumentEntryOperation(operation_registry(),
-                                    profile_,
                                     resource_id,
                                     callback);
   runner_->StartOperationWithRetry(operation);
 }
 
 void DocumentsService::GetAccountMetadata(const GetDataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GetAccountMetadataOperation* operation =
-      new GetAccountMetadataOperation(operation_registry(),
-                                      profile_,
-                                      callback);
+      new GetAccountMetadataOperation(operation_registry(), callback);
   runner_->StartOperationWithRetry(operation);
 }
 
 void DocumentsService::GetAboutResource(const GetDataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GetAboutOperation* operation =
-      new GetAboutOperation(operation_registry(), profile_, callback);
+      new GetAboutOperation(operation_registry(), callback);
   runner_->StartOperationWithRetry(operation);
 }
 
 void DocumentsService::GetApplicationList(const GetDataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GetApplistOperation* operation =
-      new GetApplistOperation(operation_registry(), profile_, callback);
+      new GetApplistOperation(operation_registry(), callback);
   runner_->StartOperationWithRetry(operation);
 }
 
 void DocumentsService::DownloadDocument(
     const FilePath& virtual_path,
     const FilePath& local_cache_path,
     const GURL& document_url,
     DocumentExportFormat format,
     const DownloadActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 10 matching lines @@
 
 void DocumentsService::DownloadFile(
       const FilePath& virtual_path,
       const FilePath& local_cache_path,
       const GURL& document_url,
       const DownloadActionCallback& download_action_callback,
       const GetDownloadDataCallback& get_download_data_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   runner_->StartOperationWithRetry(
-      new DownloadFileOperation(operation_registry(), profile_,
+      new DownloadFileOperation(operation_registry(),
                                 download_action_callback,
                                 get_download_data_callback, document_url,
                                 virtual_path, local_cache_path));
 }
 
 void DocumentsService::DeleteDocument(const GURL& document_url,
                                       const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   runner_->StartOperationWithRetry(
-      new DeleteDocumentOperation(operation_registry(), profile_, callback,
+      new DeleteDocumentOperation(operation_registry(), callback,
                                   document_url));
 }
 
 void DocumentsService::CreateDirectory(
     const GURL& parent_content_url,
     const FilePath::StringType& directory_name,
     const GetDataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   runner_->StartOperationWithRetry(
-      new CreateDirectoryOperation(operation_registry(), profile_, callback,
+      new CreateDirectoryOperation(operation_registry(), callback,
                                    parent_content_url, directory_name));
 }
 
 void DocumentsService::CopyDocument(const std::string& resource_id,
                                     const FilePath::StringType& new_name,
                                     const GetDataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   runner_->StartOperationWithRetry(
-      new CopyDocumentOperation(operation_registry(), profile_, callback,
+      new CopyDocumentOperation(operation_registry(), callback,
                                 resource_id, new_name));
 }
 
 void DocumentsService::RenameResource(const GURL& resource_url,
                                       const FilePath::StringType& new_name,
                                       const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   runner_->StartOperationWithRetry(
-      new RenameResourceOperation(operation_registry(), profile_, callback,
+      new RenameResourceOperation(operation_registry(), callback,
                                   resource_url, new_name));
 }
 
 void DocumentsService::AddResourceToDirectory(
     const GURL& parent_content_url,
     const GURL& resource_url,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   runner_->StartOperationWithRetry(
       new AddResourceToDirectoryOperation(operation_registry(),
-                                          profile_,
                                           callback,
                                           parent_content_url,
                                           resource_url));
 }
 
 void DocumentsService::RemoveResourceFromDirectory(
     const GURL& parent_content_url,
     const GURL& resource_url,
     const std::string& resource_id,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   runner_->StartOperationWithRetry(
       new RemoveResourceFromDirectoryOperation(operation_registry(),
-                                               profile_,
                                                callback,
                                                parent_content_url,
                                                resource_url,
                                                resource_id));
 }
 
 void DocumentsService::InitiateUpload(const InitiateUploadParams& params,
                                       const InitiateUploadCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (params.upload_location.is_empty()) {
     if (!callback.is_null())
       callback.Run(HTTP_BAD_REQUEST, GURL());
     return;
   }
 
   runner_->StartOperationWithRetry(
-      new InitiateUploadOperation(operation_registry(), profile_, callback,
-                                  params));
+      new InitiateUploadOperation(operation_registry(), callback, params));
 }
 
 void DocumentsService::ResumeUpload(const ResumeUploadParams& params,
                                     const ResumeUploadCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   runner_->StartOperationWithRetry(
-      new ResumeUploadOperation(operation_registry(), profile_, callback,
-                                params));
+      new ResumeUploadOperation(operation_registry(), callback, params));
 }
 
 
 void DocumentsService::AuthorizeApp(const GURL& resource_url,
                                     const std::string& app_ids,
                                     const GetDataCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   runner_->StartOperationWithRetry(
-      new AuthorizeAppsOperation(operation_registry(), profile_, callback,
+      new AuthorizeAppsOperation(operation_registry(), callback,
                                  resource_url, app_ids));
 }
 
 bool DocumentsService::HasAccessToken() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   return runner_->auth_service()->HasAccessToken();
 }
 
 bool DocumentsService::HasRefreshToken() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   return runner_->auth_service()->HasRefreshToken();
 }
 
 }  // namespace gdata