Move URLRequestContextGetter to RequestSender in c/b/google_apis.

chrome/browser/chromeos/contacts/gdata_contacts_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/contacts/gdata_contacts_service.h"
 
 #include <cstring>
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 418 matching lines @@
 // Individual contacts::Contact objects are created using the data from the
 // feed.
 //
 // Finally, GetContactPhotoRequests are created and used to start downloading
 // contacts' photos in parallel.  When all photos have been downloaded, the
 // contacts are passed to the passed-in callback.
 class GDataContactsService::DownloadContactsRequest {
  public:
   DownloadContactsRequest(
       GDataContactsService* service,
-      google_apis::RequestSender* runner,
-      net::URLRequestContextGetter* url_request_context_getter,
+      google_apis::RequestSender* sender,
       SuccessCallback success_callback,
       FailureCallback failure_callback,
       const base::Time& min_update_time)
       : service_(service),
-        sender_(runner),
-        url_request_context_getter_(url_request_context_getter),
+        sender_(sender),
         success_callback_(success_callback),
         failure_callback_(failure_callback),
         min_update_time_(min_update_time),
         contacts_(new ScopedVector<contacts::Contact>),
         my_contacts_group_id_(service->cached_my_contacts_group_id_),
         num_in_progress_photo_downloads_(0),
         photo_download_failed_(false),
         num_photo_download_404_errors_(0),
         total_photo_bytes_(0),
         weak_ptr_factory_(this) {
@@ skipping 17 matching lines @@
   // Otherwise, the contact groups download is started.
   void Run() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     download_start_time_ = base::TimeTicks::Now();
     if (!my_contacts_group_id_.empty()) {
       StartContactsDownload();
     } else {
       google_apis::GetContactGroupsRequest* operation =
           new google_apis::GetContactGroupsRequest(
               sender_,
-              url_request_context_getter_,
               base::Bind(&DownloadContactsRequest::HandleGroupsFeedData,
                          weak_ptr_factory_.GetWeakPtr()));
       if (!service_->groups_feed_url_for_testing_.is_empty()) {
         operation->set_feed_url_for_testing(
             service_->groups_feed_url_for_testing_);
       }
       sender_->StartRequestWithRetry(operation);
     }
   }
 
@@ skipping 87 matching lines @@
       ReportFailure(HISTOGRAM_RESULT_MY_CONTACTS_GROUP_NOT_FOUND);
     }
   }
 
   // Starts a download of the contacts from the "My Contacts" group.
   void StartContactsDownload() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     google_apis::GetContactsRequest* operation =
         new google_apis::GetContactsRequest(
             sender_,
-            url_request_context_getter_,
             my_contacts_group_id_,
             min_update_time_,
             base::Bind(&DownloadContactsRequest::HandleContactsFeedData,
                        weak_ptr_factory_.GetWeakPtr()));
     if (!service_->contacts_feed_url_for_testing_.is_empty()) {
       operation->set_feed_url_for_testing(
           service_->contacts_feed_url_for_testing_);
     }
     sender_->StartRequestWithRetry(operation);
   }
@@ skipping 136 matching lines @@
       contacts::Contact* contact = contacts_needing_photo_downloads_.back();
       contacts_needing_photo_downloads_.pop_back();
       DCHECK(contact_photo_urls_.count(contact));
       std::string url = contact_photo_urls_[contact];
 
       VLOG(1) << "Starting download of photo " << url << " for "
               << contact->contact_id();
       sender_->StartRequestWithRetry(
           new google_apis::GetContactPhotoRequest(
               sender_,
-              url_request_context_getter_,
               GURL(url),
               base::Bind(&DownloadContactsRequest::HandlePhotoData,
                          weak_ptr_factory_.GetWeakPtr(),
                          contact)));
       num_in_progress_photo_downloads_++;
     }
   }
 
   // Callback for GetContactPhotoRequest calls.  Updates the associated
   // Contact and checks for completion.
@@ skipping 36 matching lines @@
 
     total_photo_bytes_ += download_data->size();
     contact->set_raw_untrusted_photo(*download_data);
     CheckCompletion();
   }
 
   typedef std::map<contacts::Contact*, std::string> ContactPhotoUrls;
 
   GDataContactsService* service_;  // not owned
   google_apis::RequestSender* sender_;  // not owned
-  net::URLRequestContextGetter* url_request_context_getter_;  // not owned
 
   SuccessCallback success_callback_;
   FailureCallback failure_callback_;
 
   base::Time min_update_time_;
 
   scoped_ptr<ScopedVector<contacts::Contact> > contacts_;
 
   // ID of the "My Contacts" contacts group.
   std::string my_contacts_group_id_;
@@ skipping 33 matching lines @@
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<DownloadContactsRequest> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadContactsRequest);
 };
 
 GDataContactsService::GDataContactsService(
     net::URLRequestContextGetter* url_request_context_getter,
     Profile* profile)
-    : url_request_context_getter_(url_request_context_getter),
-      max_photo_downloads_per_second_(kMaxPhotoDownloadsPerSecond),
+    : max_photo_downloads_per_second_(kMaxPhotoDownloadsPerSecond),
       photo_download_timer_interval_(base::TimeDelta::FromSeconds(1)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   std::vector<std::string> scopes;
   scopes.push_back(kContactsScope);
   sender_.reset(new google_apis::RequestSender(profile,
-                                               url_request_context_getter_,
+                                               url_request_context_getter,
                                                scopes,
                                                "" /* custom_user_agent */));
 }
 
 GDataContactsService::~GDataContactsService() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   STLDeleteContainerPointers(requests_.begin(), requests_.end());
   requests_.clear();
 }
 
 google_apis::AuthService* GDataContactsService::auth_service_for_testing() {
   return sender_->auth_service();
 }
 
 void GDataContactsService::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   sender_->Initialize();
 }
 
 void GDataContactsService::DownloadContacts(SuccessCallback success_callback,
                                             FailureCallback failure_callback,
                                             const base::Time& min_update_time) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DownloadContactsRequest* request =
       new DownloadContactsRequest(this,
                                   sender_.get(),
-                                  url_request_context_getter_,
                                   success_callback,
                                   failure_callback,
                                   min_update_time);
   VLOG(1) << "Starting contacts download with request " << request;
   requests_.insert(request);
   request->Run();
 }
 
 void GDataContactsService::OnRequestComplete(DownloadContactsRequest* request) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(request);
   VLOG(1) << "Download request " << request << " complete";
   if (!request->my_contacts_group_id().empty())
     cached_my_contacts_group_id_ = request->my_contacts_group_id();
   requests_.erase(request);
   delete request;
 }
 
 }  // namespace contacts