[GCM] Remove all persisted data and close connections when signing out of a profile

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/files/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
@@ skipping 461 matching lines @@
   bool on_by_default = false;
   if (channel == chrome::VersionInfo::CHANNEL_UNKNOWN ||
       channel == chrome::VersionInfo::CHANNEL_CANARY ||
       channel == chrome::VersionInfo::CHANNEL_DEV) {
     on_by_default = true;
   }
   registry->RegisterBooleanPref(
       prefs::kGCMChannelEnabled,
       on_by_default,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterListPref(
+      prefs::kGCMRegisteredAppIDs,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 GCMProfileService::GCMProfileService(Profile* profile)
     : profile_(profile),
       gcm_client_ready_(false),
       testing_delegate_(NULL),
       weak_ptr_factory_(this) {
   DCHECK(!profile->IsOffTheRecord());
 }
 
@@ skipping 15 matching lines @@
                  chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL,
                  content::Source<Profile>(profile_));
   registrar_.Add(this,
                  chrome::NOTIFICATION_GOOGLE_SIGNED_OUT,
                  content::Source<Profile>(profile_));
   registrar_.Add(this,
                  chrome::NOTIFICATION_PROFILE_DESTROYED,
                  content::Source<Profile>(profile_));
   // TODO(jianli): move extension specific logic out of GCMProfileService.
   registrar_.Add(this,
-                 chrome::NOTIFICATION_EXTENSION_LOADED,
-                 content::Source<Profile>(profile_));
-  registrar_.Add(this,
                  chrome:: NOTIFICATION_EXTENSION_UNINSTALLED,
                  content::Source<Profile>(profile_));
 
   // In case that the profile has been signed in before GCMProfileService is
   // created.
   SigninManagerBase* manager = SigninManagerFactory::GetForProfile(profile_);
   if (manager) {
     std::string username = manager->GetAuthenticatedUsername();
     if (!username.empty())
       CheckIn(username);
@@ skipping 64 matching lines @@
                  GCMClient::SUCCESS);
     return;
   }
 
   // Cache the sender IDs. The registration ID will be filled when the
   // registration completes.
   RegistrationInfo registration_info;
   registration_info.sender_ids = normalized_sender_ids;
   registration_info_map_[app_id] = registration_info;
 
+  // Save the IDs of all registered apps such that we know what to remove from
+  // the the app's state store when the profile is signed out.
+  WriteRegisteredAppIDs();
+
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMProfileService::IOWorker::Register,
                  io_worker_,
                  app_id,
                  normalized_sender_ids,
                  cert));
 }
 
@@ skipping 61 matching lines @@
       if (username_ != signin_details->username)
         CheckIn(signin_details->username);
       break;
     }
     case chrome::NOTIFICATION_GOOGLE_SIGNED_OUT:
       CheckOut();
       break;
     case chrome::NOTIFICATION_PROFILE_DESTROYED:
       ResetGCMClient();
       break;
-    case chrome::NOTIFICATION_EXTENSION_LOADED: {
-      extensions::Extension* extension =
-          content::Details<extensions::Extension>(details).ptr();
-      // No need to load the persisted registration info if the extension does
-      // not have the GCM permission.
-      if (extension->HasAPIPermission(extensions::APIPermission::kGcm))
-        EnsureAppReady(extension->id());
-      break;
-    }
     case chrome:: NOTIFICATION_EXTENSION_UNINSTALLED: {
       extensions::Extension* extension =
           content::Details<extensions::Extension>(details).ptr();
       Unregister(extension->id());
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 void GCMProfileService::CheckIn(const std::string& username) {
   DCHECK(!username.empty() && username_.empty());
   username_ = username;
 
   DCHECK(!delayed_task_controller_);
   delayed_task_controller_.reset(new DelayedTaskController);
 
+  // Load all register apps.
+  ReadRegisteredAppIDs();
+
   // Let the IO thread create and initialize GCMClient.
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter =
       profile_->GetRequestContext();
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMProfileService::IOWorker::Initialize,
                  io_worker_,
                  gcm_client_factory_.get(),
                  profile_->GetPath().Append(chrome::kGCMStoreDirname),
                  url_request_context_getter));
 }
 
 void GCMProfileService::CheckOut() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   DCHECK(!username_.empty());
   username_.clear();
 
+  // 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::kGCMChannelEnabled);
+  profile_->GetPrefs()->ClearPref(prefs::kGCMRegisteredAppIDs);
+
   gcm_client_ready_ = false;
   delayed_task_controller_.reset();
   register_callbacks_.clear();
   send_callbacks_.clear();
   registration_info_map_.clear();
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMProfileService::IOWorker::CheckOut, io_worker_));
@@ skipping 21 matching lines @@
   DCHECK(register_callbacks_.find(app_id) == register_callbacks_.end());
 
   // Remove the cached registration info. If not found, there is no need to
   // ask the server to unregister it.
   RegistrationInfoMap::iterator registration_info_iter =
       registration_info_map_.find(app_id);
   if (registration_info_iter == registration_info_map_.end())
     return;
   registration_info_map_.erase(registration_info_iter);
 
+  // Update the persisted IDs of registered apps.
+  WriteRegisteredAppIDs();
+
   // Remove the persisted registration info.
   DeleteRegistrationInfo(app_id);
 
   // No need to track the app any more.
   delayed_task_controller_->RemoveApp(app_id);
 
   // Ask the server to unregister it. There could be a small chance that the
   // unregister request fails. If this occurs, it does not bring any harm since
   // we simply reject the messages/events received from the server.
   content::BrowserThread::PostTask(
@@ skipping 108 matching lines @@
     const {
   if (testing_delegate_ && testing_delegate_->GetEventRouter())
     return testing_delegate_->GetEventRouter();
 #if defined(OS_ANDROID)
   return NULL;
 #else
   return js_event_router_.get();
 #endif
 }
 
+void GCMProfileService::ReadRegisteredAppIDs() {
+  const base::ListValue* app_id_list =
+      profile_->GetPrefs()->GetList(prefs::kGCMRegisteredAppIDs);
+  for (size_t i = 0; i < app_id_list->GetSize(); ++i) {
+    std::string app_id;
+    if (!app_id_list->GetString(i, &app_id))
+      continue;
+    ReadRegistrationInfo(app_id);
+  }
+}
+
+void GCMProfileService::WriteRegisteredAppIDs() {
+  base::ListValue apps;
+  for (RegistrationInfoMap::const_iterator iter =
+           registration_info_map_.begin();
+       iter != registration_info_map_.end(); ++iter) {
+    apps.Append(new base::StringValue(iter->first));
+  }
+  profile_->GetPrefs()->Set(prefs::kGCMRegisteredAppIDs, apps);
+}
+
 void GCMProfileService::DeleteRegistrationInfo(const std::string& app_id) {
   extensions::StateStore* storage =
       extensions::ExtensionSystem::Get(profile_)->state_store();
   DCHECK(storage);
 
   storage->RemoveExtensionValue(app_id, kRegistrationKey);
 }
 
 void GCMProfileService::WriteRegistrationInfo(const std::string& app_id) {
   extensions::StateStore* storage =
@@ skipping 77 matching lines @@
 
   return true;
 }
 
 // static
 const char* GCMProfileService::GetPersistentRegisterKeyForTesting() {
   return kRegistrationKey;
 }
 
 }  // namespace gcm