[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 147 matching lines @@
 
   for (size_t i = 0; i < task_queue->tasks.size(); ++i)
     task_queue->tasks[i].Run();
   task_queue->tasks.clear();
 }
 
 class GCMProfileService::IOWorker
     : public GCMClient::Delegate,
       public base::RefCountedThreadSafe<GCMProfileService::IOWorker>{
  public:
+  // Called on UI thread.
   explicit IOWorker(const base::WeakPtr<GCMProfileService>& service);
+  void Initialize();
 
   // Overridden from GCMClient::Delegate:
-  // Called from IO thread.
+  // Called on IO thread.
   virtual void OnCheckInFinished(const GCMClient::CheckinInfo& checkin_info,
                                  GCMClient::Result result) OVERRIDE;
   virtual void OnRegisterFinished(const std::string& app_id,
                                   const std::string& registration_id,
                                   GCMClient::Result result) OVERRIDE;
   virtual void OnSendFinished(const std::string& app_id,
                               const std::string& message_id,
                               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();
 
+  void InitializeGCMClient();
+
   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) {
+    : service_(service),
+      gcm_client_(NULL) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 }
 
 GCMProfileService::IOWorker::~IOWorker() {
 }
 
+void GCMProfileService::IOWorker::Initialize() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&GCMProfileService::IOWorker::InitializeGCMClient, this));
+}
+
+void GCMProfileService::IOWorker::InitializeGCMClient() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+
+  gcm_client_ = GCMClientFactory::GetClient();
+}
+
 void GCMProfileService::IOWorker::OnCheckInFinished(
     const GCMClient::CheckinInfo& checkin_info,
     GCMClient::Result result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   checkin_info_ = checkin_info;
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
@@ skipping 81 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();
 }
 
 GCMProfileService::~GCMProfileService() {
   if (username_.empty())
     return;
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMProfileService::IOWorker::RemoveUser,
                  io_worker_,
                  username_));
 }
 
 void GCMProfileService::Init() {
   delayed_task_controller_.reset(new DelayedTaskController);
 
   // This has to be done first since CheckIn depends on it.
   io_worker_ = new IOWorker(weak_ptr_factory_.GetWeakPtr());
+  io_worker_->Initialize();

[Nicolas Zea, 2014/01/21 23:04:45]

I think it's cleaner to have the GCMProfileService do:
PostTask(IO, ..., base::Bind(..IOWoker::Initialize, io_worker_))

and make replace Initialize's implementation with InitializeGCMClient. That way
the IOWorker truly is an IO worker, including the initialize code.

[jianli, 2014/01/21 23:16:16]

Good idea. Also moved the logic defined in CheckGCMClientLoading to
IOWorker::Initialize and remove the following task posting.

 
   // Checks if GCMClient has finished the loading.
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMProfileService::IOWorker::CheckGCMClientLoading,
                  io_worker_));
 
   // In case that the profile has been signed in before GCMProfileService is
   // created.
@@ skipping 464 matching lines @@
 
   return true;
 }
 
 // static
 const char* GCMProfileService::GetPersistentRegisterKeyForTesting() {
   return kRegistrationKey;
 }
 
 }  // namespace gcm