[Sync] Move change-related methods out of SyncManager::Observer

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 "chrome/browser/sync/glue/sync_backend_host.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 97 matching lines @@
   syncable::ModelTypeSet initial_types_with_nigori(initial_types);
   if (profile_->GetPrefs()->GetBoolean(prefs::kSyncHasSetupCompleted))
     initial_types_with_nigori.insert(syncable::NIGORI);
 
   registrar_.reset(new SyncBackendRegistrar(initial_types_with_nigori,
                                             name_,
                                             profile_,
                                             sync_thread_.message_loop()));
 
   InitCore(Core::DoInitializeOptions(
+      sync_thread_.message_loop(),
       registrar_.get(),
       event_handler,
       sync_service_url,
       profile_->GetRequestContext(),
       credentials,
       delete_sync_data_folder,
       RestoreEncryptionBootstrapToken(),
       false));
 }
 
@@ skipping 190 matching lines @@
 string16 SyncBackendHost::GetAuthenticatedUsername() const {
   DCHECK(initialized());
   return UTF8ToUTF16(core_->sync_manager()->GetAuthenticatedUsername());
 }
 
 bool SyncBackendHost::HasUnsyncedItems() const {
   DCHECK(initialized());
   return core_->sync_manager()->HasUnsyncedItems();
 }
 
-void SyncBackendHost::LogUnsyncedItems(int level) const {
-  DCHECK(initialized());
-  return core_->sync_manager()->LogUnsyncedItems(level);
-}
-
 bool SyncBackendHost::IsNigoriEnabled() const {
   return registrar_.get() && registrar_->IsNigoriEnabled();
 }
 
 bool SyncBackendHost::IsUsingExplicitPassphrase() {
   return initialized() && IsNigoriEnabled() &&
       core_->sync_manager()->InitialSyncEndedForAllEnabledTypes() &&
       core_->sync_manager()->IsUsingExplicitPassphrase();
 }
 
 bool SyncBackendHost::IsCryptographerReady(
     const sync_api::BaseTransaction* trans) const {
   return initialized() && trans->GetCryptographer()->is_ready();
 }
 
 void SyncBackendHost::GetModelSafeRoutingInfo(
     ModelSafeRoutingInfo* out) const {
   if (initialized()) {
     CHECK(registrar_.get());
     registrar_->GetModelSafeRoutingInfo(out);
   } else {
     NOTREACHED();
   }
 }
 
 SyncBackendHost::Core::Core(const std::string& name,
                             SyncBackendHost* backend)
     : name_(name),
       host_(backend),
+      sync_loop_(NULL),
       registrar_(NULL) {
   DCHECK(host_);
 }
 
 SyncBackendHost::Core::~Core() {
   DCHECK(!sync_manager_.get());
-}
-
-void SyncBackendHost::Core::OnChangesApplied(
-    syncable::ModelType model_type,
-    const sync_api::BaseTransaction* trans,
-    const sync_api::ImmutableChangeRecordList& changes) {
-  if (!host_ || !host_->frontend_) {
-    DCHECK(false) << "OnChangesApplied called after Shutdown?";
-    return;
-  }
-  ChangeProcessor* processor = registrar_->GetProcessor(model_type);
-  if (!processor)
-    return;
-
-  processor->ApplyChangesFromSyncModel(trans, changes);
-}
-
-void SyncBackendHost::Core::OnChangesComplete(
-    syncable::ModelType model_type) {
-  if (!host_ || !host_->frontend_) {
-    DCHECK(false) << "OnChangesComplete called after Shutdown?";
-    return;
-  }
-
-  ChangeProcessor* processor = registrar_->GetProcessor(model_type);
-  if (!processor)
-    return;
-
-  // This call just notifies the processor that it can commit, it already
-  // buffered any changes it plans to makes so needs no further information.
-  processor->CommitChangesFromSyncModel();
+  DCHECK(!sync_loop_);
 }
 
 void SyncBackendHost::Core::OnSyncCycleCompleted(
     const SyncSessionSnapshot* snapshot) {
+  if (!sync_loop_)
+    return;
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &Core::HandleSyncCycleCompletedOnFrontendLoop,
       new SyncSessionSnapshot(*snapshot)));
 }
 
 
 void SyncBackendHost::Core::OnInitializationComplete(
     const WeakHandle<JsBackend>& js_backend,
     bool success) {
-  if (!host_ || !host_->frontend_)
+  if (!sync_loop_)
     return;  // We may have been told to Shutdown before initialization
              // completed.
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
 
   // 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::HandleInitializationCompletedOnFrontendLoop,
                         js_backend, success));
 
   // Initialization is complete, so we can schedule recurring SaveChanges.
-  host_->sync_thread_.message_loop()->PostTask(FROM_HERE,
+  sync_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &Core::StartSavingChanges));
 }
 
 void SyncBackendHost::Core::OnAuthError(const AuthError& auth_error) {
+  if (!sync_loop_)
+    return;
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   // Post to our core loop so we can modify state. Could be on another thread.
   host_->frontend_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &Core::HandleAuthErrorEventOnFrontendLoop,
       auth_error));
 }
 
 void SyncBackendHost::Core::OnPassphraseRequired(
     sync_api::PassphraseRequiredReason reason) {
+  if (!sync_loop_)
+    return;
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &Core::NotifyPassphraseRequired, reason));
 }
 
 void SyncBackendHost::Core::OnPassphraseAccepted(
     const std::string& bootstrap_token) {
+  if (!sync_loop_)
+    return;
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &Core::NotifyPassphraseAccepted,
           bootstrap_token));
 }
 
 void SyncBackendHost::Core::OnStopSyncingPermanently() {
+  if (!sync_loop_)
+    return;
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &Core::HandleStopSyncingPermanentlyOnFrontendLoop));
 }
 
 void SyncBackendHost::Core::OnUpdatedToken(const std::string& token) {
+  if (!sync_loop_)
+    return;
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &Core::NotifyUpdatedToken, token));
 }
 
 void SyncBackendHost::Core::OnClearServerDataFailed() {
+  if (!sync_loop_)
+    return;
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &Core::HandleClearServerDataFailedOnFrontendLoop));
 }
 
 void SyncBackendHost::Core::OnClearServerDataSucceeded() {
+  if (!sync_loop_)
+    return;
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &Core::HandleClearServerDataSucceededOnFrontendLoop));
 }
 
 void SyncBackendHost::Core::OnEncryptionComplete(
     const syncable::ModelTypeSet& encrypted_types) {
+  if (!sync_loop_)
+    return;
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &Core::NotifyEncryptionComplete,
                         encrypted_types));
 }
 
 void SyncBackendHost::Core::OnActionableError(
     const browser_sync::SyncProtocolError& sync_error) {
-  if (!host_ || !host_->frontend_)
+  if (!sync_loop_)
     return;
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &Core::HandleActionableErrorEventOnFrontendLoop,
                         sync_error));
 }
 
 SyncBackendHost::Core::DoInitializeOptions::DoInitializeOptions(
+    MessageLoop* sync_loop,
     SyncBackendRegistrar* registrar,
     const WeakHandle<JsEventHandler>& event_handler,
     const GURL& service_url,
     const scoped_refptr<net::URLRequestContextGetter>&
         request_context_getter,
     const sync_api::SyncCredentials& credentials,
     bool delete_sync_data_folder,
     const std::string& restored_key_for_bootstrapping,
     bool setup_for_test_mode)
-    : registrar(registrar),
+    : sync_loop(sync_loop),
+      registrar(registrar),
       event_handler(event_handler),
       service_url(service_url),
       request_context_getter(request_context_getter),
       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() {}
@@ skipping 22 matching lines @@
   }
 
   user_agent += version_info.Version();
   user_agent += " (" + version_info.LastChange() + ")";
   if (!version_info.IsOfficialBuild())
     user_agent += "-devel";
   return user_agent;
 }
 
 void SyncBackendHost::Core::DoInitialize(const DoInitializeOptions& options) {
-  DCHECK(MessageLoop::current() == host_->sync_thread_.message_loop());
+  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.
   bool success = file_util::CreateDirectory(host_->sync_data_folder_path());
   DCHECK(success);
 
   DCHECK(!registrar_);
   registrar_ = options.registrar;
   DCHECK(registrar_);
 
   sync_manager_.reset(new sync_api::SyncManager(name_));
   sync_manager_->AddObserver(this);
   const FilePath& path_str = host_->sync_data_folder_path();
   success = sync_manager_->Init(
       path_str,
       options.event_handler,
       options.service_url.host() + options.service_url.path(),
       options.service_url.EffectiveIntPort(),
       options.service_url.SchemeIsSecure(),
       host_->MakeHttpBridgeFactory(options.request_context_getter),
-      options.registrar,
+      options.registrar /* as ModelSafeWorkerRegistrar */,
+      options.registrar /* as SyncManager::ChangeDelegate */,
       MakeUserAgentForSyncApi(),
       options.credentials,
       host_->sync_notifier_factory_.CreateSyncNotifier(),
       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());
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->UpdateCredentials(credentials);
 }
 
 void SyncBackendHost::Core::DoUpdateEnabledTypes() {
-  DCHECK(MessageLoop::current() == host_->sync_thread_.message_loop());
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->UpdateEnabledTypes();
 }
 
 void SyncBackendHost::Core::DoStartSyncing() {
-  DCHECK(MessageLoop::current() == host_->sync_thread_.message_loop());
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->StartSyncingNormally();
 }
 
 void SyncBackendHost::Core::DoRequestClearServerData() {
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->RequestClearServerData();
 }
 
 void SyncBackendHost::Core::DoRequestCleanupDisabledTypes() {
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->RequestCleanupDisabledTypes();
 }
 
 void SyncBackendHost::Core::DoSetPassphrase(const std::string& passphrase,
                                             bool is_explicit) {
-  DCHECK(MessageLoop::current() == host_->sync_thread_.message_loop());
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->SetPassphrase(passphrase, is_explicit);
 }
 
 void SyncBackendHost::Core::DoEnableEncryptEverything() {
-  DCHECK(MessageLoop::current() == host_->sync_thread_.message_loop());
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->EnableEncryptEverything();
 }
 
 void SyncBackendHost::Core::DoShutdown(bool sync_disabled) {
-  DCHECK(MessageLoop::current() == host_->sync_thread_.message_loop());
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
 
   save_changes_timer_.Stop();
   sync_manager_->Shutdown();  // Stops the SyncerThread.
   sync_manager_->RemoveObserver(this);
   sync_manager_.reset();
   registrar_->OnSyncerShutdownComplete();
   registrar_ = NULL;
 
   if (sync_disabled)
     DeleteSyncDataFolder();
 
+  sync_loop_ = NULL;
+
   host_ = NULL;
 }
 
 void SyncBackendHost::Core::DoRequestConfig(
     const syncable::ModelTypeBitSet& types_to_config,
     sync_api::ConfigureReason reason) {
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->RequestConfig(types_to_config, reason);
 }
 
 void SyncBackendHost::Core::DoStartConfiguration(Callback0::Type* callback) {
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->StartConfigurationMode(callback);
 }
 
 void SyncBackendHost::Core::DeleteSyncDataFolder() {
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   if (file_util::DirectoryExists(host_->sync_data_folder_path())) {
     if (!file_util::Delete(host_->sync_data_folder_path(), true))
       SLOG(DFATAL) << "Could not delete the Sync Data folder.";
   }
 }
 
 void SyncBackendHost::Core::FinishConfigureDataTypes() {
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &SyncBackendHost::Core::FinishConfigureDataTypesOnFrontendLoop));
 }
 
 void SyncBackendHost::Core::HandleInitializationCompletedOnFrontendLoop(
     const WeakHandle<JsBackend>& js_backend,
     bool success) {
   if (!host_)
     return;
   host_->HandleInitializationCompletedOnFrontendLoop(js_backend, success);
 }
 
 void SyncBackendHost::Core::StartSavingChanges() {
+  // We may already be shut down.
+  if (!sync_loop_)
+    return;
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   save_changes_timer_.Start(FROM_HERE,
       base::TimeDelta::FromSeconds(kSaveChangesIntervalSeconds),
       this, &Core::SaveChanges);
 }
 
 void SyncBackendHost::Core::SaveChanges() {
+  DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sync_manager_->SaveChanges();
 }
 
 void SyncBackendHost::Core::HandleActionableErrorEventOnFrontendLoop(
     const browser_sync::SyncProtocolError& sync_error) {
-  DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
   if (!host_ || !host_->frontend_)
     return;
+  DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
   host_->frontend_->OnActionableError(sync_error);
 }
 
 void SyncBackendHost::Core::HandleAuthErrorEventOnFrontendLoop(
     const GoogleServiceAuthError& new_auth_error) {
   if (!host_ || !host_->frontend_)
     return;
 
   DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
 
@@ skipping 231 matching lines @@
     : reason(sync_api::CONFIGURE_REASON_UNKNOWN) {}
 
 SyncBackendHost::PendingConfigureDataTypesState::
 ~PendingConfigureDataTypesState() {}
 
 #undef SVLOG
 
 #undef SLOG
 
 }  // namespace browser_sync