make new syncer thread the default.

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 48 matching lines @@
 
 SyncBackendHost::SyncBackendHost(Profile* profile)
     : core_(new Core(ALLOW_THIS_IN_INITIALIZER_LIST(this))),
       core_thread_("Chrome_SyncCoreThread"),
       frontend_loop_(MessageLoop::current()),
       profile_(profile),
       frontend_(NULL),
       sync_data_folder_path_(
           profile_->GetPath().Append(kSyncDataFolderName)),
       last_auth_error_(AuthError::None()),
-      using_new_syncer_thread_(
-          CommandLine::ForCurrentProcess()->HasSwitch(
-              switches::kNewSyncerThread)),
       syncapi_initialized_(false) {
 }
 
 SyncBackendHost::SyncBackendHost()
     : core_thread_("Chrome_SyncCoreThread"),
       frontend_loop_(MessageLoop::current()),
       profile_(NULL),
       frontend_(NULL),
       last_auth_error_(AuthError::None()),
-      using_new_syncer_thread_(
-          CommandLine::ForCurrentProcess()->HasSwitch(
-              switches::kNewSyncerThread)),
       syncapi_initialized_(false) {
 }
 
 SyncBackendHost::~SyncBackendHost() {
   DCHECK(!core_ && !frontend_) << "Must call Shutdown before destructor.";
   DCHECK(registrar_.workers.empty());
 }
 
 void SyncBackendHost::Initialize(
     SyncFrontend* frontend,
@@ skipping 308 matching lines @@
     ConfigureAutofillMigration();
   }
 
   {
     base::AutoLock lock(registrar_lock_);
     pending_config_mode_state_.reset(
         MakePendingConfigModeState(data_type_controllers, types, ready_task,
                                    &registrar_.routing_info));
   }
 
-  // If we're doing the first configure (at startup) this is redundant as the
-  // syncer thread always must start in config mode.
-  if (using_new_syncer_thread_) {
-    core_thread_.message_loop()->PostTask(
-        FROM_HERE,
-        NewRunnableMethod(core_.get(),
-        &SyncBackendHost::Core::DoStartConfigurationMode));
-  } else {
-    FinishConfigureDataTypesOnFrontendLoop();
-  }
+  FinishConfigureDataTypesOnFrontendLoop();
 }
 
 void SyncBackendHost::FinishConfigureDataTypesOnFrontendLoop() {
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
   // Nudge the syncer. This is necessary for both datatype addition/deletion.
   //
   // Deletions need a nudge in order to ensure the deletion occurs in a timely
   // manner (see issue 56416).
   //
   // In the case of additions, on the next sync cycle, the syncer should
   // notice that the routing info has changed and start the process of
   // downloading updates for newly added data types.  Once this is
   // complete, the configure_state_.ready_task_ is run via an
   // OnInitializationComplete notification.
-  bool request_nudge = false;
+
   if (pending_config_mode_state_->deleted_type) {
-    if (using_new_syncer_thread_) {
-      core_thread_.message_loop()->PostTask(FROM_HERE,
-          NewRunnableMethod(core_.get(),
-          &SyncBackendHost::Core::DeferNudgeForCleanup));
-    } else {
-      request_nudge = true;
-    }
+    core_thread_.message_loop()->PostTask(FROM_HERE,
+        NewRunnableMethod(core_.get(),
+        &SyncBackendHost::Core::DeferNudgeForCleanup));
   }
 
   if (pending_config_mode_state_->added_types.none() &&
       !core_->syncapi()->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);
   }
 
   // If we've added types, we always want to request a nudge/config (even if
   // the initial sync is ended), in case we could not decrypt the data.
   if (pending_config_mode_state_->added_types.none()) {
     // No new types - just notify the caller that the types are available.
     pending_config_mode_state_->ready_task->Run();
   } else {
     pending_download_state_.reset(pending_config_mode_state_.release());
-    if (using_new_syncer_thread_) {
-      RequestConfig(pending_download_state_->added_types);
-    } else {
-      request_nudge = true;
-    }
-  }
 
-  // TODO(tim): Remove this when we get rid of the old syncer thread.
-  if (request_nudge) {
-    CHECK(!using_new_syncer_thread_);
-    RequestNudge(FROM_HERE);
+    syncable::ModelTypeBitSet types_copy(pending_download_state_->added_types);
+    if (IsNigoriEnabled())
+      types_copy.set(syncable::NIGORI);
+    core_thread_.message_loop()->PostTask(FROM_HERE,
+         NewRunnableMethod(core_.get(),
+                           &SyncBackendHost::Core::DoRequestConfig,
+                           types_copy));
   }
 
   pending_config_mode_state_.reset();
 
   // Notify the SyncManager about the new types.
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(core_.get(),
                         &SyncBackendHost::Core::DoUpdateEnabledTypes));
 }
 
 void SyncBackendHost::EncryptDataTypes(
     const syncable::ModelTypeSet& encrypted_types) {
   core_thread_.message_loop()->PostTask(FROM_HERE,
      NewRunnableMethod(core_.get(),
                        &SyncBackendHost::Core::DoEncryptDataTypes,
                        encrypted_types));
 }
 
 void SyncBackendHost::RequestNudge(const tracked_objects::Location& location) {
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoRequestNudge,
                         location));
 }
 
-void SyncBackendHost::RequestConfig(
-    const syncable::ModelTypeBitSet& added_types) {
-  DCHECK(core_->syncapi());
-
-  syncable::ModelTypeBitSet types_copy(added_types);
-  if (IsNigoriEnabled())
-    types_copy.set(syncable::NIGORI);
-
-  core_->syncapi()->RequestConfig(types_copy);
-}
-
 void SyncBackendHost::ActivateDataType(
     DataTypeController* data_type_controller,
     ChangeProcessor* change_processor) {
   base::AutoLock lock(registrar_lock_);
 
   // Ensure that the given data type is in the PASSIVE group.
   browser_sync::ModelSafeRoutingInfo::iterator i =
       registrar_.routing_info.find(data_type_controller->type());
   DCHECK(i != registrar_.routing_info.end());
   DCHECK((*i).second == GROUP_PASSIVE);
@@ skipping 11 matching lines @@
     DataTypeController* data_type_controller,
     ChangeProcessor* change_processor) {
   base::AutoLock lock(registrar_lock_);
   registrar_.routing_info.erase(data_type_controller->type());
 
   std::map<syncable::ModelType, ChangeProcessor*>::size_type erased =
       processors_.erase(data_type_controller->type());
   DCHECK_EQ(erased, 1U);
 }
 
-bool SyncBackendHost::RequestPause() {
-  DCHECK(!using_new_syncer_thread_);
-  core_thread_.message_loop()->PostTask(FROM_HERE,
-     NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoRequestPause));
-  return true;
-}
-
-bool SyncBackendHost::RequestResume() {
-  DCHECK(!using_new_syncer_thread_);
-  core_thread_.message_loop()->PostTask(FROM_HERE,
-     NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoRequestResume));
-  return true;
-}
-
 bool SyncBackendHost::RequestClearServerData() {
   core_thread_.message_loop()->PostTask(FROM_HERE,
      NewRunnableMethod(core_.get(),
      &SyncBackendHost::Core::DoRequestClearServerData));
   return true;
 }
 
 SyncBackendHost::Core::~Core() {
 }
 
-void SyncBackendHost::Core::NotifyPaused() {
-  DCHECK(!host_ || !host_->using_new_syncer_thread_);
-  NotificationService::current()->Notify(NotificationType::SYNC_PAUSED,
-                                         NotificationService::AllSources(),
-                                         NotificationService::NoDetails());
-}
-
-void SyncBackendHost::Core::NotifyResumed() {
-  DCHECK(!host_ || !host_->using_new_syncer_thread_);
-  NotificationService::current()->Notify(NotificationType::SYNC_RESUMED,
-                                         NotificationService::AllSources(),
-                                         NotificationService::NoDetails());
-}
-
 void SyncBackendHost::Core::NotifyPassphraseRequired(bool for_decryption) {
   if (!host_ || !host_->frontend_)
     return;
 
   DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
 
   if (processing_passphrase_) {
     VLOG(1) << "Core received OnPassphraseRequired while processing a "
             << "passphrase. Silently dropping.";
     return;
@@ skipping 233 matching lines @@
   DCHECK(MessageLoop::current() == host_->frontend_loop_);
   processing_passphrase_ = true;
 }
 
 void SyncBackendHost::Core::DoEncryptDataTypes(
     const syncable::ModelTypeSet& encrypted_types) {
   DCHECK(MessageLoop::current() == host_->core_thread_.message_loop());
   syncapi_->EncryptDataTypes(encrypted_types);
 }
 
+void SyncBackendHost::Core::DoRequestConfig(
+    const syncable::ModelTypeBitSet& added_types) {
+  syncapi_->RequestConfig(added_types);
+}
+
 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) {
@@ skipping 97 matching lines @@
     bool found_all_added = true;
     for (syncable::ModelTypeSet::const_iterator it =
              host_->pending_download_state_->initial_types.begin();
          it != host_->pending_download_state_->initial_types.end();
          ++it) {
       if (host_->pending_download_state_->added_types.test(*it))
         found_all_added &= snapshot->initial_sync_ended.test(*it);
     }
     if (!found_all_added) {
       CHECK(false);
-      DCHECK(!host_->using_new_syncer_thread_);
     } else {
       host_->pending_download_state_->ready_task->Run();
       host_->pending_download_state_.reset();
     }
   }
   host_->frontend_->OnSyncCycleCompleted();
 }
 
 void SyncBackendHost::Core::OnInitializationComplete() {
   if (!host_ || !host_->frontend_)
@@ skipping 57 matching lines @@
       NewRunnableMethod(this, &Core::NotifyPassphraseFailed));
 }
 
 void SyncBackendHost::Core::OnPassphraseAccepted(
     const std::string& bootstrap_token) {
   host_->frontend_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &Core::NotifyPassphraseAccepted,
           bootstrap_token));
 }
 
-void SyncBackendHost::Core::OnPaused() {
-  host_->frontend_loop_->PostTask(
-      FROM_HERE,
-      NewRunnableMethod(this, &Core::NotifyPaused));
-}
-
-void SyncBackendHost::Core::OnResumed() {
-  host_->frontend_loop_->PostTask(
-      FROM_HERE,
-      NewRunnableMethod(this, &Core::NotifyResumed));
-}
-
 void SyncBackendHost::Core::OnStopSyncingPermanently() {
   host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &Core::HandleStopSyncingPermanentlyOnFrontendLoop));
 }
 
 void SyncBackendHost::Core::OnUpdatedToken(const std::string& token) {
   host_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
       &Core::NotifyUpdatedToken, token));
 }
 
@@ skipping 71 matching lines @@
 
 void SyncBackendHost::Core::DoRequestNudge(
     const tracked_objects::Location& nudge_location) {
   syncapi_->RequestNudge(nudge_location);
 }
 
 void SyncBackendHost::Core::DoRequestClearServerData() {
   syncapi_->RequestClearServerData();
 }
 
-void SyncBackendHost::Core::DoRequestResume() {
-  syncapi_->RequestResume();
-}
-
-void SyncBackendHost::Core::DoRequestPause() {
-  syncapi()->RequestPause();
-}
-
 void SyncBackendHost::Core::SaveChanges() {
   syncapi_->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.";
   }
 }
@@ skipping 55 matching lines @@
   syncapi_->RemoveObserver(&sync_manager_observer_);
 }
 
 void SyncBackendHost::Core::DoProcessMessage(
     const std::string& name, const JsArgList& args,
     const JsEventHandler* sender) {
   DCHECK_EQ(MessageLoop::current(), host_->core_thread_.message_loop());
   syncapi_->GetJsBackend()->ProcessMessage(name, args, sender);
 }
 
-void SyncBackendHost::Core::DoStartConfigurationMode() {
-  syncapi_->StartConfigurationMode(NewCallback(this,
-        &SyncBackendHost::Core::FinishConfigureDataTypes));
-}
-
 void SyncBackendHost::Core::DeferNudgeForCleanup() {
   DCHECK_EQ(MessageLoop::current(), host_->core_thread_.message_loop());
   deferred_nudge_for_cleanup_requested_ = true;
 }
 
 }  // namespace browser_sync