[GCM] Stop/restart GCM when the state is forced off/on

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 <string>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 246 matching lines @@
                                   GCMClient::Result result) OVERRIDE;
   virtual void OnGCMReady() OVERRIDE;
 
   // Called on IO thread.
   void Initialize(scoped_ptr<GCMClientFactory> gcm_client_factory,
                   const base::FilePath& store_path,
                   const std::vector<std::string>& account_ids,
                   const scoped_refptr<net::URLRequestContextGetter>&
                       url_request_context_getter);
   void Reset();
   void Load(const base::WeakPtr<GCMProfileService>& service);

[Dmitry Titov, 2014/03/04 02:47:51]

Note: If you rename GCMClient::Load -> Start, you will need to rename this too,
and perhaps GCMProfileService::EnsureLoaded() as well...

[jianli, 2014/03/04 05:14:26]

Yes, will rename all these if we proceed with the renaming.

+  void Stop();
   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);
 
   // For testing purpose. Can be called from UI thread. Use with care.
@@ skipping 141 matching lines @@
 }
 
 void GCMProfileService::IOWorker::Load(
     const base::WeakPtr<GCMProfileService>& service) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   service_ = service;
   gcm_client_->Load();
 }
 
+void GCMProfileService::IOWorker::Stop() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+
+  gcm_client_->Stop();
+}
+
 void GCMProfileService::IOWorker::CheckOut() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
   gcm_client_->CheckOut();
 
   // Note that we still need to keep GCMClient instance alive since the profile
   // might be signed in again.
 }
 
 void GCMProfileService::IOWorker::Register(
@@ skipping 113 matching lines @@
                  profile_->GetPath().Append(chrome::kGCMStoreDirname),
                  account_ids,
                  url_request_context_getter));
 
   // Load from the GCM store and initiate the GCM check-in if the rollout signal
   // indicates yes.
   if (GetGCMEnabledState(profile_) == ALWAYS_ENABLED)
     EnsureLoaded();
 }
 
+void GCMProfileService::Start() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  EnsureLoaded();
+}
+
+void GCMProfileService::Stop() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  // No need to stop GCM service if not signed in yet.
+  if (username_.empty())
+    return;
+  username_.clear();

[fgorski, 2014/03/04 20:07:49]

Seems that clearing username could be a part of RemoveCachedData... after all it
is an information that you are caching. And clearing coincides with calls to
RemoveCachedData.

[jianli, 2014/03/04 20:52:26]

Done.

+
+  RemoveCachedData();
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&GCMProfileService::IOWorker::Stop, io_worker_));
+}
+
 void GCMProfileService::Register(const std::string& app_id,
                                  const std::vector<std::string>& sender_ids,
                                  const std::string& cert,
                                  RegisterCallback callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(!app_id.empty() && !sender_ids.empty() && !callback.is_null());
 
   // Ensure that check-in has been done.
   EnsureLoaded();
 
@@ skipping 193 matching lines @@
   // 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(&GCMProfileService::IOWorker::Load,
                  io_worker_,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void GCMProfileService::CheckOut() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-
-  // We still proceed with the check-out logic even if the check-in is not
-  // initiated in the current session. This will make sure that all the
-  // persisted data written previously will get purged.
-  username_.clear();
-
+void GCMProfileService::RemoveCachedData() {
   // Remove all the queued tasks since they no longer make sense after
-  // check-out.
+  // GCM service is stopped.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
+  gcm_client_ready_ = false;
+  delayed_task_controller_.reset();
+  register_callbacks_.clear();
+  send_callbacks_.clear();
+  registration_info_map_.clear();
+}
+
+void GCMProfileService::RemovePersistedData() {
   // Remove persisted data from app's state store.
   for (RegistrationInfoMap::const_iterator iter =
            registration_info_map_.begin();
        iter != registration_info_map_.end(); ++iter) {
     DeleteRegistrationInfo(iter->first);
   }
 
   // Remove persisted data from prefs store.
   profile_->GetPrefs()->ClearPref(prefs::kGCMRegisteredAppIDs);
+}
 
-  gcm_client_ready_ = false;
-  delayed_task_controller_.reset();
-  register_callbacks_.clear();
-  send_callbacks_.clear();
-  registration_info_map_.clear();
+void GCMProfileService::CheckOut() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  // We still proceed with the check-out logic even if the check-in is not
+  // initiated in the current session. This will make sure that all the
+  // persisted data written previously will get purged.
+  username_.clear();
+
+  // This has to be done before removing the cached data since we need to do
+  // the lookup based on the cached data.
+  RemovePersistedData();
+
+  RemoveCachedData();
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMProfileService::IOWorker::CheckOut, io_worker_));
 }
 
 void GCMProfileService::ResetGCMClient() {
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
@@ skipping 257 matching lines @@
 
   return true;
 }
 
 // static
 const char* GCMProfileService::GetPersistentRegisterKeyForTesting() {
   return kRegistrationKey;
 }
 
 }  // namespace gcm