Move URLRequestContextGetter to RequestSender in c/b/google_apis.

chrome/browser/drive/gdata_wapi_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/drive/gdata_wapi_service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 181 matching lines @@
 // to the Drive API v2, so we'll reuse GetResourceListRequest to implement
 // following methods, instead of cleaning the request class.
 
 CancelCallback GDataWapiService::GetAllResourceList(
     const GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new GetResourceListRequest(sender_.get(),
-                                 url_request_context_getter_,
                                  url_generator_,
                                  GURL(),         // No override url
                                  0,              // start changestamp
                                  std::string(),  // empty search query
                                  std::string(),  // no directory resource id
                                  callback));
 }
 
 CancelCallback GDataWapiService::GetResourceListInDirectory(
     const std::string& directory_resource_id,
     const GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!directory_resource_id.empty());
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new GetResourceListRequest(sender_.get(),
-                                 url_request_context_getter_,
                                  url_generator_,
                                  GURL(),         // No override url
                                  0,              // start changestamp
                                  std::string(),  // empty search query
                                  directory_resource_id,
                                  callback));
 }
 
 CancelCallback GDataWapiService::Search(
     const std::string& search_query,
     const GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!search_query.empty());
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new GetResourceListRequest(sender_.get(),
-                                 url_request_context_getter_,
                                  url_generator_,
                                  GURL(),         // No override url
                                  0,              // start changestamp
                                  search_query,
                                  std::string(),  // no directory resource id
                                  callback));
 }
 
 CancelCallback GDataWapiService::SearchByTitle(
     const std::string& title,
     const std::string& directory_resource_id,
     const GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!title.empty());
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new SearchByTitleRequest(sender_.get(),
-                               url_request_context_getter_,
                                url_generator_,
                                title,
                                directory_resource_id,
                                callback));
 }
 
 CancelCallback GDataWapiService::GetChangeList(
     int64 start_changestamp,
     const GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new GetResourceListRequest(sender_.get(),
-                                 url_request_context_getter_,
                                  url_generator_,
                                  GURL(),         // No override url
                                  start_changestamp,
                                  std::string(),  // empty search query
                                  std::string(),  // no directory resource id
                                  callback));
 }
 
 CancelCallback GDataWapiService::ContinueGetResourceList(
     const GURL& override_url,
     const GetResourceListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!override_url.is_empty());
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new GetResourceListRequest(sender_.get(),
-                                 url_request_context_getter_,
                                  url_generator_,
                                  override_url,
                                  0,              // start changestamp
                                  std::string(),  // empty search query
                                  std::string(),  // no directory resource id
                                  callback));
 }
 
 CancelCallback GDataWapiService::GetResourceEntry(
     const std::string& resource_id,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new GetResourceEntryRequest(sender_.get(),
-                                  url_request_context_getter_,
                                   url_generator_,
                                   resource_id,
                                   base::Bind(&ParseResourceEntryAndRun,
                                              callback)));
 }
 
 CancelCallback GDataWapiService::GetAboutResource(
     const GetAboutResourceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new GetAccountMetadataRequest(
           sender_.get(),
-          url_request_context_getter_,
           url_generator_,
           base::Bind(&ParseAboutResourceAndRun, callback),
           false));  // Exclude installed apps.
 }
 
 CancelCallback GDataWapiService::GetAppList(
     const GetAppListCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new GetAccountMetadataRequest(sender_.get(),
-                                    url_request_context_getter_,
                                     url_generator_,
                                     base::Bind(&ParseAppListAndRun, callback),
                                     true));  // Include installed apps.
 }
 
 CancelCallback GDataWapiService::DownloadFile(
     const base::FilePath& local_cache_path,
     const GURL& download_url,
     const DownloadActionCallback& download_action_callback,
     const GetContentCallback& get_content_callback,
     const ProgressCallback& progress_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!download_action_callback.is_null());
   // get_content_callback and progress_callback may be null.
 
   return sender_->StartRequestWithRetry(
       new DownloadFileRequest(sender_.get(),
-                              url_request_context_getter_,
                               download_action_callback,
                               get_content_callback,
                               progress_callback,
                               download_url,
                               local_cache_path));
 }
 
 CancelCallback GDataWapiService::DeleteResource(
     const std::string& resource_id,
     const std::string& etag,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new DeleteResourceRequest(sender_.get(),
-                                url_request_context_getter_,
                                 url_generator_,
                                 callback,
                                 resource_id,
                                 etag));
 }
 
 CancelCallback GDataWapiService::AddNewDirectory(
     const std::string& parent_resource_id,
     const std::string& directory_name,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new CreateDirectoryRequest(sender_.get(),
-                                 url_request_context_getter_,
                                  url_generator_,
                                  base::Bind(&ParseResourceEntryAndRun,
                                             callback),
                                  parent_resource_id,
                                  directory_name));
 }
 
 CancelCallback GDataWapiService::CopyResource(
     const std::string& resource_id,
     const std::string& parent_resource_id,
@@ skipping 11 matching lines @@
 
 CancelCallback GDataWapiService::CopyHostedDocument(
     const std::string& resource_id,
     const std::string& new_name,
     const GetResourceEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new CopyHostedDocumentRequest(sender_.get(),
-                                    url_request_context_getter_,
                                     url_generator_,
                                     base::Bind(&ParseResourceEntryAndRun,
                                                callback),
                                     resource_id,
                                     new_name));
 }
 
 CancelCallback GDataWapiService::RenameResource(
     const std::string& resource_id,
     const std::string& new_name,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new RenameResourceRequest(sender_.get(),
-                                url_request_context_getter_,
                                 url_generator_,
                                 callback,
                                 resource_id,
                                 new_name));
 }
 
 CancelCallback GDataWapiService::TouchResource(
     const std::string& resource_id,
     const base::Time& modified_date,
     const base::Time& last_viewed_by_me_date,
@@ skipping 14 matching lines @@
 
 CancelCallback GDataWapiService::AddResourceToDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new AddResourceToDirectoryRequest(sender_.get(),
-                                        url_request_context_getter_,
                                         url_generator_,
                                         callback,
                                         parent_resource_id,
                                         resource_id));
 }
 
 CancelCallback GDataWapiService::RemoveResourceFromDirectory(
     const std::string& parent_resource_id,
     const std::string& resource_id,
     const EntryActionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new RemoveResourceFromDirectoryRequest(sender_.get(),
-                                             url_request_context_getter_,
                                              url_generator_,
                                              callback,
                                              parent_resource_id,
                                              resource_id));
 }
 
 CancelCallback GDataWapiService::InitiateUploadNewFile(
     const std::string& content_type,
     int64 content_length,
     const std::string& parent_resource_id,
     const std::string& title,
     const InitiateUploadCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(!parent_resource_id.empty());
 
   return sender_->StartRequestWithRetry(
       new InitiateUploadNewFileRequest(sender_.get(),
-                                       url_request_context_getter_,
                                        url_generator_,
                                        callback,
                                        content_type,
                                        content_length,
                                        parent_resource_id,
                                        title));
 }
 
 CancelCallback GDataWapiService::InitiateUploadExistingFile(
     const std::string& content_type,
     int64 content_length,
     const std::string& resource_id,
     const std::string& etag,
     const InitiateUploadCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(!resource_id.empty());
 
   return sender_->StartRequestWithRetry(
       new InitiateUploadExistingFileRequest(sender_.get(),
-                                            url_request_context_getter_,
                                             url_generator_,
                                             callback,
                                             content_type,
                                             content_length,
                                             resource_id,
                                             etag));
 }
 
 CancelCallback GDataWapiService::ResumeUpload(
     const GURL& upload_url,
     int64 start_position,
     int64 end_position,
     int64 content_length,
     const std::string& content_type,
     const base::FilePath& local_file_path,
     const UploadRangeCallback& callback,
     const ProgressCallback& progress_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new ResumeUploadRequest(sender_.get(),
-                              url_request_context_getter_,
                               callback,
                               progress_callback,
                               upload_url,
                               start_position,
                               end_position,
                               content_length,
                               content_type,
                               local_file_path));
 }
 
 CancelCallback GDataWapiService::GetUploadStatus(
     const GURL& upload_url,
     int64 content_length,
     const UploadRangeCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new GetUploadStatusRequest(sender_.get(),
-                                 url_request_context_getter_,
                                  callback,
                                  upload_url,
                                  content_length));
 }
 
 CancelCallback GDataWapiService::AuthorizeApp(
     const std::string& resource_id,
     const std::string& app_id,
     const AuthorizeAppCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   return sender_->StartRequestWithRetry(
       new AuthorizeAppRequest(sender_.get(),
-                              url_request_context_getter_,
                               url_generator_,
                               callback,
                               resource_id,
                               app_id));
 }
 
 bool GDataWapiService::HasAccessToken() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   return sender_->auth_service()->HasAccessToken();
@@ skipping 20 matching lines @@
   if (CanSendRequest()) {
     FOR_EACH_OBSERVER(
         DriveServiceObserver, observers_, OnReadyToSendRequests());
   } else if (!HasRefreshToken()) {
     FOR_EACH_OBSERVER(
         DriveServiceObserver, observers_, OnRefreshTokenInvalid());
   }
 }
 
 }  // namespace drive