[Invalidations] Add GetInvalidatorState() to Invalidator{,Frontend}

chrome/browser/sync/glue/sync_backend_host.cc

 // Copyright (c) 2012 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 "build/build_config.h"
 
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/timer.h"
 #include "base/tracked_objects.h"
 #include "base/utf_string_conversions.h"
+#include "build/build_config.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/token_service.h"
 #include "chrome/browser/sync/glue/bridged_invalidator.h"
 #include "chrome/browser/sync/glue/change_processor.h"
 #include "chrome/browser/sync/glue/chrome_encryptor.h"
 #include "chrome/browser/sync/glue/chrome_sync_notification_bridge.h"
 #include "chrome/browser/sync/glue/sync_backend_registrar.h"
 #include "chrome/browser/sync/invalidations/invalidator_storage.h"
 #include "chrome/browser/sync/sync_prefs.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 79 matching lines @@
       syncer::BootstrapTokenType type) OVERRIDE;
   virtual void OnEncryptedTypesChanged(
       syncer::ModelTypeSet encrypted_types,
       bool encrypt_everything) OVERRIDE;
   virtual void OnEncryptionComplete() OVERRIDE;
   virtual void OnCryptographerStateChanged(
       syncer::Cryptographer* cryptographer) OVERRIDE;
   virtual void OnPassphraseStateChanged(syncer::PassphraseState state) OVERRIDE;
 
   // syncer::InvalidationHandler implementation.
-  virtual void OnNotificationsEnabled() OVERRIDE;
-  virtual void OnNotificationsDisabled(
-      syncer::NotificationsDisabledReason reason) OVERRIDE;
-  virtual void OnIncomingNotification(
+  virtual void OnInvalidatorStateChange(
+      syncer::InvalidatorState state) OVERRIDE;
+  virtual void OnIncomingInvalidation(
       const syncer::ObjectIdStateMap& id_state_map,
-      syncer::IncomingNotificationSource source) OVERRIDE;
+      syncer::IncomingInvalidationSource source) OVERRIDE;
 
   // Note:
   //
   // The Do* methods are the various entry points from our
   // SyncBackendHost.  They are all called on the sync thread to
   // actually perform synchronous (and potentially blocking) syncapi
   // operations.
   //
   // Called to perform initialization of the syncapi on behalf of
   // SyncBackendHost::Initialize.
@@ skipping 892 matching lines @@
     const syncer::SyncProtocolError& sync_error) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(
       FROM_HERE,
       &SyncBackendHost::HandleActionableErrorEventOnFrontendLoop,
       sync_error);
 }
 
-void SyncBackendHost::Core::OnNotificationsEnabled() {
+void SyncBackendHost::Core::OnInvalidatorStateChange(
+    syncer::InvalidatorState state) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(FROM_HERE,
-             &SyncBackendHost::HandleNotificationsEnabledOnFrontendLoop);
+             &SyncBackendHost::HandleInvalidatorStateChangeOnFrontendLoop,
+             state);
 }
 
-void SyncBackendHost::Core::OnNotificationsDisabled(
-    syncer::NotificationsDisabledReason reason) {
+void SyncBackendHost::Core::OnIncomingInvalidation(
+    const syncer::ObjectIdStateMap& id_state_map,
+    syncer::IncomingInvalidationSource source) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(FROM_HERE,
-             &SyncBackendHost::HandleNotificationsDisabledOnFrontendLoop,
-             reason);
-}
-
-void SyncBackendHost::Core::OnIncomingNotification(
-    const syncer::ObjectIdStateMap& id_state_map,
-    syncer::IncomingNotificationSource source) {
-  if (!sync_loop_)
-    return;
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  host_.Call(FROM_HERE,
-             &SyncBackendHost::HandleIncomingNotificationOnFrontendLoop,
+             &SyncBackendHost::HandleIncomingInvalidationOnFrontendLoop,
              id_state_map, source);
 }
 
 void SyncBackendHost::Core::DoInitialize(const DoInitializeOptions& options) {
   DCHECK(!sync_loop_);
   sync_loop_ = options.sync_loop;
   DCHECK(sync_loop_);
 
   // Blow away the partial or corrupt sync data folder before doing any more
   // initialization, if necessary.
   if (options.delete_sync_data_folder) {
     DeleteSyncDataFolder();
   }
 
   // Make sure that the directory exists before initializing the backend.
   // If it already exists, this will do no harm.
   if (!file_util::CreateDirectory(sync_data_folder_path_)) {
     DLOG(FATAL) << "Sync Data directory creation failed.";
   }
 
   DCHECK(!registrar_);
   registrar_ = options.registrar;
   DCHECK(registrar_);
 
   DCHECK(!chrome_sync_notification_bridge_);
   chrome_sync_notification_bridge_ = options.chrome_sync_notification_bridge;
   DCHECK(chrome_sync_notification_bridge_);
 
+#if defined(OS_ANDROID)
+  // Android uses ChromeSyncNotificationBridge exclusively.
+  const syncer::InvalidatorState kDefaultInvalidatorState =
+      syncer::INVALIDATIONS_ENABLED;
+#else
+  const syncer::InvalidatorState kDefaultInvalidatorState =
+      syncer::DEFAULT_INVALIDATION_ERROR;
+#endif
+
   sync_manager_ = options.sync_manager_factory->CreateSyncManager(name_);
   sync_manager_->AddObserver(this);
   sync_manager_->Init(
       sync_data_folder_path_,
       options.event_handler,
       options.service_url.host() + options.service_url.path(),
       options.service_url.EffectiveIntPort(),
       options.service_url.SchemeIsSecure(),
       BrowserThread::GetBlockingPool(),
       options.make_http_bridge_factory_fn.Run().Pass(),
       options.workers,
       options.extensions_activity_monitor,
       options.registrar /* as SyncManager::ChangeDelegate */,
       options.credentials,
       scoped_ptr<syncer::Invalidator>(new BridgedInvalidator(
           options.chrome_sync_notification_bridge,
-          options.invalidator_factory->CreateInvalidator())),
+          options.invalidator_factory->CreateInvalidator(),
+          kDefaultInvalidatorState)),
       options.restored_key_for_bootstrapping,
       options.restored_keystore_key_for_bootstrapping,
       scoped_ptr<InternalComponentsFactory>(
           options.internal_components_factory),
       &encryptor_,
       options.unrecoverable_error_handler,
       options.report_unrecoverable_error_function);
 
   // |sync_manager_| may end up being NULL here in tests (in
   // synchronous initialization mode).
@@ skipping 301 matching lines @@
 }
 
 void SyncBackendHost::HandleActionableErrorEventOnFrontendLoop(
     const syncer::SyncProtocolError& sync_error) {
   if (!frontend_)
     return;
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
   frontend_->OnActionableError(sync_error);
 }
 
-void SyncBackendHost::HandleNotificationsEnabledOnFrontendLoop() {
+void SyncBackendHost::HandleInvalidatorStateChangeOnFrontendLoop(
+    syncer::InvalidatorState state) {
   if (!frontend_)
     return;
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
-  frontend_->OnNotificationsEnabled();
+  frontend_->OnInvalidatorStateChange(state);
 }
 
-void SyncBackendHost::HandleNotificationsDisabledOnFrontendLoop(
-    syncer::NotificationsDisabledReason reason) {
+void SyncBackendHost::HandleIncomingInvalidationOnFrontendLoop(
+    const syncer::ObjectIdStateMap& id_state_map,
+    syncer::IncomingInvalidationSource source) {
   if (!frontend_)
     return;
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
-  frontend_->OnNotificationsDisabled(reason);
-}
-
-void SyncBackendHost::HandleIncomingNotificationOnFrontendLoop(
-    const syncer::ObjectIdStateMap& id_state_map,
-    syncer::IncomingNotificationSource source) {
-  if (!frontend_)
-    return;
-  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
-  frontend_->OnIncomingNotification(id_state_map, source);
+  frontend_->OnIncomingInvalidation(id_state_map, source);
 }
 
 bool SyncBackendHost::CheckPassphraseAgainstCachedPendingKeys(
     const std::string& passphrase) const {
   DCHECK(cached_pending_keys_.has_blob());
   DCHECK(!passphrase.empty());
   syncer::Nigori nigori;
   nigori.InitByDerivation("localhost", "dummy", passphrase);
   std::string plaintext;
   bool result = nigori.Decrypt(cached_pending_keys_.blob(), &plaintext);
@@ skipping 82 matching lines @@
     const syncer::ModelTypeSet failed_configuration_types) {
   HandleInitializationCompletedOnFrontendLoop(
       failed_configuration_types.Empty());
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync