Add GCMChannelStatusSyncer to schedule requests and enable/disable GCM

BUG=384041
TEST=new tests added

Review URL: https://codereview.chromium.org/561943002

Cr-Commit-Position: refs/heads/master@{#295524}

chrome/browser/browser_process_impl.cc

@@ -1135,6 +1135,7 @@ void BrowserProcessImpl::CreateGCMDriver() {
   CHECK(PathService::Get(chrome::DIR_GLOBAL_GCM_STORE, &store_path));
   gcm_driver_ = gcm::CreateGCMDriverDesktop(
       make_scoped_ptr(new gcm::GCMClientFactory),
+      local_state(),
       store_path,
       system_request_context());
   // Sign-in is not required for device-level GCM usage. So we just call

chrome/browser/prefs/browser_prefs.cc

@@ -82,6 +82,7 @@
 #include "components/autofill/core/browser/autofill_manager.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/dom_distiller/core/distilled_page_prefs.h"
+#include "components/gcm_driver/gcm_channel_status_syncer.h"
 #include "components/google/core/browser/google_pref_names.h"
 #include "components/google/core/browser/google_url_tracker.h"
 #include "components/network_time/network_time_tracker.h"
@@ -293,6 +294,8 @@ void RegisterLocalState(PrefRegistrySimple* registry) {
   AutomaticProfileResetterFactory::RegisterPrefs(registry);
   BackgroundModeManager::RegisterPrefs(registry);
   RegisterBrowserPrefs(registry);
+  // The native GCM is used on Android instead.
+  gcm::GCMChannelStatusSyncer::RegisterPrefs(registry);
 #if !defined(OS_CHROMEOS)
   RegisterDefaultBrowserPromptPrefs(registry);
 #endif  // !defined(OS_CHROMEOS)
@@ -443,6 +446,7 @@ void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   extensions::ExtensionSettingsHandler::RegisterProfilePrefs(registry);
   extensions::TabsCaptureVisibleTabFunction::RegisterProfilePrefs(registry);
   first_run::RegisterProfilePrefs(registry);
+  gcm::GCMChannelStatusSyncer::RegisterProfilePrefs(registry);
   NewTabUI::RegisterProfilePrefs(registry);
   PepperFlashSettingsManager::RegisterProfilePrefs(registry);
   PinnedTabCodec::RegisterProfilePrefs(registry);

chrome/browser/services/gcm/gcm_desktop_utils.cc

@@ -73,6 +73,7 @@ GCMClient::ChromeBuildInfo GetChromeBuildInfo() {
 
 scoped_ptr<GCMDriver> CreateGCMDriverDesktop(
     scoped_ptr<GCMClientFactory> gcm_client_factory,
+    PrefService* prefs,
     const base::FilePath& store_path,
     const scoped_refptr<net::URLRequestContextGetter>& request_context) {
   scoped_refptr<base::SequencedWorkerPool> worker_pool(
@@ -84,6 +85,7 @@ scoped_ptr<GCMDriver> CreateGCMDriverDesktop(
   return scoped_ptr<GCMDriver>(new GCMDriverDesktop(
       gcm_client_factory.Pass(),
       GetChromeBuildInfo(),
+      prefs,
       store_path,
       request_context,
       content::BrowserThread::GetMessageLoopProxyForThread(

chrome/browser/services/gcm/gcm_desktop_utils.h

@@ -8,6 +8,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 
+class PrefService;
 namespace base {
 class FilePath;
 }
@@ -23,6 +24,7 @@ class GCMClientFactory;
 
 scoped_ptr<GCMDriver> CreateGCMDriverDesktop(
     scoped_ptr<GCMClientFactory> gcm_client_factory,
+    PrefService* prefs,
     const base::FilePath& store_path,
     const scoped_refptr<net::URLRequestContextGetter>& request_context);
 

chrome/browser/services/gcm/gcm_profile_service.cc

@@ -169,6 +169,7 @@ GCMProfileService::GCMProfileService(
 
   driver_ = CreateGCMDriverDesktop(
       gcm_client_factory.Pass(),
+      profile_->GetPrefs(),
       profile_->GetPath().Append(chrome::kGCMStoreDirname),
       profile_->GetRequestContext());
 

components/gcm_driver.gypi

@@ -33,6 +33,8 @@
         'gcm_driver/gcm_backoff_policy.h',
         'gcm_driver/gcm_channel_status_request.cc',
         'gcm_driver/gcm_channel_status_request.h',
+        'gcm_driver/gcm_channel_status_syncer.cc',
+        'gcm_driver/gcm_channel_status_syncer.h',
         'gcm_driver/gcm_client.cc',
         'gcm_driver/gcm_client.h',
         'gcm_driver/gcm_client_factory.cc',
@@ -73,6 +75,8 @@
             'gcm_driver/gcm_account_mapper.h',
             'gcm_driver/gcm_channel_status_request.cc',
             'gcm_driver/gcm_channel_status_request.h',
+            'gcm_driver/gcm_channel_status_syncer.cc',
+            'gcm_driver/gcm_channel_status_syncer.h',
             'gcm_driver/gcm_client_factory.cc',
             'gcm_driver/gcm_client_factory.h',
             'gcm_driver/gcm_client_impl.cc',

components/gcm_driver/BUILD.gn

@@ -17,6 +17,8 @@ static_library("gcm_driver") {
     "gcm_backoff_policy.h",
     "gcm_channel_status_request.cc",
     "gcm_channel_status_request.h",
+    "gcm_channel_status_syncer.cc",
+    "gcm_channel_status_syncer.h",
     "gcm_client.cc",
     "gcm_client.h",
     "gcm_client_factory.cc",
@@ -51,6 +53,8 @@ static_library("gcm_driver") {
     sources -= [
       "gcm_channel_status_request.cc",
       "gcm_channel_status_request.h",
+      "gcm_channel_status_syncer.cc",
+      "gcm_channel_status_syncer.h",
       "gcm_client_factory.cc",
       "gcm_client_factory.h",
       "gcm_client_impl.cc",

components/gcm_driver/DEPS

 include_rules = [
   "+components/os_crypt",
+  "+components/pref_registry",
   # TODO(johnme): Fix this layering violation.
   "!content/public/android/java",
   "+google_apis/gaia",

components/gcm_driver/gcm_channel_status_request.cc

@@ -41,12 +41,12 @@ GCMChannelStatusRequest::~GCMChannelStatusRequest() {
 }
 
 // static
-int GCMChannelStatusRequest::default_poll_interval_seconds_for_testing() {
+int GCMChannelStatusRequest::default_poll_interval_seconds() {
   return kDefaultPollIntervalSeconds;
 }
 
 // static
-int GCMChannelStatusRequest::min_poll_interval_seconds_for_testing() {
+int GCMChannelStatusRequest::min_poll_interval_seconds() {
   return kMinPollIntervalSeconds;
 }
 

components/gcm_driver/gcm_channel_status_request.h

@@ -36,9 +36,8 @@ class GCMChannelStatusRequest : public net::URLFetcherDelegate {
 
   void Start();
 
-  // Exposed for testing purpose.
-  static int default_poll_interval_seconds_for_testing();
-  static int min_poll_interval_seconds_for_testing();
+  static int default_poll_interval_seconds();
+  static int min_poll_interval_seconds();
 
  private:
   // Overridden from URLFetcherDelegate:

components/gcm_driver/gcm_channel_status_request_unittest.cc

@@ -136,7 +136,7 @@ TEST_F(GCMChannelStatusRequestTest, ResponseWithDisabledStatus) {
   EXPECT_TRUE(request_callback_invoked_);
   EXPECT_FALSE(enabled_);
   EXPECT_EQ(
-      GCMChannelStatusRequest::default_poll_interval_seconds_for_testing(),
+      GCMChannelStatusRequest::default_poll_interval_seconds(),
       poll_interval_seconds_);
 }
 
@@ -148,7 +148,7 @@ TEST_F(GCMChannelStatusRequestTest, ResponseWithEnabledStatus) {
   EXPECT_TRUE(request_callback_invoked_);
   EXPECT_TRUE(enabled_);
   EXPECT_EQ(
-      GCMChannelStatusRequest::default_poll_interval_seconds_for_testing(),
+      GCMChannelStatusRequest::default_poll_interval_seconds(),
       poll_interval_seconds_);
 }
 
@@ -156,8 +156,7 @@ TEST_F(GCMChannelStatusRequestTest, ResponseWithPollInterval) {
   // Setting a poll interval 15 minutes longer than the minimum interval we
   // enforce.
   int poll_interval_seconds =
-      GCMChannelStatusRequest::min_poll_interval_seconds_for_testing() +
-      15 * 60;
+      GCMChannelStatusRequest::min_poll_interval_seconds() + 15 * 60;
   StartRequest();
   SetResponseProtoData(NOT_SPECIFIED, poll_interval_seconds);
   CompleteFetch();
@@ -171,22 +170,20 @@ TEST_F(GCMChannelStatusRequestTest, ResponseWithShortPollInterval) {
   // Setting a poll interval 15 minutes shorter than the minimum interval we
   // enforce.
   int poll_interval_seconds =
-      GCMChannelStatusRequest::min_poll_interval_seconds_for_testing() -
-      15 * 60;
+      GCMChannelStatusRequest::min_poll_interval_seconds() - 15 * 60;
   StartRequest();
   SetResponseProtoData(NOT_SPECIFIED, poll_interval_seconds);
   CompleteFetch();
 
   EXPECT_TRUE(request_callback_invoked_);
   EXPECT_TRUE(enabled_);
-  EXPECT_EQ(GCMChannelStatusRequest::min_poll_interval_seconds_for_testing(),
+  EXPECT_EQ(GCMChannelStatusRequest::min_poll_interval_seconds(),
             poll_interval_seconds_);
 }
 
 TEST_F(GCMChannelStatusRequestTest, ResponseWithDisabledStatusAndPollInterval) {
   int poll_interval_seconds =
-      GCMChannelStatusRequest::min_poll_interval_seconds_for_testing() +
-      15 * 60;
+      GCMChannelStatusRequest::min_poll_interval_seconds() + 15 * 60;
   StartRequest();
   SetResponseProtoData(GCM_DISABLED, poll_interval_seconds);
   CompleteFetch();

components/gcm_driver/gcm_channel_status_syncer.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 "components/gcm_driver/gcm_channel_status_syncer.h"
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "base/message_loop/message_loop.h"
+#include "base/prefs/pref_registry_simple.h"
+#include "base/prefs/pref_service.h"
+#include "base/rand_util.h"
+#include "components/gcm_driver/gcm_channel_status_request.h"
+#include "components/gcm_driver/gcm_driver.h"
+#include "components/pref_registry/pref_registry_syncable.h"
+
+namespace gcm {
+
+namespace {
+
+// The GCM channel's enabled state.
+const char kGCMChannelStatus[] = "gcm.channel_status";
+
+// The GCM channel's polling interval (in seconds).
+const char kGCMChannelPollIntervalSeconds[] = "gcm.poll_interval";
+
+// Last time when checking with the GCM channel status server is done.
+const char kGCMChannelLastCheckTime[] = "gcm.check_time";
+
+// A small delay to avoid sending request at browser startup time for first-time
+// request.
+const int kFirstTimeDelaySeconds = 1 * 60;  // 1 minute.
+
+// The fuzzing variation added to the polling delay.
+const int kGCMChannelRequestTimeJitterSeconds = 15 * 60;  // 15 minues.
+
+}  // namespace
+
+// static
+void GCMChannelStatusSyncer::RegisterPrefs(PrefRegistrySimple* registry) {
+  registry->RegisterBooleanPref(kGCMChannelStatus, true);
+  registry->RegisterIntegerPref(
+      kGCMChannelPollIntervalSeconds,
+      GCMChannelStatusRequest::default_poll_interval_seconds());
+  registry->RegisterInt64Pref(kGCMChannelLastCheckTime, 0);
+}
+
+// static
+void GCMChannelStatusSyncer::RegisterProfilePrefs(
+    user_prefs::PrefRegistrySyncable* registry) {
+  registry->RegisterBooleanPref(
+      kGCMChannelStatus,
+      true,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      kGCMChannelPollIntervalSeconds,
+      GCMChannelStatusRequest::default_poll_interval_seconds(),
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterInt64Pref(
+      kGCMChannelLastCheckTime,
+      0,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+}
+
+// static
+int GCMChannelStatusSyncer::first_time_delay_seconds() {
+  return kFirstTimeDelaySeconds;
+}
+
+GCMChannelStatusSyncer::GCMChannelStatusSyncer(
+    GCMDriver* driver,
+    PrefService* prefs,
+    const scoped_refptr<net::URLRequestContextGetter>& request_context)
+    : driver_(driver),
+      prefs_(prefs),
+      request_context_(request_context),
+      gcm_enabled_(true),
+      poll_interval_seconds_(
+          GCMChannelStatusRequest::default_poll_interval_seconds()),
+      delay_removed_for_testing_(false),
+      weak_ptr_factory_(this) {
+  gcm_enabled_ = prefs_->GetBoolean(kGCMChannelStatus);
+  poll_interval_seconds_ = prefs_->GetInteger(kGCMChannelPollIntervalSeconds);
+  if (poll_interval_seconds_ <
+      GCMChannelStatusRequest::min_poll_interval_seconds()) {
+    poll_interval_seconds_ =
+        GCMChannelStatusRequest::min_poll_interval_seconds();
+  }
+  last_check_time_ = base::Time::FromInternalValue(
+      prefs_->GetInt64(kGCMChannelLastCheckTime));
+}
+
+GCMChannelStatusSyncer::~GCMChannelStatusSyncer() {
+}
+
+void GCMChannelStatusSyncer::EnsureStarted() {
+  // Bail out if the request is already scheduled or started.
+  if (weak_ptr_factory_.HasWeakPtrs() || request_)
+    return;
+
+  ScheduleRequest();
+}
+
+void GCMChannelStatusSyncer::Stop() {
+  request_.reset();
+  weak_ptr_factory_.InvalidateWeakPtrs();
+}
+
+void GCMChannelStatusSyncer::OnRequestCompleted(bool enabled,
+                                                int poll_interval_seconds) {
+  DCHECK(request_);
+  request_.reset();
+
+  // Persist the current time as the last request complete time.
+  last_check_time_ = base::Time::Now();
+  prefs_->SetInt64(kGCMChannelLastCheckTime,
+                   last_check_time_.ToInternalValue());
+
+  if (gcm_enabled_ != enabled) {
+    gcm_enabled_ = enabled;
+    prefs_->SetBoolean(kGCMChannelStatus, enabled);
+    if (gcm_enabled_)
+      driver_->Enable();
+    else
+      driver_->Disable();
+  }
+
+  DCHECK_GE(poll_interval_seconds,
+            GCMChannelStatusRequest::min_poll_interval_seconds());
+  if (poll_interval_seconds_ != poll_interval_seconds) {
+    poll_interval_seconds_ = poll_interval_seconds;
+    prefs_->SetInteger(kGCMChannelPollIntervalSeconds, poll_interval_seconds_);
+  }
+
+  ScheduleRequest();
+}
+
+void GCMChannelStatusSyncer::ScheduleRequest() {
+  current_request_delay_interval_ = GetRequestDelayInterval();
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&GCMChannelStatusSyncer::StartRequest,
+                 weak_ptr_factory_.GetWeakPtr()),
+      current_request_delay_interval_);
+}
+
+void GCMChannelStatusSyncer::StartRequest() {
+  DCHECK(!request_);
+
+  request_.reset(new GCMChannelStatusRequest(
+      request_context_,
+      base::Bind(&GCMChannelStatusSyncer::OnRequestCompleted,
+                 weak_ptr_factory_.GetWeakPtr())));
+  request_->Start();
+}
+
+base::TimeDelta GCMChannelStatusSyncer::GetRequestDelayInterval() const {
+  // No delay during testing.
+  if (delay_removed_for_testing_)
+    return base::TimeDelta();
+
+  // Make sure that checking with server occurs at polling interval, regardless
+  // whether the browser restarts.
+  int64 delay_seconds = poll_interval_seconds_ -
+      (base::Time::Now() - last_check_time_).InSeconds();
+  if (delay_seconds < 0)
+    delay_seconds = 0;
+
+  if (last_check_time_.is_null()) {
+    // For the first-time request, add a small delay to avoid sending request at
+    // browser startup time.
+    DCHECK(!delay_seconds);
+    delay_seconds = kFirstTimeDelaySeconds;
+  } else {
+    // Otherwise, add a fuzzing variation to the delay.
+    delay_seconds += base::RandInt(0, kGCMChannelRequestTimeJitterSeconds);
+  }
+
+  return base::TimeDelta::FromSeconds(delay_seconds);
+}
+
+}  // namespace gcm

components/gcm_driver/gcm_channel_status_syncer.h

+// 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.
+
+#ifndef COMPONENTS_GCM_DRIVER_GCM_CHANNEL_STATUS_SYNCER_H_
+#define COMPONENTS_GCM_DRIVER_GCM_CHANNEL_STATUS_SYNCER_H_
+
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/time/time.h"
+
+class PrefService;
+class PrefRegistrySimple;
+
+namespace net {
+class URLRequestContextGetter;
+}
+
+namespace user_prefs {
+class PrefRegistrySyncable;
+}
+
+namespace gcm {
+
+class GCMChannelStatusRequest;
+class GCMDriver;
+
+// Syncing with the server for GCM channel status that controls if GCM
+// functionality should be enabled or disabled.
+class GCMChannelStatusSyncer {
+ public:
+  static void RegisterPrefs(PrefRegistrySimple* registry);
+  static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
+
+  GCMChannelStatusSyncer(
+      GCMDriver* driver,
+      PrefService* prefs,
+      const scoped_refptr<net::URLRequestContextGetter>& request_context);
+  ~GCMChannelStatusSyncer();
+
+  void EnsureStarted();
+  void Stop();
+
+  bool gcm_enabled() const { return gcm_enabled_; }
+
+  // For testing purpose.
+  void set_delay_removed_for_testing(bool delay_removed) {
+    delay_removed_for_testing_ = delay_removed;
+  }
+  base::TimeDelta current_request_delay_interval() const {
+    return current_request_delay_interval_;
+  }
+  static int first_time_delay_seconds();
+
+ private:
+  // Called when a request is completed.
+  void OnRequestCompleted(bool enabled, int poll_interval_seconds);
+
+  // Schedules next request to start after appropriate delay.
+  void ScheduleRequest();
+
+  // Creates and starts a request immediately.
+  void StartRequest();
+
+  // Computes and returns a delay with the fuzzing variation added if needed,
+  // after which the request could start.
+  base::TimeDelta GetRequestDelayInterval() const;
+
+  // GCMDriver owns GCMChannelStatusSyncer instance.
+  GCMDriver* driver_;
+  PrefService* prefs_;
+
+  scoped_refptr<net::URLRequestContextGetter> request_context_;
+  scoped_ptr<GCMChannelStatusRequest> request_;
+
+  bool gcm_enabled_;
+  int poll_interval_seconds_;
+  base::Time last_check_time_;
+
+  // The flag that indicates if the delay, including fuzzing variation and poll
+  // interval, is removed for testing purpose.
+  bool delay_removed_for_testing_;
+
+  // Tracked for testing purpose.
+  base::TimeDelta current_request_delay_interval_;
+
+  // Used to pass a weak pointer to a task.
+  base::WeakPtrFactory<GCMChannelStatusSyncer> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(GCMChannelStatusSyncer);
+};
+
+}  // namespace gcm
+
+#endif  // COMPONENTS_GCM_DRIVER_GCM_CHANNEL_STATUS_SYNCER_H_

components/gcm_driver/gcm_driver_desktop.cc

@@ -14,6 +14,7 @@
 #include "base/sequenced_task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/gcm_driver/gcm_app_handler.h"
+#include "components/gcm_driver/gcm_channel_status_syncer.h"
 #include "components/gcm_driver/gcm_client_factory.h"
 #include "components/gcm_driver/gcm_delayed_task_controller.h"
 #include "components/gcm_driver/system_encryptor.h"
@@ -329,18 +330,22 @@ void GCMDriverDesktop::IOWorker::RemoveAccountMapping(
 GCMDriverDesktop::GCMDriverDesktop(
     scoped_ptr<GCMClientFactory> gcm_client_factory,
     const GCMClient::ChromeBuildInfo& chrome_build_info,
+    PrefService* prefs,
     const base::FilePath& store_path,
     const scoped_refptr<net::URLRequestContextGetter>& request_context,
     const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
     const scoped_refptr<base::SequencedTaskRunner>& io_thread,
     const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner)
-    : signed_in_(false),
+    : gcm_channel_status_syncer_(this, prefs, request_context),
+      signed_in_(false),
       gcm_started_(false),
       gcm_enabled_(true),
       connected_(false),
       ui_thread_(ui_thread),
       io_thread_(io_thread),
       weak_ptr_factory_(this) {
+  gcm_enabled_ = gcm_channel_status_syncer_.gcm_enabled();
+
   // Create and initialize the GCMClient. Note that this does not initiate the
   // GCM check-in.
   io_worker_.reset(new IOWorker(ui_thread, io_thread));
@@ -442,6 +447,8 @@ void GCMDriverDesktop::Stop() {
   if (!gcm_started_)
     return;
 
+  gcm_channel_status_syncer_.Stop();
+
   RemoveCachedData();
 
   io_thread_->PostTask(
@@ -627,6 +634,11 @@ GCMClient::Result GCMDriverDesktop::EnsureStarted() {
   DCHECK(!delayed_task_controller_);
   delayed_task_controller_.reset(new GCMDelayedTaskController);
 
+  // Polling for channel status is only needed when GCM is supported for all
+  // users.
+  if (GCMDriver::IsAllowedForAllUsers())
+    gcm_channel_status_syncer_.EnsureStarted();
+
   // Note that we need to pass weak pointer again since the existing weak
   // pointer in IOWorker might have been invalidated when check-out occurs.
   io_thread_->PostTask(

components/gcm_driver/gcm_driver_desktop.h

@@ -15,10 +15,13 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
+#include "components/gcm_driver/gcm_channel_status_syncer.h"
 #include "components/gcm_driver/gcm_client.h"
 #include "components/gcm_driver/gcm_connection_observer.h"
 #include "components/gcm_driver/gcm_driver.h"
 
+class PrefService;
+
 namespace base {
 class FilePath;
 class SequencedTaskRunner;
@@ -44,6 +47,7 @@ class GCMDriverDesktop : public GCMDriver {
   GCMDriverDesktop(
       scoped_ptr<GCMClientFactory> gcm_client_factory,
       const GCMClient::ChromeBuildInfo& chrome_build_info,
+      PrefService* prefs,
       const base::FilePath& store_path,
       const scoped_refptr<net::URLRequestContextGetter>& request_context,
       const scoped_refptr<base::SequencedTaskRunner>& ui_thread,
@@ -84,6 +88,12 @@ class GCMDriverDesktop : public GCMDriver {
   void SetAccountsForCheckin(
       const std::map<std::string, std::string>& account_tokens);
 
+  // Exposed for testing purpose.
+  bool gcm_enabled() const { return gcm_enabled_; }
+  GCMChannelStatusSyncer* gcm_channel_status_syncer_for_testing() {
+    return &gcm_channel_status_syncer_;
+  }
+
  protected:
   // GCMDriver implementation:
   virtual GCMClient::Result EnsureStarted() OVERRIDE;
@@ -125,6 +135,8 @@ class GCMDriverDesktop : public GCMDriver {
 
   void GetGCMStatisticsFinished(const GCMClient::GCMStatistics& stats);
 
+  GCMChannelStatusSyncer gcm_channel_status_syncer_;
+
   // Flag to indicate whether the user is signed in to a GAIA account.
   // TODO(jianli): To be removed when sign-in enforcement is dropped.
   bool signed_in_;
@@ -133,6 +145,7 @@ class GCMDriverDesktop : public GCMDriver {
   bool gcm_started_;
 
   // Flag to indicate if GCM is enabled.
+  // TODO(jianli): Removed when we switch completely to support all users.
   bool gcm_enabled_;
 
   // Flag to indicate the last known state of the GCM client. Because this