[GCM] Make GCM API not work in incognito mode

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"
@@ skipping 20 matching lines @@
 const char kRegistrationKey[] = "gcm.registration";
 const char kSendersKey[] = "senders";
 const char kRegistrationIDKey[] = "reg_id";
 
 // Helper class to save tasks to run until we're ready to execute them.
 class GCMProfileService::DelayedTaskController {
  public:
   DelayedTaskController();
   ~DelayedTaskController();
 
-  // Adds an app to non-ready list that queue all tasks to invoke until ready.
+  // Adds an app to the tracking list. It will be first marked as not ready.
+  // Tasks will be queued for delay execution until the app is marked as ready.
   void AddApp(const std::string& app_id);
 
+  // Removes the app from the tracking list.
+  void RemoveApp(const std::string& app_id);
+
   // Adds a task that will be invoked once we're ready.
   void AddTask(const std::string& app_id, base::Closure task);
 
   // Marks that GCMClient is ready.
   void SetGCMClientReady();
 
   // Marks that the app is ready to have operations performed.
   void SetAppReady(const std::string& app_id);
 
   // Returns true if it is ready to perform operations for an app.
   bool CanRunTaskWithoutDelay(const std::string& app_id) const;
 
+  // Returns true if the app has been tracked for readiness.
+  bool IsAppTracked(const std::string& app_id) const;
+
  private:
   struct AppTaskQueue {
     AppTaskQueue();
     ~AppTaskQueue();
 
     // The flag that indicates if GCMProfileService completes loading the
     // persistent data for the app.
     bool ready;
 
     // Tasks to be invoked upon ready.
@@ skipping 27 matching lines @@
     delete iter->second;
   }
 }
 
 void GCMProfileService::DelayedTaskController::AddApp(
     const std::string& app_id) {
   DCHECK(delayed_task_map_.find(app_id) == delayed_task_map_.end());
   delayed_task_map_[app_id] = new AppTaskQueue;
 }
 
+void GCMProfileService::DelayedTaskController::RemoveApp(
+    const std::string& app_id) {
+  delayed_task_map_.erase(app_id);
+}
+
 void GCMProfileService::DelayedTaskController::AddTask(
     const std::string& app_id, base::Closure task) {
   DelayedTaskMap::const_iterator iter = delayed_task_map_.find(app_id);
   DCHECK(iter != delayed_task_map_.end());
   iter->second->tasks.push_back(task);
 }
 
 void GCMProfileService::DelayedTaskController::SetGCMClientReady() {
   gcm_client_ready_ = true;
 
@@ skipping 29 matching lines @@
 bool GCMProfileService::DelayedTaskController::CanRunTaskWithoutDelay(
     const std::string& app_id) const {
   if (!gcm_client_ready_)
     return false;
   DelayedTaskMap::const_iterator iter = delayed_task_map_.find(app_id);
   if (iter == delayed_task_map_.end())
     return true;
   return iter->second->ready;
 }
 
+bool GCMProfileService::DelayedTaskController::IsAppTracked(
+    const std::string& app_id) const {
+  return delayed_task_map_.find(app_id) != delayed_task_map_.end();
+}
+
 void GCMProfileService::DelayedTaskController::RunTasks(
     AppTaskQueue* task_queue) {
   DCHECK(gcm_client_ready_ && task_queue->ready);
 
   for (size_t i = 0; i < task_queue->tasks.size(); ++i)
     task_queue->tasks[i].Run();
   task_queue->tasks.clear();
 }
 
 class GCMProfileService::IOWorker
@@ skipping 246 matching lines @@
 GCMProfileService::RegistrationInfo::~RegistrationInfo() {
 }
 
 bool GCMProfileService::RegistrationInfo::IsValid() const {
   return !sender_ids.empty() && !registration_id.empty();
 }
 
 bool GCMProfileService::enable_gcm_for_testing_ = false;
 
 // static
-bool GCMProfileService::IsGCMEnabled() {
+bool GCMProfileService::IsGCMEnabled(Profile* profile) {
+  // GCM is not enabled in incognito mode.
+  if (profile->IsOffTheRecord())
+    return false;
+
   if (enable_gcm_for_testing_)
     return true;
 
   // GCM support is only enabled for Canary/Dev builds.
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   return channel == chrome::VersionInfo::CHANNEL_UNKNOWN ||
          channel == chrome::VersionInfo::CHANNEL_CANARY ||
          channel == chrome::VersionInfo::CHANNEL_DEV;
 }
 
 // static
 void GCMProfileService::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterUint64Pref(
       prefs::kGCMUserAccountID,
       0,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(
       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();
 }
@@ skipping 262 matching lines @@
   // 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);
 
   // 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(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GCMProfileService::IOWorker::Unregister,
                  io_worker_,
                  app_id));
 }
@@ skipping 142 matching lines @@
       new base::DictionaryValue());
   registration_info_dict->Set(kSendersKey, senders_list.release());
   registration_info_dict->SetString(kRegistrationIDKey,
                                     registration_info.registration_id);
 
   storage->SetExtensionValue(
       app_id, kRegistrationKey, registration_info_dict.PassAs<base::Value>());
 }
 
 void GCMProfileService::ReadRegistrationInfo(const std::string& app_id) {
+  // This function can be called more than once when the app is allowed in
+  // incognito and the extension service reloads the app.
+  if (delayed_task_controller_->IsAppTracked(app_id))
+    return;
+
+  delayed_task_controller_->AddApp(app_id);
+
   extensions::StateStore* storage =
       extensions::ExtensionSystem::Get(profile_)->state_store();
   DCHECK(storage);
-
-  delayed_task_controller_->AddApp(app_id);
-
   storage->GetExtensionValue(
       app_id,
       kRegistrationKey,
       base::Bind(
           &GCMProfileService::ReadRegistrationInfoFinished,
           weak_ptr_factory_.GetWeakPtr(),
           app_id));
 }
 
 void GCMProfileService::ReadRegistrationInfoFinished(
@@ skipping 34 matching lines @@
 
   return true;
 }
 
 // static
 const char* GCMProfileService::GetPersistentRegisterKeyForTesting() {
   return kRegistrationKey;
 }
 
 }  // namespace gcm