[Sync] Pass the correct set of enabled types to the sync notifier

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>
@@ skipping 106 matching lines @@
   // operations.
   //
   // Called to perform initialization of the syncapi on behalf of
   // SyncBackendHost::Initialize.
   void DoInitialize(const DoInitializeOptions& options);
 
   // Called to perform credential update on behalf of
   // SyncBackendHost::UpdateCredentials
   void DoUpdateCredentials(const syncer::SyncCredentials& credentials);
 
-  // Called when the user disables or enables a sync type.
-  void DoUpdateEnabledTypes(const syncer::ModelTypeSet& enabled_types);
-
   // Called to tell the syncapi to start syncing (generally after
   // initialization and authentication).
   void DoStartSyncing(const syncer::ModelSafeRoutingInfo& routing_info);
 
   // Called to set the passphrase for encryption.
   void DoSetEncryptionPassphrase(const std::string& passphrase,
                                  bool is_explicit);
 
   // Called to decrypt the pending keys.
   void DoSetDecryptionPassphrase(const std::string& passphrase);
@@ skipping 74 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_;
 
   // The top-level syncapi entry point.  Lives on the sync thread.
   scoped_ptr<syncer::SyncManager> sync_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
@@ skipping 77 matching lines @@
       sync_notifier_factory_(
           ParseNotifierOptions(*CommandLine::ForCurrentProcess(),
                                profile_->GetRequestContext()),
           content::GetUserAgent(GURL()),
           base::WeakPtr<syncer::InvalidationStateTracker>()),
       frontend_(NULL) {
 }
 
 SyncBackendHost::~SyncBackendHost() {
   DCHECK(!core_ && !frontend_) << "Must call Shutdown before destructor.";
+  DCHECK(!chrome_sync_notification_bridge_.get());
   DCHECK(!registrar_.get());
 }
 
 namespace {
 
 // Helper to construct a user agent string (ASCII) suitable for use by
 // the syncapi for any HTTP communication. This string is used by the sync
 // backend for classifying client types when calculating statistics.
 std::string MakeUserAgentForSyncApi() {
   std::string user_agent;
@@ skipping 407 matching lines @@
        base::Bind(&SyncBackendHost::Core::DoConfigureSyncer,
                   core_.get(),
                   reason,
                   types_to_config,
                   routing_info,
                   ready_task,
                   retry_callback));
 }
 
 void SyncBackendHost::FinishConfigureDataTypesOnFrontendLoop(
-    syncer::ModelTypeSet types_to_configure,
-    syncer::ModelTypeSet configured_types,
+    syncer::ModelTypeSet failed_configuration_types,
     const base::Callback<void(syncer::ModelTypeSet)>& ready_task) {
-  const syncer::ModelTypeSet failed_configuration_types =
-      Difference(types_to_configure, configured_types);
-  SDVLOG(1)
-      << "Added types: "
-      << syncer::ModelTypeSetToString(types_to_configure)
-      << ", configured types: "
-      << syncer::ModelTypeSetToString(configured_types)
-      << ", failed configuration types: "
-      << syncer::ModelTypeSetToString(failed_configuration_types);
-
-  // Update |chrome_sync_notification_bridge_|'s enabled types here as it has
-  // to happen on the UI thread.
-  chrome_sync_notification_bridge_->UpdateEnabledTypes(configured_types);
-
-  // Notify SyncManager (especially the notification listener) about new types.
-  sync_thread_.message_loop()->PostTask(FROM_HERE,
-      base::Bind(&SyncBackendHost::Core::DoUpdateEnabledTypes, core_.get(),
-                 configured_types));
-
+  if (!frontend_)
+    return;
+  DCHECK_EQ(MessageLoop::current(), frontend_loop_);
   if (!ready_task.is_null())
     ready_task.Run(failed_configuration_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,
@@ skipping 32 matching lines @@
 
 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) {
+      registrar_(NULL),
+      chrome_sync_notification_bridge_(NULL) {
   DCHECK(backend.get());
 }
 
 SyncBackendHost::Core::~Core() {
   DCHECK(!sync_manager_.get());
   DCHECK(!sync_loop_);
 }
 
 void SyncBackendHost::Core::OnSyncCycleCompleted(
     const SyncSessionSnapshot& snapshot) {
@@ skipping 128 matching lines @@
 
   // Make sure that the directory exists before initializing the backend.
   // If it already exists, this will do no harm.
   bool success = file_util::CreateDirectory(sync_data_folder_path_);
   DCHECK(success);
 
   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_);
+
   sync_manager_ = options.sync_manager_factory->CreateSyncManager(name_);
   sync_manager_->AddObserver(this);
   success = 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(),
@@ skipping 24 matching lines @@
     sync_manager_->ThrowUnrecoverableError();
   }
 }
 
 void SyncBackendHost::Core::DoUpdateCredentials(
     const SyncCredentials& credentials) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->UpdateCredentials(credentials);
 }
 
-void SyncBackendHost::Core::DoUpdateEnabledTypes(
-    const syncer::ModelTypeSet& enabled_types) {
-  DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  sync_manager_->UpdateEnabledTypes(enabled_types);
-}
-
 void SyncBackendHost::Core::DoStartSyncing(
     const syncer::ModelSafeRoutingInfo& routing_info) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->StartSyncingNormally(routing_info);
 }
 
 void SyncBackendHost::Core::DoSetEncryptionPassphrase(
     const std::string& passphrase,
     bool is_explicit) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
@@ skipping 27 matching lines @@
 
 void SyncBackendHost::Core::DoShutdown(bool sync_disabled) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   if (!sync_manager_.get())
     return;
 
   save_changes_timer_.reset();
   sync_manager_->ShutdownOnSyncThread();
   sync_manager_->RemoveObserver(this);
   sync_manager_.reset();
+  chrome_sync_notification_bridge_ = NULL;
   registrar_ = NULL;
 
   if (sync_disabled)
     DeleteSyncDataFolder();
 
   sync_loop_ = NULL;
 
   host_.Reset();
 }
 
@@ skipping 14 matching lines @@
                  ready_task),
       base::Bind(&SyncBackendHost::Core::DoRetryConfiguration,
                  this,
                  retry_callback));
 }
 
 void SyncBackendHost::Core::DoFinishConfigureDataTypes(
     syncer::ModelTypeSet types_to_config,
     const base::Callback<void(syncer::ModelTypeSet)>& ready_task) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  syncer::ModelTypeSet configured_types =
-      sync_manager_->InitialSyncEndedTypes();
-  configured_types.RetainAll(types_to_config);
+
+  // Update the enabled types for the bridge and sync manager.
+  syncer::ModelSafeRoutingInfo routing_info;
+  registrar_->GetModelSafeRoutingInfo(&routing_info);
+  const syncer::ModelTypeSet enabled_types = GetRoutingInfoTypes(routing_info);
+  chrome_sync_notification_bridge_->UpdateEnabledTypes(enabled_types);
+  sync_manager_->UpdateEnabledTypes(enabled_types);
+
+  const syncer::ModelTypeSet failed_configuration_types =
+      Difference(types_to_config, sync_manager_->InitialSyncEndedTypes());
   host_.Call(FROM_HERE,
              &SyncBackendHost::FinishConfigureDataTypesOnFrontendLoop,
-             types_to_config,
-             configured_types,
+             failed_configuration_types,
              ready_task);
 }
 
 void SyncBackendHost::Core::DoRetryConfiguration(
     const base::Closure& retry_callback) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(FROM_HERE,
              &SyncBackendHost::RetryConfigurationOnFrontendLoop,
              retry_callback);
 }
@@ skipping 256 matching lines @@
       FROM_HERE,
       base::Bind(&SyncBackendHost::Core::DoRefreshNigori,
                  core_.get(), sync_thread_done_callback));
 }
 
 #undef SDVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync