[Sync] Split DirectoryChangeListener for thread-safety

chrome/browser/sync/glue/sync_backend_host.cc

 // Copyright (c) 2011 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 <algorithm>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 50 matching lines @@
 SyncBackendHost::SyncBackendHost(Profile* profile)
     : core_(new Core(profile->GetDebugName(),
                      ALLOW_THIS_IN_INITIALIZER_LIST(this))),
       sync_thread_("Chrome_SyncThread"),
       frontend_loop_(MessageLoop::current()),
       profile_(profile),
       frontend_(NULL),
       sync_data_folder_path_(
           profile_->GetPath().Append(kSyncDataFolderName)),
       last_auth_error_(AuthError::None()),
-      syncapi_initialized_(false) {
+      sync_manager_initialized_(false) {
 }
 
 SyncBackendHost::SyncBackendHost()
     : sync_thread_("Chrome_SyncThread"),
       frontend_loop_(MessageLoop::current()),
       profile_(NULL),
       frontend_(NULL),
       last_auth_error_(AuthError::None()),
-      syncapi_initialized_(false) {
+      sync_manager_initialized_(false) {
 }
 
 SyncBackendHost::~SyncBackendHost() {
   DCHECK(!core_ && !frontend_) << "Must call Shutdown before destructor.";
   DCHECK(registrar_.workers.empty());
 }
 
 void SyncBackendHost::Initialize(
     SyncFrontend* frontend,
     const GURL& sync_service_url,
@@ skipping 68 matching lines @@
   return token;
 }
 
 bool SyncBackendHost::IsNigoriEnabled() const {
   base::AutoLock lock(registrar_lock_);
   return registrar_.routing_info.find(syncable::NIGORI) !=
       registrar_.routing_info.end();
 }
 
 bool SyncBackendHost::IsUsingExplicitPassphrase() {
-  return IsNigoriEnabled() && syncapi_initialized_ &&
-      core_->syncapi()->InitialSyncEndedForAllEnabledTypes() &&
-      core_->syncapi()->IsUsingExplicitPassphrase();
+  return IsNigoriEnabled() && sync_manager_initialized_ &&
+      core_->sync_manager()->InitialSyncEndedForAllEnabledTypes() &&
+      core_->sync_manager()->IsUsingExplicitPassphrase();
 }
 
 bool SyncBackendHost::IsCryptographerReady(
     const sync_api::BaseTransaction* trans) const {
-  return syncapi_initialized_ && trans->GetCryptographer()->is_ready();
+  return sync_manager_initialized_ && trans->GetCryptographer()->is_ready();
 }
 
 JsBackend* SyncBackendHost::GetJsBackend() {
-  if (syncapi_initialized_) {
+  if (sync_manager_initialized_) {
     return core_.get();
   } else {
     NOTREACHED();
     return NULL;
   }
 }
 
 sync_api::HttpPostProviderFactory* SyncBackendHost::MakeHttpBridgeFactory(
     net::URLRequestContextGetter* getter) {
   return new HttpBridgeFactory(getter);
@@ skipping 39 matching lines @@
       NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoSetPassphrase,
                         passphrase, is_explicit));
 }
 
 void SyncBackendHost::Shutdown(bool sync_disabled) {
   // Thread shutdown should occur in the following order:
   // - Sync Thread
   // - UI Thread (stops some time after we return from this call).
   if (sync_thread_.IsRunning()) {  // Not running in tests.
     // TODO(akalin): Remove the need for this.
-    core_->syncapi()->RequestEarlyExit();
+    if (sync_manager_initialized_) {
+      core_->sync_manager()->RequestEarlyExit();
+    }
     sync_thread_.message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(core_.get(),
                           &SyncBackendHost::Core::DoShutdown,
                           sync_disabled));
   }
 
   // Before joining the sync_thread_, we wait for the UIModelWorker to
   // give us the green light that it is not depending on the frontend_loop_ to
   // process any more tasks. Stop() blocks until this termination condition
   // is true.
@@ skipping 26 matching lines @@
   registrar_.workers.erase(GROUP_HISTORY);
   registrar_.workers.erase(GROUP_UI);
   registrar_.workers.erase(GROUP_PASSIVE);
   registrar_.workers.erase(GROUP_PASSWORD);
   frontend_ = NULL;
   core_ = NULL;  // Releases reference to core_.
 }
 
 syncable::AutofillMigrationState
     SyncBackendHost::GetAutofillMigrationState() {
-  return core_->syncapi()->GetAutofillMigrationState();
+  DCHECK(sync_manager_initialized_);
+  return core_->sync_manager()->GetAutofillMigrationState();
 }
 
 void SyncBackendHost::SetAutofillMigrationState(
     syncable::AutofillMigrationState state) {
-  return core_->syncapi()->SetAutofillMigrationState(state);
+  DCHECK(sync_manager_initialized_);
+  return core_->sync_manager()->SetAutofillMigrationState(state);
 }
 
 syncable::AutofillMigrationDebugInfo
     SyncBackendHost::GetAutofillMigrationDebugInfo() {
-  return core_->syncapi()->GetAutofillMigrationDebugInfo();
+  DCHECK(sync_manager_initialized_);
+  return core_->sync_manager()->GetAutofillMigrationDebugInfo();
 }
 
 void SyncBackendHost::SetAutofillMigrationDebugInfo(
     syncable::AutofillMigrationDebugInfo::PropertyToSet property_to_set,
     const syncable::AutofillMigrationDebugInfo& info) {
-  return core_->syncapi()->SetAutofillMigrationDebugInfo(property_to_set, info);
+  DCHECK(sync_manager_initialized_);
+  return core_->sync_manager()->SetAutofillMigrationDebugInfo(
+      property_to_set, info);
 }
 
 void SyncBackendHost::ConfigureAutofillMigration() {
   if (GetAutofillMigrationState() == syncable::NOT_DETERMINED) {
     sync_api::ReadTransaction trans(GetUserShare());
     sync_api::ReadNode autofil_root_node(&trans);
 
     // Check for the presence of autofill node.
     if (!autofil_root_node.InitByTagLookup(browser_sync::kAutofillTag)) {
         SetAutofillMigrationState(syncable::INSUFFICIENT_INFO_TO_DETERMINE);
@@ skipping 80 matching lines @@
 
 void SyncBackendHost::ConfigureDataTypes(
     const DataTypeController::TypeMap& data_type_controllers,
     const syncable::ModelTypeSet& types,
     sync_api::ConfigureReason reason,
     CancelableTask* ready_task,
     bool enable_nigori) {
   // Only one configure is allowed at a time.
   DCHECK(!pending_config_mode_state_.get());
   DCHECK(!pending_download_state_.get());
-  DCHECK(syncapi_initialized_);
+  DCHECK(sync_manager_initialized_);
 
   if (types.count(syncable::AUTOFILL_PROFILE) != 0) {
     ConfigureAutofillMigration();
   }
 
   syncable::ModelTypeSet types_copy = types;
   if (enable_nigori) {
     types_copy.insert(syncable::NIGORI);
   }
   bool nigori_currently_enabled = IsNigoriEnabled();
@@ skipping 32 matching lines @@
 
   VLOG(1) << "Syncer in config mode. SBH executing"
           << "FinishConfigureDataTypesOnFrontendLoop";
   if (pending_config_mode_state_->deleted_type) {
     sync_thread_.message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(core_.get(),
         &SyncBackendHost::Core::DeferNudgeForCleanup));
   }
 
   if (pending_config_mode_state_->added_types.none() &&
-      !core_->syncapi()->InitialSyncEndedForAllEnabledTypes()) {
+      !core_->sync_manager()->InitialSyncEndedForAllEnabledTypes()) {
     LOG(WARNING) << "No new types, but initial sync not finished."
                  << "Possible sync db corruption / removal.";
     // TODO(tim): Log / UMA / count this somehow?
     // TODO(tim): If no added types, we could (should?) config only for
     // types that are needed... but this is a rare corruption edge case or
     // implies the user mucked around with their syncdb, so for now do all.
     pending_config_mode_state_->added_types =
         syncable::ModelTypeBitSetFromSet(
             pending_config_mode_state_->initial_types);
   }
@@ skipping 30 matching lines @@
 
 void SyncBackendHost::EncryptDataTypes(
     const syncable::ModelTypeSet& encrypted_types) {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
      NewRunnableMethod(core_.get(),
                        &SyncBackendHost::Core::DoEncryptDataTypes,
                        encrypted_types));
 }
 
 syncable::ModelTypeSet SyncBackendHost::GetEncryptedDataTypes() const {
-  DCHECK(syncapi_initialized_);
-  return core_->syncapi()->GetEncryptedDataTypes();
+  DCHECK(sync_manager_initialized_);
+  return core_->sync_manager()->GetEncryptedDataTypes();
 }
 
 void SyncBackendHost::RequestNudge(const tracked_objects::Location& location) {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoRequestNudge,
                         location));
 }
 
 void SyncBackendHost::ActivateDataType(
     DataTypeController* data_type_controller,
@@ skipping 32 matching lines @@
 }
 
 bool SyncBackendHost::RequestClearServerData() {
   sync_thread_.message_loop()->PostTask(FROM_HERE,
      NewRunnableMethod(core_.get(),
      &SyncBackendHost::Core::DoRequestClearServerData));
   return true;
 }
 
 SyncBackendHost::Core::~Core() {
+  DCHECK(!sync_manager_.get());
 }
 
 void SyncBackendHost::Core::NotifyPassphraseRequired(
     sync_api::PassphraseRequiredReason reason) {
   if (!host_ || !host_->frontend_)
     return;
 
   DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
 
   // When setting a passphrase fails, unset our waiting flag.
@@ skipping 70 matching lines @@
       http_bridge_factory(http_bridge_factory),
       credentials(credentials),
       delete_sync_data_folder(delete_sync_data_folder),
       restored_key_for_bootstrapping(restored_key_for_bootstrapping),
       setup_for_test_mode(setup_for_test_mode) {
 }
 
 SyncBackendHost::Core::DoInitializeOptions::~DoInitializeOptions() {}
 
 sync_api::UserShare* SyncBackendHost::GetUserShare() const {
-  DCHECK(syncapi_initialized_);
-  return core_->syncapi()->GetUserShare();
+  DCHECK(sync_manager_initialized_);
+  return core_->sync_manager()->GetUserShare();
 }
 
 SyncBackendHost::Status SyncBackendHost::GetDetailedStatus() {
-  DCHECK(syncapi_initialized_);
-  return core_->syncapi()->GetDetailedStatus();
+  DCHECK(sync_manager_initialized_);
+  return core_->sync_manager()->GetDetailedStatus();
 }
 
 SyncBackendHost::StatusSummary SyncBackendHost::GetStatusSummary() {
-  DCHECK(syncapi_initialized_);
-  return core_->syncapi()->GetStatusSummary();
+  DCHECK(sync_manager_initialized_);
+  return core_->sync_manager()->GetStatusSummary();
 }
 
 string16 SyncBackendHost::GetAuthenticatedUsername() const {
-  DCHECK(syncapi_initialized_);
-  return UTF8ToUTF16(core_->syncapi()->GetAuthenticatedUsername());
+  DCHECK(sync_manager_initialized_);
+  return UTF8ToUTF16(core_->sync_manager()->GetAuthenticatedUsername());
 }
 
 const GoogleServiceAuthError& SyncBackendHost::GetAuthError() const {
   return last_auth_error_;
 }
 
 const SyncSessionSnapshot* SyncBackendHost::GetLastSessionSnapshot() const {
   return last_snapshot_.get();
 }
 
 void SyncBackendHost::GetWorkers(std::vector<ModelSafeWorker*>* out) {
   base::AutoLock lock(registrar_lock_);
   out->clear();
   for (WorkerMap::const_iterator it = registrar_.workers.begin();
        it != registrar_.workers.end(); ++it) {
     out->push_back((*it).second);
   }
 }
 
 void SyncBackendHost::GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
   base::AutoLock lock(registrar_lock_);
   ModelSafeRoutingInfo copy(registrar_.routing_info);
   out->swap(copy);
 }
 
 bool SyncBackendHost::HasUnsyncedItems() const {
-  DCHECK(syncapi_initialized_);
-  return core_->syncapi()->HasUnsyncedItems();
+  DCHECK(sync_manager_initialized_);
+  return core_->sync_manager()->HasUnsyncedItems();
 }
 
 void SyncBackendHost::LogUnsyncedItems(int level) const {
-  DCHECK(syncapi_initialized_);
-  return core_->syncapi()->LogUnsyncedItems(level);
+  DCHECK(sync_manager_initialized_);
+  return core_->sync_manager()->LogUnsyncedItems(level);
 }
 
 SyncBackendHost::Core::Core(const std::string& name, SyncBackendHost* backend)
-    : host_(backend),
-      syncapi_(new sync_api::SyncManager(name)),
+    : name_(name),
+      host_(backend),
       sync_manager_observer_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       parent_router_(NULL),
       processing_passphrase_(false),
       deferred_nudge_for_cleanup_requested_(false) {
 }
 
 // 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 MakeUserAgentForSyncApi() {
   std::string user_agent;
   user_agent = "Chrome ";
 #if defined(OS_WIN)
   user_agent += "WIN ";
 #elif defined(OS_LINUX)
   user_agent += "LINUX ";
 #elif defined(OS_FREEBSD)
   user_agent += "FREEBSD ";
 #elif defined(OS_OPENBSD)
   user_agent += "OPENBSD ";
@@ skipping 21 matching lines @@
   // 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.
   bool success = file_util::CreateDirectory(host_->sync_data_folder_path());
   DCHECK(success);
 
-  syncapi_->AddObserver(this);
+  sync_manager_.reset(new sync_api::SyncManager(name_)),
+  sync_manager_->AddObserver(this);
   const FilePath& path_str = host_->sync_data_folder_path();
-  success = syncapi_->Init(
+  success = sync_manager_->Init(
       path_str,
       (options.service_url.host() + options.service_url.path()).c_str(),
       options.service_url.EffectiveIntPort(),
       options.service_url.SchemeIsSecure(),
       options.http_bridge_factory,
       host_,  // ModelSafeWorkerRegistrar.
-      MakeUserAgentForSyncapi().c_str(),
+      MakeUserAgentForSyncApi().c_str(),
       options.credentials,
       sync_notifier_.get(),
       options.restored_key_for_bootstrapping,
       options.setup_for_test_mode);
   DCHECK(success) << "Syncapi initialization failed!";
 }
 
 void SyncBackendHost::Core::DoUpdateCredentials(
     const SyncCredentials& credentials) {
   DCHECK(MessageLoop::current() == host_->sync_thread_.message_loop());
-  syncapi_->UpdateCredentials(credentials);
+  sync_manager_->UpdateCredentials(credentials);
 }
 
 void SyncBackendHost::Core::DoUpdateEnabledTypes() {
   DCHECK(MessageLoop::current() == host_->sync_thread_.message_loop());
-  syncapi_->UpdateEnabledTypes();
+  sync_manager_->UpdateEnabledTypes();
 }
 
 void SyncBackendHost::Core::DoStartSyncing() {
   DCHECK(MessageLoop::current() == host_->sync_thread_.message_loop());
-  syncapi_->StartSyncingNormally();
+  sync_manager_->StartSyncingNormally();
   if (deferred_nudge_for_cleanup_requested_)
-    syncapi_->RequestNudge(FROM_HERE);
+    sync_manager_->RequestNudge(FROM_HERE);
   deferred_nudge_for_cleanup_requested_ = false;
 }
 
 void SyncBackendHost::Core::DoSetPassphrase(const std::string& passphrase,
                                             bool is_explicit) {
   DCHECK(MessageLoop::current() == host_->sync_thread_.message_loop());
-  syncapi_->SetPassphrase(passphrase, is_explicit);
+  sync_manager_->SetPassphrase(passphrase, is_explicit);
 }
 
 bool SyncBackendHost::Core::processing_passphrase() const {
   DCHECK(MessageLoop::current() == host_->frontend_loop_);
   return processing_passphrase_;
 }
 
 void SyncBackendHost::Core::set_processing_passphrase() {
   DCHECK(MessageLoop::current() == host_->frontend_loop_);
   processing_passphrase_ = true;
 }
 
 void SyncBackendHost::Core::DoEncryptDataTypes(
     const syncable::ModelTypeSet& encrypted_types) {
   DCHECK(MessageLoop::current() == host_->sync_thread_.message_loop());
-  syncapi_->EncryptDataTypes(encrypted_types);
+  sync_manager_->EncryptDataTypes(encrypted_types);
 }
 
 void SyncBackendHost::Core::DoRequestConfig(
     const syncable::ModelTypeBitSet& added_types,
     sync_api::ConfigureReason reason) {
-  syncapi_->RequestConfig(added_types, reason);
+  sync_manager_->RequestConfig(added_types, reason);
 }
 
 void SyncBackendHost::Core::DoStartConfiguration(Callback0::Type* callback) {
-  syncapi_->StartConfigurationMode(callback);
+  sync_manager_->StartConfigurationMode(callback);
 }
 
 UIModelWorker* SyncBackendHost::ui_worker() {
   ModelSafeWorker* w = registrar_.workers[GROUP_UI];
   if (w == NULL)
     return NULL;
   if (w->GetModelSafeGroup() != GROUP_UI)
     NOTREACHED();
   return static_cast<UIModelWorker*>(w);
 }
 
 void SyncBackendHost::Core::DoShutdown(bool sync_disabled) {
   DCHECK(MessageLoop::current() == host_->sync_thread_.message_loop());
 
   save_changes_timer_.Stop();
-  syncapi_->Shutdown();  // Stops the SyncerThread.
-  syncapi_->RemoveObserver(this);
+  sync_manager_->Shutdown();  // Stops the SyncerThread.
+  sync_manager_->RemoveObserver(this);
   DisconnectChildJsEventRouter();
+  sync_manager_.reset();
   host_->ui_worker()->OnSyncerShutdownComplete();
 
   if (sync_disabled)
     DeleteSyncDataFolder();
 
   host_ = NULL;
 }
 
 ChangeProcessor* SyncBackendHost::Core::GetProcessor(
     syncable::ModelType model_type) {
@@ skipping 103 matching lines @@
 
 void SyncBackendHost::Core::OnInitializationComplete() {
   if (!host_ || !host_->frontend_)
     return;  // We may have been told to Shutdown before initialization
              // completed.
 
   // We could be on some random sync backend thread, so MessageLoop::current()
   // can definitely be null in here.
   host_->frontend_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this,
-                        &Core::HandleInitalizationCompletedOnFrontendLoop));
+                        &Core::HandleInitializationCompletedOnFrontendLoop));
 
   // Initialization is complete, so we can schedule recurring SaveChanges.
   host_->sync_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(this, &Core::StartSavingChanges));
 }
 
-void SyncBackendHost::Core::HandleInitalizationCompletedOnFrontendLoop() {
+void SyncBackendHost::Core::HandleInitializationCompletedOnFrontendLoop() {
   if (!host_)
     return;
   host_->HandleInitializationCompletedOnFrontendLoop();
 }
 
 void SyncBackendHost::HandleInitializationCompletedOnFrontendLoop() {
   if (!frontend_)
     return;
-  syncapi_initialized_ = true;
+  sync_manager_initialized_ = true;
   // Now that the syncapi is initialized, we can update the cryptographer (and
   // can handle any ON_PASSPHRASE_REQUIRED notifications that may arise).
-  core_->syncapi()->RefreshEncryption();
+  core_->sync_manager()->RefreshEncryption();
   frontend_->OnBackendInitialized();
 }
 
 bool SyncBackendHost::Core::IsCurrentThreadSafeForModel(
     syncable::ModelType model_type) {
   base::AutoLock lock(host_->registrar_lock_);
 
   browser_sync::ModelSafeRoutingInfo::const_iterator routing_it =
       host_->registrar_.routing_info.find(model_type);
   if (routing_it == host_->registrar_.routing_info.end())
@@ skipping 121 matching lines @@
 }
 
 void SyncBackendHost::Core::StartSavingChanges() {
   save_changes_timer_.Start(
       base::TimeDelta::FromSeconds(kSaveChangesIntervalSeconds),
       this, &Core::SaveChanges);
 }
 
 void SyncBackendHost::Core::DoRequestNudge(
     const tracked_objects::Location& nudge_location) {
-  syncapi_->RequestNudge(nudge_location);
+  sync_manager_->RequestNudge(nudge_location);
 }
 
 void SyncBackendHost::Core::DoRequestClearServerData() {
-  syncapi_->RequestClearServerData();
+  sync_manager_->RequestClearServerData();
 }
 
 void SyncBackendHost::Core::SaveChanges() {
-  syncapi_->SaveChanges();
+  sync_manager_->SaveChanges();
 }
 
 void SyncBackendHost::Core::DeleteSyncDataFolder() {
   if (file_util::DirectoryExists(host_->sync_data_folder_path())) {
     if (!file_util::Delete(host_->sync_data_folder_path(), true))
       LOG(DFATAL) << "Could not delete the Sync Data folder.";
   }
 }
 
 void SyncBackendHost::Core::SetParentJsEventRouter(JsEventRouter* router) {
@@ skipping 34 matching lines @@
       FROM_HERE,
       NewRunnableMethod(this,
                         &SyncBackendHost::Core::DoProcessMessage,
                         name, args, sender));
 }
 
 void SyncBackendHost::Core::ConnectChildJsEventRouter() {
   DCHECK_EQ(MessageLoop::current(), host_->sync_thread_.message_loop());
   // We need this check since AddObserver() can be called at most once
   // for a given observer.
-  if (!syncapi_->GetJsBackend()->GetParentJsEventRouter()) {
-    syncapi_->GetJsBackend()->SetParentJsEventRouter(this);
-    syncapi_->AddObserver(&sync_manager_observer_);
+  if (!sync_manager_->GetJsBackend()->GetParentJsEventRouter()) {
+    sync_manager_->GetJsBackend()->SetParentJsEventRouter(this);
+    sync_manager_->AddObserver(&sync_manager_observer_);
   }
 }
 
 void SyncBackendHost::Core::DisconnectChildJsEventRouter() {
   DCHECK_EQ(MessageLoop::current(), host_->sync_thread_.message_loop());
-  syncapi_->GetJsBackend()->RemoveParentJsEventRouter();
-  syncapi_->RemoveObserver(&sync_manager_observer_);
+  sync_manager_->GetJsBackend()->RemoveParentJsEventRouter();
+  sync_manager_->RemoveObserver(&sync_manager_observer_);
 }
 
 void SyncBackendHost::Core::DoProcessMessage(
     const std::string& name, const JsArgList& args,
     const JsEventHandler* sender) {
   DCHECK_EQ(MessageLoop::current(), host_->sync_thread_.message_loop());
-  syncapi_->GetJsBackend()->ProcessMessage(name, args, sender);
+  sync_manager_->GetJsBackend()->ProcessMessage(name, args, sender);
 }
 
 void SyncBackendHost::Core::DeferNudgeForCleanup() {
   DCHECK_EQ(MessageLoop::current(), host_->sync_thread_.message_loop());
   deferred_nudge_for_cleanup_requested_ = true;
 }
 
 }  // namespace browser_sync