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)
+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)
     : identity_provider_(identity_provider.Pass()),
+      gcm_enabled_(true),
       gcm_client_ready_(false),
       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,
@@ skipping 185 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())
+  if (gcm_enabled_)
     EnsureStarted();
 }
 
 void GCMDriver::OnActiveAccountLogout() {
   CheckOut();
 }
 
 void GCMDriver::EnsureStarted() {

[fgorski, 2014/05/19 17:33:32]

please make sure to check on gcm_enabled_

[jianli, 2014/05/19 18:37:20]

Done.

   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   const std::string account_id = identity_provider_->GetActiveAccountId();
   if (account_id.empty())
     return;
 
   // 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;
@@ skipping 163 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