Make GCMProfileService own GCMDriver, instead of deriving from it

chrome/browser/services/gcm/gcm_driver.cc

 // Copyright 2014 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_driver.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 364 matching lines @@
     stats = gcm_client_->GetStatistics();
     stats.gcm_client_created = true;
   }
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&GCMDriver::GetGCMStatisticsFinished, service_, stats));
 }
 
-GCMDriver::GCMDriver(scoped_ptr<IdentityProvider> identity_provider)
-    : identity_provider_(identity_provider.Pass()),
+GCMDriver::GCMDriver(
+    scoped_ptr<GCMClientFactory> gcm_client_factory,
+    scoped_ptr<IdentityProvider> identity_provider,
+    const base::FilePath& store_path,
+    const scoped_refptr<net::URLRequestContextGetter>& request_context)
+    : gcm_enabled_(true),
       gcm_client_ready_(false),
+      identity_provider_(identity_provider.Pass()),
       weak_ptr_factory_(this) {
-}
-
-GCMDriver::~GCMDriver() {
-}
-
-void GCMDriver::Initialize(scoped_ptr<GCMClientFactory> gcm_client_factory) {
   // Get the list of available accounts.
   std::vector<std::string> account_ids;
 #if !defined(OS_ANDROID)
   account_ids = identity_provider_->GetTokenService()->GetAccounts();
 #endif
 
   // Create and initialize the GCMClient. Note that this does not initiate the
   // GCM check-in.
-  DCHECK(!io_worker_);
   io_worker_.reset(new IOWorker());
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMDriver::IOWorker::Initialize,
                  base::Unretained(io_worker_.get()),
                  base::Passed(&gcm_client_factory),
-                 GetStorePath(),
+                 store_path,
                  account_ids,
-                 GetURLRequestContextGetter()));
-
-  // Start the GCM service if the rollout signal indicates yes.
-  if (ShouldStartAutomatically())
-    EnsureStarted();
+                 request_context));
 
   identity_provider_->AddObserver(this);
 }
 
-void GCMDriver::Start() {
+GCMDriver::GCMDriver()
+    : gcm_enabled_(true),
+      gcm_client_ready_(false),
+      weak_ptr_factory_(this) {
+}
+
+GCMDriver::~GCMDriver() {
+}
+
+void GCMDriver::Enable() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
+  if (gcm_enabled_)
+    return;
+  gcm_enabled_ = true;
+
   EnsureStarted();
 }
 
+void GCMDriver::Disable() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  if (!gcm_enabled_)
+    return;
+  gcm_enabled_ = false;
+
+  Stop();
+}
+
 void GCMDriver::Stop() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   // No need to stop GCM service if not started yet.
   if (account_id_.empty())
     return;
 
   RemoveCachedData();
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMDriver::IOWorker::Stop,
                  base::Unretained(io_worker_.get())));
 }
 
-void GCMDriver::ShutdownService() {
+void GCMDriver::Shutdown() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   identity_provider_->RemoveObserver(this);
   for (GCMAppHandlerMap::const_iterator iter = app_handlers_.begin();
        iter != app_handlers_.end(); ++iter) {
     iter->second->ShutdownHandler();
   }
   app_handlers_.clear();
   content::BrowserThread::DeleteSoon(content::BrowserThread::IO,
                                      FROM_HERE,
                                      io_worker_.release());
 }
 
 void GCMDriver::AddAppHandler(const std::string& app_id,
                               GCMAppHandler* handler) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(!app_id.empty());
   DCHECK(handler);
   DCHECK(app_handlers_.find(app_id) == app_handlers_.end());
 
   app_handlers_[app_id] = handler;
+
+   // Ensures that the GCM service is started when there is an interest.
+  EnsureStarted();
 }
 
 void GCMDriver::RemoveAppHandler(const std::string& app_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(!app_id.empty());
 
   app_handlers_.erase(app_id);
 }
 
 void GCMDriver::Register(const std::string& app_id,
                          const std::vector<std::string>& sender_ids,
                          const RegisterCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(!app_id.empty());
   DCHECK(!sender_ids.empty());
   DCHECK(!callback.is_null());
 
-  GCMClient::Result result = EnsureAppReady(app_id);
+  GCMClient::Result result = EnsureStarted();
   if (result != GCMClient::SUCCESS) {
     callback.Run(std::string(), result);
     return;
   }
 
   // If previous un/register operation is still in progress, bail out.
   if (IsAsyncOperationPending(app_id)) {
     callback.Run(std::string(), GCMClient::ASYNC_OPERATION_PENDING);
     return;
   }
@@ skipping 34 matching lines @@
                  app_id,
                  normalized_sender_ids));
 }
 
 void GCMDriver::Unregister(const std::string& app_id,
                            const UnregisterCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(!app_id.empty());
   DCHECK(!callback.is_null());
 
-  GCMClient::Result result = EnsureAppReady(app_id);
+  GCMClient::Result result = EnsureStarted();
   if (result != GCMClient::SUCCESS) {
     callback.Run(result);
     return;
   }
 
   // If previous un/register operation is still in progress, bail out.
   if (IsAsyncOperationPending(app_id)) {
     callback.Run(GCMClient::ASYNC_OPERATION_PENDING);
     return;
   }
@@ skipping 27 matching lines @@
 
 void GCMDriver::Send(const std::string& app_id,
                      const std::string& receiver_id,
                      const GCMClient::OutgoingMessage& message,
                      const SendCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(!app_id.empty());
   DCHECK(!receiver_id.empty());
   DCHECK(!callback.is_null());
 
-  GCMClient::Result result = EnsureAppReady(app_id);
+  GCMClient::Result result = EnsureStarted();
   if (result != GCMClient::SUCCESS) {
     callback.Run(std::string(), result);
     return;
   }
 
   // If the message with send ID is still in progress, bail out.
   std::pair<std::string, std::string> key(app_id, message.id);
   if (send_callbacks_.find(key) != send_callbacks_.end()) {
     callback.Run(message.id, GCMClient::INVALID_PARAMETER);
     return;
@@ skipping 64 matching lines @@
   request_gcm_statistics_callback_ = callback;
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMDriver::IOWorker::SetGCMRecording,
                  base::Unretained(io_worker_.get()),
                  recording));
 }
 
 void GCMDriver::OnActiveAccountLogin() {
-  if (ShouldStartAutomatically())
-    EnsureStarted();
+  EnsureStarted();
 }
 
 void GCMDriver::OnActiveAccountLogout() {
   CheckOut();
 }
 
-void GCMDriver::EnsureStarted() {
+GCMClient::Result GCMDriver::EnsureStarted() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  if (!gcm_enabled_)
+    return GCMClient::GCM_DISABLED;
+
+  // Is the user signed in?
   const std::string account_id = identity_provider_->GetActiveAccountId();
   if (account_id.empty())
-    return;
+    return GCMClient::NOT_SIGNED_IN;
 
   // CheckIn could be called more than once when:
   // 1) The password changes.
   // 2) Register/send function calls it to ensure CheckIn is done.
   if (account_id_ == account_id)
-    return;
+    return GCMClient::SUCCESS;
   account_id_ = account_id;
 
   DCHECK(!delayed_task_controller_);
   delayed_task_controller_.reset(new DelayedTaskController);
 
   // Note that we need to pass weak pointer again since the existing weak
   // pointer in IOWorker might have been invalidated when check-out occurs.
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMDriver::IOWorker::Start,
                  base::Unretained(io_worker_.get()),
                  weak_ptr_factory_.GetWeakPtr()));
+
+  return GCMClient::SUCCESS;
 }
 
 void GCMDriver::RemoveCachedData() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   // Remove all the queued tasks since they no longer make sense after
   // GCM service is stopped.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   account_id_.clear();
   gcm_client_ready_ = false;
@@ skipping 11 matching lines @@
 
   RemoveCachedData();
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMDriver::IOWorker::CheckOut,
                  base::Unretained(io_worker_.get())));
 }
 
-GCMClient::Result GCMDriver::EnsureAppReady(const std::string& app_id) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-
-  // Starts the service if not yet.
-  EnsureStarted();
-
-  // If the service cannot be started, bail out.
-  if (account_id_.empty())
-    return GCMClient::NOT_SIGNED_IN;
-
-  return GCMClient::SUCCESS;
-}
-
 bool GCMDriver::IsAsyncOperationPending(const std::string& app_id) const {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   return register_callbacks_.find(app_id) != register_callbacks_.end() ||
          unregister_callbacks_.find(app_id) != unregister_callbacks_.end();
 }
 
 void GCMDriver::RegisterFinished(const std::string& app_id,
                                  const std::string& registration_id,
                                  GCMClient::Result result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
@@ skipping 96 matching lines @@
 void GCMDriver::GetGCMStatisticsFinished(GCMClient::GCMStatistics stats) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   // Normally request_gcm_statistics_callback_ would not be null.
   if (!request_gcm_statistics_callback_.is_null())
     request_gcm_statistics_callback_.Run(stats);
   else
     LOG(WARNING) << "request_gcm_statistics_callback_ is NULL.";
 }
 
+std::string GCMDriver::SignedInUserName() const {
+  if (IsStarted())
+    return identity_provider_->GetActiveUsername();
+  return std::string();
+}
+
 }  // namespace gcm