Separate local and remote sync invalidations

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/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/signin/token_service_factory.h"
-#include "chrome/browser/sync/glue/bridged_invalidator.h"
+#include "chrome/browser/sync/glue/android_invalidator_bridge.h"
+#include "chrome/browser/sync/glue/android_invalidator_bridge_proxy.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/device_info.h"
 #include "chrome/browser/sync/glue/sync_backend_registrar.h"
 #include "chrome/browser/sync/glue/synced_device_tracker.h"
 #include "chrome/browser/sync/invalidations/invalidator_storage.h"
 #include "chrome/browser/sync/sync_prefs.h"
 #include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_source.h"
 #include "content/public/common/content_client.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "jingle/notifier/base/notification_method.h"
 #include "jingle/notifier/base/notifier_options.h"
 #include "net/base/host_port_pair.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "sync/internal_api/public/base_transaction.h"
 #include "sync/internal_api/public/engine/model_safe_worker.h"
 #include "sync/internal_api/public/http_bridge.h"
 #include "sync/internal_api/public/internal_components_factory_impl.h"
@@ skipping 113 matching lines @@
 
   // Called to turn on encryption of all sync data as well as
   // reencrypt everything.
   void DoEnableEncryptEverything();
 
   // Called at startup to download the control types. Will invoke
   // DoInitialProcessControlTypes on success, and OnControlTypesDownloadRetry
   // if an error occurred.
   void DoDownloadControlTypes();
 
+  // Ask the syncer check for updates for the specified types.

[Nicolas Zea, 2013/01/28 23:48:43]

"syncer to check for server updates"

[rlarocque, 2013/01/29 18:48:58]

Done.

+  void DoRefreshTypes(syncer::ModelTypeSet types);
+
   // Invoked if we failed to download the necessary control types at startup.
   // Invokes SyncBackendHost::HandleControlTypesDownloadRetry.
   void OnControlTypesDownloadRetry();
 
   // Called to perform tasks which require the control data to be downloaded.
   // This includes refreshing encryption, setting up the device info change
   // processor, etc.
   void DoInitialProcessControlTypes();
 
   // Some parts of DoInitialProcessControlTypes() may be executed on a different
@@ skipping 73 matching lines @@
   syncer::WeakHandle<SyncBackendHost> host_;
 
   // The loop where all the sync backend operations happen.
   // Non-NULL only between calls to DoInitialize() and DoShutdown().
   MessageLoop* sync_loop_;
 
   // Our parent's registrar (not owned).  Non-NULL only between
   // calls to DoInitialize() and DoShutdown().
   SyncBackendRegistrar* registrar_;
 
-  // Our parent's notification bridge (not owned).  Non-NULL only
-  // between calls to DoInitialize() and DoShutdown().
-  ChromeSyncNotificationBridge* chrome_sync_notification_bridge_;
-
   // The timer used to periodically call SaveChanges.
   scoped_ptr<base::RepeatingTimer<Core> > save_changes_timer_;
 
   // Our encryptor, which uses Chrome's encryption functions.
   ChromeEncryptor encryptor_;
 
   // A special ChangeProcessor that tracks the DEVICE_INFO type for us.
   scoped_ptr<SyncedDeviceTracker> synced_device_tracker_;
 
   // The top-level syncapi entry point.  Lives on the sync thread.
@@ skipping 89 matching lines @@
           ParseNotifierOptions(*CommandLine::ForCurrentProcess(),
                                profile_->GetRequestContext()),
           content::GetUserAgent(GURL()),
           base::WeakPtr<syncer::InvalidationStateTracker>()),
       frontend_(NULL),
       cached_passphrase_type_(syncer::IMPLICIT_PASSPHRASE) {
 }
 
 SyncBackendHost::~SyncBackendHost() {
   DCHECK(!core_ && !frontend_) << "Must call Shutdown before destructor.";
-  DCHECK(!chrome_sync_notification_bridge_.get());
+  DCHECK(!android_invalidator_bridge_.get());
   DCHECK(!registrar_.get());
 }
 
 namespace {
 
 scoped_ptr<syncer::HttpPostProviderFactory> MakeHttpBridgeFactory(
     const scoped_refptr<net::URLRequestContextGetter>& getter) {
   chrome::VersionInfo version_info;
   return scoped_ptr<syncer::HttpPostProviderFactory>(
       new syncer::HttpBridgeFactory(
           getter, DeviceInfo::MakeUserAgentForSyncApi(version_info)));
 }
 
 }  // namespace
 
 void SyncBackendHost::Initialize(
     SyncFrontend* frontend,
     const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
     const GURL& sync_service_url,
     const SyncCredentials& credentials,
     bool delete_sync_data_folder,
     syncer::SyncManagerFactory* sync_manager_factory,
     syncer::UnrecoverableErrorHandler* unrecoverable_error_handler,
     syncer::ReportUnrecoverableErrorFunction
         report_unrecoverable_error_function) {
   if (!sync_thread_.Start())
     return;
 
-  chrome_sync_notification_bridge_.reset(
-      new ChromeSyncNotificationBridge(
+  android_invalidator_bridge_.reset(
+      new AndroidInvalidatorBridge(
           profile_, sync_thread_.message_loop_proxy()));
 
   frontend_ = frontend;
   DCHECK(frontend);
 
   registrar_.reset(new SyncBackendRegistrar(name_,
                                             profile_,
                                             sync_thread_.message_loop()));
   syncer::ModelSafeRoutingInfo routing_info;
   std::vector<syncer::ModelSafeWorker*> workers;
@@ skipping 20 matching lines @@
       sync_thread_.message_loop(),
       registrar_.get(),
       routing_info,
       workers,
       &extensions_activity_monitor_,
       event_handler,
       sync_service_url,
       base::Bind(&MakeHttpBridgeFactory,
                  make_scoped_refptr(profile_->GetRequestContext())),
       credentials,
-      chrome_sync_notification_bridge_.get(),
+      android_invalidator_bridge_.get(),
       &invalidator_factory_,
       sync_manager_factory,
       delete_sync_data_folder,
       sync_prefs_->GetEncryptionBootstrapToken(),
       sync_prefs_->GetKeystoreEncryptionBootstrapToken(),
       new InternalComponentsFactoryImpl(factory_switches),
       unrecoverable_error_handler,
       report_unrecoverable_error_function));
 }
 
@@ skipping 108 matching lines @@
     core_->DoStopSyncManagerForShutdown(closure);
   }
 }
 
 void SyncBackendHost::StopSyncingForShutdown() {
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
 
   // Immediately stop sending messages to the frontend.
   frontend_ = NULL;
 
+  // Stop listening for and forwarding locally-triggered sync refresh requests.
+  notification_registrar_.RemoveAll();
+
   // Thread shutdown should occur in the following order:
   // - Sync Thread
   // - UI Thread (stops some time after we return from this call).
   //
   // In order to achieve this, we first shutdown components from the UI thread
   // and send signals to abort components that may be busy on the sync thread.
   // The callback (OnSyncerShutdownComplete) will happen on the sync thread,
   // after which we'll shutdown components on the sync thread, and then be
   // able to stop the sync loop.
   if (sync_thread_.IsRunning()) {
@@ skipping 24 matching lines @@
 void SyncBackendHost::Shutdown(bool sync_disabled) {
   // StopSyncingForShutdown() (which nulls out |frontend_|) should be
   // called first.
   DCHECK(!frontend_);
   // TODO(tim): DCHECK(registrar_->StoppedOnUIThread()) would be nice.
   if (sync_thread_.IsRunning()) {
     sync_thread_.message_loop()->PostTask(FROM_HERE,
         base::Bind(&SyncBackendHost::Core::DoShutdown, core_.get(),
                    sync_disabled));
 
-    if (chrome_sync_notification_bridge_.get())
-      chrome_sync_notification_bridge_->StopForShutdown();
+    if (android_invalidator_bridge_.get())
+      android_invalidator_bridge_->StopForShutdown();
   }
 
   // Stop will return once the thread exits, which will be after DoShutdown
   // runs. DoShutdown needs to run from sync_thread_ because the sync backend
   // requires any thread that opened sqlite handles to relinquish them
   // personally. We need to join threads, because otherwise the main Chrome
   // thread (ui loop) can exit before DoShutdown finishes, at which point
   // virtually anything the sync backend does (or the post-back to
   // frontend_loop_ by our Core) will epically fail because the CRT won't be
   // initialized.
   // Since we are blocking the UI thread here, we need to turn ourselves in
   // with the ThreadRestriction police.  For sentencing and how we plan to fix
   // this, see bug 19757.
   base::Time stop_thread_start_time = base::Time::Now();
   {
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     sync_thread_.Stop();
   }
   base::TimeDelta stop_sync_thread_time = base::Time::Now() -
       stop_thread_start_time;
   UMA_HISTOGRAM_TIMES("Sync.Shutdown.StopSyncThreadTime",
                       stop_sync_thread_time);
 
   registrar_.reset();
   js_backend_.Reset();
-  chrome_sync_notification_bridge_.reset();
+  android_invalidator_bridge_.reset();
   core_ = NULL;  // Releases reference to core_.
 }
 
 void SyncBackendHost::ConfigureDataTypes(
     syncer::ConfigureReason reason,
     syncer::ModelTypeSet types_to_add,
     syncer::ModelTypeSet types_to_remove,
     const base::Callback<void(syncer::ModelTypeSet)>& ready_task,
     const base::Callback<void()>& retry_callback) {
   // Only one configure is allowed at a time.  This is guaranteed by our
@@ skipping 170 matching lines @@
 
   initialization_state_ = INITIALIZATING_CONTROL_TYPES;
 
   js_backend_ = js_backend;
   debug_info_listener_ = debug_info_listener;
 
   // Inform the registrar of those types that have been fully downloaded and
   // applied.
   registrar_->SetInitialTypes(restored_types);
 
+  // Start forwarding refresh requests to the SyncManager
+  notification_registrar_.Add(this, chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
+                              content::Source<Profile>(profile_));
+
   // Kick off the next step in SyncBackendHost initialization by downloading
   // any necessary control types.
   sync_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoDownloadControlTypes,
                  core_.get()));
 }
 
+void SyncBackendHost::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_EQ(type, chrome::NOTIFICATION_SYNC_REFRESH_LOCAL);
+
+  content::Details<const syncer::ModelTypeInvalidationMap>
+      state_details(details);
+  const syncer::ModelTypeInvalidationMap& invalidation_map =
+      *(state_details.ptr());
+  const syncer::ModelTypeSet types =
+      ModelTypeInvalidationMapToSet(invalidation_map);
+  sync_thread_.message_loop()->PostTask(FROM_HERE,
+      base::Bind(&SyncBackendHost::Core::DoRefreshTypes, core_.get(), types));
+}
+
 SyncBackendHost::DoInitializeOptions::DoInitializeOptions(
     MessageLoop* sync_loop,
     SyncBackendRegistrar* registrar,
     const syncer::ModelSafeRoutingInfo& routing_info,
     const std::vector<syncer::ModelSafeWorker*>& workers,
     syncer::ExtensionsActivityMonitor* extensions_activity_monitor,
     const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
     const GURL& service_url,
     MakeHttpBridgeFactoryFn make_http_bridge_factory_fn,
     const syncer::SyncCredentials& credentials,
-    ChromeSyncNotificationBridge* chrome_sync_notification_bridge,
+    AndroidInvalidatorBridge* android_invalidator_bridge,
     syncer::InvalidatorFactory* invalidator_factory,
     syncer::SyncManagerFactory* sync_manager_factory,
     bool delete_sync_data_folder,
     const std::string& restored_key_for_bootstrapping,
     const std::string& restored_keystore_key_for_bootstrapping,
     InternalComponentsFactory* internal_components_factory,
     syncer::UnrecoverableErrorHandler* unrecoverable_error_handler,
     syncer::ReportUnrecoverableErrorFunction
         report_unrecoverable_error_function)
     : sync_loop(sync_loop),
       registrar(registrar),
       routing_info(routing_info),
       workers(workers),
       extensions_activity_monitor(extensions_activity_monitor),
       event_handler(event_handler),
       service_url(service_url),
       make_http_bridge_factory_fn(make_http_bridge_factory_fn),
       credentials(credentials),
-      chrome_sync_notification_bridge(chrome_sync_notification_bridge),
+      android_invalidator_bridge(android_invalidator_bridge),
       invalidator_factory(invalidator_factory),
       sync_manager_factory(sync_manager_factory),
       delete_sync_data_folder(delete_sync_data_folder),
       restored_key_for_bootstrapping(restored_key_for_bootstrapping),
       restored_keystore_key_for_bootstrapping(
           restored_keystore_key_for_bootstrapping),
       internal_components_factory(internal_components_factory),
       unrecoverable_error_handler(unrecoverable_error_handler),
       report_unrecoverable_error_function(
           report_unrecoverable_error_function) {
 }
 
 SyncBackendHost::DoInitializeOptions::~DoInitializeOptions() {}
 
 SyncBackendHost::Core::Core(const std::string& name,
                             const FilePath& sync_data_folder_path,
                             const base::WeakPtr<SyncBackendHost>& backend)
     : name_(name),
       sync_data_folder_path_(sync_data_folder_path),
       host_(backend),
       sync_loop_(NULL),
       registrar_(NULL),
-      chrome_sync_notification_bridge_(NULL),
       registered_as_invalidation_handler_(false) {
   DCHECK(backend.get());
 }
 
 SyncBackendHost::Core::~Core() {
   DCHECK(!sync_manager_.get());
   DCHECK(!sync_loop_);
 }
 
 void SyncBackendHost::Core::OnSyncCycleCompleted(
@@ skipping 20 matching lines @@
   sync_manager_->ConfigureSyncer(
       syncer::CONFIGURE_REASON_NEW_CLIENT,
       new_control_types,
       routing_info,
       base::Bind(&SyncBackendHost::Core::DoInitialProcessControlTypes,
                  this),
       base::Bind(&SyncBackendHost::Core::OnControlTypesDownloadRetry,
                  this));
 }
 
+void SyncBackendHost::Core::DoRefreshTypes(syncer::ModelTypeSet types) {
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
+  sync_manager_->RefreshTypes(types);
+}
+
 void SyncBackendHost::Core::OnControlTypesDownloadRetry() {
   host_.Call(FROM_HERE,
              &SyncBackendHost::HandleControlTypesDownloadRetry);
 }
 
 void SyncBackendHost::Core::OnInitializationComplete(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     bool success,
@@ skipping 168 matching lines @@
   // 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(),
       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(),
-          kDefaultInvalidatorState)),
+#if defined(OS_ANDROID)
+      scoped_ptr<syncer::Invalidator>(
+          new AndroidInvalidatorBridgeProxy(
+              options.android_invalidator_bridge)),
+#else
+      scoped_ptr<syncer::Invalidator>(
+          options.invalidator_factory->CreateInvalidator()),
+#endif
       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 129 matching lines @@
 }
 
 void SyncBackendHost::Core::DoShutdown(bool sync_disabled) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   // It's safe to do this even if the type was never activated.
   registrar_->DeactivateDataType(syncer::DEVICE_INFO);
   synced_device_tracker_.reset();
 
   DoDestroySyncManager();
 
-  chrome_sync_notification_bridge_ = NULL;
   registrar_ = NULL;
 
   if (sync_disabled)
     DeleteSyncDataFolder();
 
   sync_loop_ = NULL;
 
   host_.Reset();
 }
 
@@ skipping 284 matching lines @@
   DVLOG(1) << "Connection status changed: "
            << syncer::ConnectionStatusToString(status);
   frontend_->OnConnectionStatusChange(status);
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync