[GCM] Reland: Introduce GCMClientFactory to create GCMClient for GCMProfileService

chrome/browser/services/gcm/gcm_profile_service.cc

 // Copyright (c) 2013 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/services/gcm/gcm_profile_service.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/state_store.h"
+#include "chrome/browser/services/gcm/gcm_client_factory.h"
 #include "chrome/browser/services/gcm/gcm_event_router.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "components/webdata/encryptor/encryptor.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
@@ skipping 168 matching lines @@
                               GCMClient::Result result) OVERRIDE;
   virtual void OnMessageReceived(
       const std::string& app_id,
       const GCMClient::IncomingMessage& message) OVERRIDE;
   virtual void OnMessagesDeleted(const std::string& app_id) OVERRIDE;
   virtual void OnMessageSendError(const std::string& app_id,
                                   const std::string& message_id,
                                   GCMClient::Result result) OVERRIDE;
   virtual GCMClient::CheckinInfo GetCheckinInfo() const OVERRIDE;
   virtual void OnLoadingCompleted() OVERRIDE;
-  virtual base::TaskRunner* GetFileTaskRunner() OVERRIDE;
 
   void CheckGCMClientLoading();
   void SetUser(const std::string& username);
   void RemoveUser(const std::string& username);
   void CheckIn();
   // TODO(fgorski): Update to pass by const ref.
   void SetCheckinInfo(GCMClient::CheckinInfo checkin_info);
   void CheckOut();
   void Register(const std::string& app_id,
                 const std::vector<std::string>& sender_ids,
                 const std::string& cert);
   void Unregister(const std::string& app_id);
   void Send(const std::string& app_id,
             const std::string& receiver_id,
             const GCMClient::OutgoingMessage& message);
 
  private:
   friend class base::RefCountedThreadSafe<IOWorker>;
   virtual ~IOWorker();
 
   const base::WeakPtr<GCMProfileService> service_;
 
+  // Not owned.
+  GCMClient* gcm_client_;
+
   // The username (email address) of the signed-in user.
   std::string username_;
 
   // The checkin info obtained from the server for the signed in user associated
   // with the profile.
   GCMClient::CheckinInfo checkin_info_;
 };
 
 GCMProfileService::IOWorker::IOWorker(
     const base::WeakPtr<GCMProfileService>& service)
     : service_(service) {
+  gcm_client_ = GCMClientFactory::GetClient();

[fgorski, 2014/01/16 23:18:31]

will it work on the initialization list?
: service_(service),
  gcm_client_(GCMClientFactory::GetClient()) {
}

Or is that incorrect for some reason?

[jianli, 2014/01/17 00:43:54]

Yes, your suggestion works. However, I need to move setting gcm_client_ to
another method.

 }
 
 GCMProfileService::IOWorker::~IOWorker() {
 }
 
 void GCMProfileService::IOWorker::OnCheckInFinished(
     const GCMClient::CheckinInfo& checkin_info,
     GCMClient::Result result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
@@ skipping 86 matching lines @@
 }
 
 void GCMProfileService::IOWorker::OnLoadingCompleted() {
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&GCMProfileService::GCMClientLoadingFinished,
                  service_));
 }
 
-base::TaskRunner* GCMProfileService::IOWorker::GetFileTaskRunner() {
-  // TODO(jianli): to be implemented.
-  return NULL;
-}
-
 void GCMProfileService::IOWorker::CheckGCMClientLoading() {
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&GCMProfileService::CheckGCMClientLoadingFinished,
                  service_,
-                 GCMClient::Get()->IsLoading()));
+                 gcm_client_->IsLoading()));
 }
 
 void GCMProfileService::IOWorker::SetUser(const std::string& username) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(username_.empty() && !username.empty());
 
   username_ = username;
-  GCMClient::Get()->SetUserDelegate(username_, this);
+  gcm_client_->SetUserDelegate(username_, this);
 }
 
 void GCMProfileService::IOWorker::RemoveUser(const std::string& username) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(!username.empty());
 
   if (username_.empty())
     return;
   username_.clear();
-  GCMClient::Get()->SetUserDelegate(username_, NULL);
+  gcm_client_->SetUserDelegate(username_, NULL);
 }
 
 void GCMProfileService::IOWorker::CheckIn() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
-  GCMClient::Get()->CheckIn(username_);
+  gcm_client_->CheckIn(username_);
 }
 
 void GCMProfileService::IOWorker::SetCheckinInfo(
     GCMClient::CheckinInfo checkin_info) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   checkin_info_ = checkin_info;
 }
 
 void GCMProfileService::IOWorker::CheckOut() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   username_.clear();
   checkin_info_.Reset();
 }
 
 void GCMProfileService::IOWorker::Register(
     const std::string& app_id,
     const std::vector<std::string>& sender_ids,
     const std::string& cert) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(!username_.empty() && checkin_info_.IsValid());
 
-  GCMClient::Get()->Register(username_, app_id, cert, sender_ids);
+  gcm_client_->Register(username_, app_id, cert, sender_ids);
 }
 
 void GCMProfileService::IOWorker::Unregister(const std::string& app_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(!username_.empty() && checkin_info_.IsValid());
 
-  GCMClient::Get()->Unregister(username_, app_id);
+  gcm_client_->Unregister(username_, app_id);
 }
 
 void GCMProfileService::IOWorker::Send(
     const std::string& app_id,
     const std::string& receiver_id,
     const GCMClient::OutgoingMessage& message) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(!username_.empty() && checkin_info_.IsValid());
 
-  GCMClient::Get()->Send(username_, app_id, receiver_id, message);
+  gcm_client_->Send(username_, app_id, receiver_id, message);
 }
 
 GCMProfileService::RegistrationInfo::RegistrationInfo() {
 }
 
 GCMProfileService::RegistrationInfo::~RegistrationInfo() {
 }
 
 bool GCMProfileService::RegistrationInfo::IsValid() const {
   return !sender_ids.empty() && !registration_id.empty();
@@ skipping 28 matching lines @@
       prefs::kGCMUserToken,
       "",
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 GCMProfileService::GCMProfileService(Profile* profile)
     : profile_(profile),
       testing_delegate_(NULL),
       weak_ptr_factory_(this) {
   DCHECK(!profile->IsOffTheRecord());
+
   Init();
 }
 
 GCMProfileService::GCMProfileService(Profile* profile,
                                      TestingDelegate* testing_delegate)
     : profile_(profile),
       testing_delegate_(testing_delegate),
       weak_ptr_factory_(this) {
   Init();
 }
@@ skipping 491 matching lines @@
 
   return true;
 }
 
 // static
 const char* GCMProfileService::GetPersistentRegisterKeyForTesting() {
   return kRegistrationKey;
 }
 
 }  // namespace gcm