Revert "Revert 142517 - [Sync] Refactor sync configuration logic."

sync/internal_api/sync_manager.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 "sync/internal_api/public/sync_manager.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 14 matching lines @@
 #include "sync/engine/throttled_data_type_tracker.h"
 #include "sync/internal_api/change_reorder_buffer.h"
 #include "sync/internal_api/debug_info_event_listener.h"
 #include "sync/internal_api/js_mutation_event_observer.h"
 #include "sync/internal_api/js_sync_manager_observer.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/base/model_type_payload_map.h"
 #include "sync/internal_api/public/base_node.h"
 #include "sync/internal_api/public/configure_reason.h"
 #include "sync/internal_api/public/engine/polling_constants.h"
+#include "sync/internal_api/public/http_post_provider_factory.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/user_share.h"
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/internal_api/public/write_node.h"
 #include "sync/internal_api/public/write_transaction.h"
 #include "sync/internal_api/syncapi_internal.h"
 #include "sync/internal_api/syncapi_server_connection_manager.h"
 #include "sync/js/js_arg_list.h"
 #include "sync/js/js_backend.h"
@@ skipping 124 matching lines @@
   virtual ~SyncInternal() {
     CHECK(!initialized_);
   }
 
   bool Init(const FilePath& database_location,
             const WeakHandle<JsEventHandler>& event_handler,
             const std::string& sync_server_and_path,
             int port,
             bool use_ssl,
             const scoped_refptr<base::TaskRunner>& blocking_task_runner,
-            HttpPostProviderFactory* post_factory,
+            scoped_ptr<HttpPostProviderFactory> post_factory,
             const syncer::ModelSafeRoutingInfo& model_safe_routing_info,
             const std::vector<syncer::ModelSafeWorker*>& workers,
             syncer::ExtensionsActivityMonitor*
                 extensions_activity_monitor,
             ChangeDelegate* change_delegate,
             const SyncCredentials& credentials,
-            syncer::SyncNotifier* sync_notifier,
+            scoped_ptr<syncer::SyncNotifier> sync_notifier,
             const std::string& restored_key_for_bootstrapping,
             TestingMode testing_mode,
             Encryptor* encryptor,
             UnrecoverableErrorHandler* unrecoverable_error_handler,
             ReportUnrecoverableErrorFunction
                 report_unrecoverable_error_function);
 
   // Sign into sync with given credentials.
   // We do not verify the tokens given. After this call, the tokens are set
   // and the sync DB is open. True if successful, false if something
@@ skipping 172 matching lines @@
   virtual void OnServerConnectionEvent(
       const ServerConnectionEvent& event) OVERRIDE;
 
   // JsBackend implementation.
   virtual void SetJsEventHandler(
       const WeakHandle<JsEventHandler>& event_handler) OVERRIDE;
   virtual void ProcessJsMessage(
       const std::string& name, const JsArgList& args,
       const WeakHandle<JsReplyHandler>& reply_handler) OVERRIDE;
 
+  void SetSyncSchedulerForTest(scoped_ptr<SyncScheduler> scheduler);
+
  private:
   struct NotificationInfo {
     int total_count;
     std::string payload;
 
     NotificationInfo() : total_count(0) {}
 
     ~NotificationInfo() {}
 
     // Returned pointer owned by the caller.
@@ skipping 296 matching lines @@
 SyncManager::SyncManager(const std::string& name)
     : data_(new SyncInternal(name)) {}
 
 bool SyncManager::Init(
     const FilePath& database_location,
     const WeakHandle<JsEventHandler>& event_handler,
     const std::string& sync_server_and_path,
     int sync_server_port,
     bool use_ssl,
     const scoped_refptr<base::TaskRunner>& blocking_task_runner,
-    HttpPostProviderFactory* post_factory,
+    scoped_ptr<HttpPostProviderFactory> post_factory,
     const syncer::ModelSafeRoutingInfo& model_safe_routing_info,
     const std::vector<syncer::ModelSafeWorker*>& workers,
     syncer::ExtensionsActivityMonitor* extensions_activity_monitor,
     ChangeDelegate* change_delegate,
     const SyncCredentials& credentials,
-    syncer::SyncNotifier* sync_notifier,
+    scoped_ptr<syncer::SyncNotifier> sync_notifier,
     const std::string& restored_key_for_bootstrapping,
     TestingMode testing_mode,
     Encryptor* encryptor,
     UnrecoverableErrorHandler* unrecoverable_error_handler,
     ReportUnrecoverableErrorFunction report_unrecoverable_error_function) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(post_factory);
+  DCHECK(post_factory.get());
   DVLOG(1) << "SyncManager starting Init...";
   std::string server_string(sync_server_and_path);
   return data_->Init(database_location,
                      event_handler,
                      server_string,
                      sync_server_port,
                      use_ssl,
                      blocking_task_runner,
-                     post_factory,
+                     post_factory.Pass(),
                      model_safe_routing_info,
                      workers,
                      extensions_activity_monitor,
                      change_delegate,
                      credentials,
-                     sync_notifier,
+                     sync_notifier.Pass(),
                      restored_key_for_bootstrapping,
                      testing_mode,
                      encryptor,
                      unrecoverable_error_handler,
                      report_unrecoverable_error_function);
 }
 
 void SyncManager::UpdateCredentials(const SyncCredentials& credentials) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->UpdateCredentials(credentials);
 }
 
 void SyncManager::UpdateEnabledTypes(const ModelTypeSet& enabled_types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->UpdateEnabledTypes(enabled_types);
 }
 
 void SyncManager::ThrowUnrecoverableError() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ReadTransaction trans(FROM_HERE, GetUserShare());
   trans.GetWrappedTrans()->OnUnrecoverableError(
       FROM_HERE, "Simulating unrecoverable error for testing purposes.");
 }
 
 syncer::ModelTypeSet SyncManager::InitialSyncEndedTypes() {
   return data_->InitialSyncEndedTypes();
 }
 
+syncer::ModelTypeSet SyncManager::GetTypesWithEmptyProgressMarkerToken(
+    syncer::ModelTypeSet types) {
+  syncer::ModelTypeSet result;
+  for (syncer::ModelTypeSet::Iterator i = types.First();
+       i.Good(); i.Inc()) {
+    sync_pb::DataTypeProgressMarker marker;
+    GetUserShare()->directory->GetDownloadProgress(i.Get(), &marker);
+
+    if (marker.token().empty())
+      result.Put(i.Get());
+
+  }
+  return result;
+}
+
 void SyncManager::StartSyncingNormally(
     const syncer::ModelSafeRoutingInfo& routing_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->StartSyncingNormally(routing_info);
 }
 
 void SyncManager::SetEncryptionPassphrase(const std::string& passphrase,
                                           bool is_explicit) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->SetEncryptionPassphrase(passphrase, is_explicit);
@@ skipping 24 matching lines @@
 
 bool SyncManager::EncryptEverythingEnabledForTest() const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return trans.GetCryptographer()->encrypt_everything();
 }
 
 bool SyncManager::IsUsingExplicitPassphrase() {
   return data_ && data_->IsUsingExplicitPassphrase();
 }
 
-void SyncManager::RequestCleanupDisabledTypes(
-    const syncer::ModelSafeRoutingInfo& routing_info) {
+void SyncManager::ConfigureSyncer(
+    ConfigureReason reason,
+    const syncer::ModelTypeSet& types_to_config,
+    const syncer::ModelSafeRoutingInfo& new_routing_info,
+    const base::Closure& ready_task,
+    const base::Closure& retry_task) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (data_->scheduler()) {
-    data_->session_context()->set_routing_info(routing_info);
-    data_->scheduler()->CleanupDisabledTypes();
-  }
-}
+  DCHECK(!ready_task.is_null());
+  DCHECK(!retry_task.is_null());
 
-void SyncManager::RequestConfig(
-    const syncer::ModelSafeRoutingInfo& routing_info,
-    const ModelTypeSet& types, ConfigureReason reason) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  // TODO(zea): set this based on whether cryptographer has keystore
+  // encryption key or not (requires opening a transaction). crbug.com/129665.
+  ConfigurationParams::KeystoreKeyStatus keystore_key_status =
+      ConfigurationParams::KEYSTORE_KEY_UNNECESSARY;
+
+  ConfigurationParams params(GetSourceFromReason(reason),
+                             types_to_config,
+                             new_routing_info,
+                             keystore_key_status,
+                             ready_task);
+
   if (!data_->scheduler()) {
     LOG(INFO)
-        << "SyncManager::RequestConfig: bailing out because scheduler is "
-        << "null";
+        << "SyncManager::ConfigureSyncer: could not configure because "
+        << "scheduler is null";
+    params.ready_task.Run();
     return;
   }
-  StartConfigurationMode(base::Closure());
-  data_->session_context()->set_routing_info(routing_info);
-  data_->scheduler()->ScheduleConfiguration(types, GetSourceFromReason(reason));
-}
 
-void SyncManager::StartConfigurationMode(const base::Closure& callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (!data_->scheduler()) {
-    LOG(INFO)
-        << "SyncManager::StartConfigurationMode: could not start "
-        << "configuration mode because because scheduler is null";
-    return;
-  }
-  data_->scheduler()->Start(
-      syncer::SyncScheduler::CONFIGURATION_MODE, callback);
+  data_->scheduler()->Start(syncer::SyncScheduler::CONFIGURATION_MODE);
+  if (!data_->scheduler()->ScheduleConfiguration(params))
+    retry_task.Run();
+
 }
 
 bool SyncManager::SyncInternal::Init(
     const FilePath& database_location,
     const WeakHandle<JsEventHandler>& event_handler,
     const std::string& sync_server_and_path,
     int port,
     bool use_ssl,
     const scoped_refptr<base::TaskRunner>& blocking_task_runner,
-    HttpPostProviderFactory* post_factory,
+    scoped_ptr<HttpPostProviderFactory> post_factory,
     const syncer::ModelSafeRoutingInfo& model_safe_routing_info,
     const std::vector<syncer::ModelSafeWorker*>& workers,
     syncer::ExtensionsActivityMonitor* extensions_activity_monitor,
     ChangeDelegate* change_delegate,
     const SyncCredentials& credentials,
-    syncer::SyncNotifier* sync_notifier,
+    scoped_ptr<syncer::SyncNotifier> sync_notifier,
     const std::string& restored_key_for_bootstrapping,
     TestingMode testing_mode,
     Encryptor* encryptor,
     UnrecoverableErrorHandler* unrecoverable_error_handler,
     ReportUnrecoverableErrorFunction report_unrecoverable_error_function) {
   CHECK(!initialized_);
 
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG(1) << "Starting SyncInternal initialization.";
 
   weak_handle_this_ = MakeWeakHandle(weak_ptr_factory_.GetWeakPtr());
 
   blocking_task_runner_ = blocking_task_runner;
 
   change_delegate_ = change_delegate;
   testing_mode_ = testing_mode;
 
-  sync_notifier_.reset(sync_notifier);
+  sync_notifier_ = sync_notifier.Pass();
 
   AddObserver(&js_sync_manager_observer_);
   SetJsEventHandler(event_handler);
 
   AddObserver(&debug_info_event_listener_);
 
   database_path_ = database_location.Append(
       syncable::Directory::kSyncDatabaseFilename);
   encryptor_ = encryptor;
   unrecoverable_error_handler_ = unrecoverable_error_handler;
@@ skipping 13 matching lines @@
   }
 
   DCHECK(backing_store);
   share_.directory.reset(
       new syncable::Directory(encryptor_,
                               unrecoverable_error_handler_,
                               report_unrecoverable_error_function_,
                               backing_store));
 
   connection_manager_.reset(new SyncAPIServerConnectionManager(
-      sync_server_and_path, port, use_ssl, post_factory));
+      sync_server_and_path, port, use_ssl, post_factory.release()));
 
   net::NetworkChangeNotifier::AddIPAddressObserver(this);
   observing_ip_address_changes_ = true;
 
   connection_manager()->AddListener(this);
 
   // Test mode does not use a syncer context or syncer thread.
   if (testing_mode_ == NON_TEST) {
     // Build a SyncSessionContext and store the worker in it.
     DVLOG(1) << "Sync is bringing up SyncSessionContext.";
@@ skipping 11 matching lines @@
         &debug_info_event_listener_,
         &traffic_recorder_));
     session_context()->set_account_name(credentials.email);
     scheduler_.reset(new SyncScheduler(name_, session_context(), new Syncer()));
   }
 
   bool signed_in = SignIn(credentials);
 
   if (signed_in) {
     if (scheduler()) {
-      scheduler()->Start(
-          syncer::SyncScheduler::CONFIGURATION_MODE, base::Closure());
+      scheduler()->Start(syncer::SyncScheduler::CONFIGURATION_MODE);
     }
 
     initialized_ = true;
 
     // Cryptographer should only be accessed while holding a
     // transaction.  Grabbing the user share for the transaction
     // checks the initialization state, so this must come after
     // |initialized_| is set to true.
     ReadTransaction trans(FROM_HERE, GetUserShare());
     trans.GetCryptographer()->Bootstrap(restored_key_for_bootstrapping);
@@ skipping 153 matching lines @@
   allstatus_.SetCryptographerReady(cryptographer->is_ready());
   allstatus_.SetCryptoHasPendingKeys(cryptographer->has_pending_keys());
   debug_info_event_listener_.SetCryptographerReady(cryptographer->is_ready());
   debug_info_event_listener_.SetCrytographerHasPendingKeys(
       cryptographer->has_pending_keys());
 }
 
 void SyncManager::SyncInternal::StartSyncingNormally(
     const syncer::ModelSafeRoutingInfo& routing_info) {
   // Start the sync scheduler.
-  if (scheduler()) { // NULL during certain unittests.
+  if (scheduler()) {  // NULL during certain unittests.
+    // TODO(sync): We always want the newest set of routes when we switch back
+    // to normal mode. Figure out how to enforce set_routing_info is always
+    // appropriately set and that it's only modified when switching to normal
+    // mode.
     session_context()->set_routing_info(routing_info);
-    scheduler()->Start(SyncScheduler::NORMAL_MODE, base::Closure());
+    scheduler()->Start(SyncScheduler::NORMAL_MODE);
   }
 }
 
 bool SyncManager::SyncInternal::OpenDirectory() {
   DCHECK(!initialized_) << "Should only happen once";
 
   // Set before Open().
   change_observer_ =
       syncer::MakeWeakHandle(js_mutation_event_observer_.AsWeakPtr());
   WeakHandle<syncable::TransactionObserver> transaction_observer(
@@ skipping 1215 matching lines @@
 void SyncManager::SyncInternal::AddObserver(
     SyncManager::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void SyncManager::SyncInternal::RemoveObserver(
     SyncManager::Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
+void SyncManager::SyncInternal::SetSyncSchedulerForTest(
+    scoped_ptr<SyncScheduler> sync_scheduler) {
+  scheduler_ = sync_scheduler.Pass();
+}
+
 SyncStatus SyncManager::GetDetailedStatus() const {
   return data_->GetStatus();
 }
 
 void SyncManager::SaveChanges() {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->SaveChanges();
 }
 
 void SyncManager::SyncInternal::SaveChanges() {
@@ skipping 10 matching lines @@
   data_->UpdateCryptographerAndNigori(
       chrome_version,
       done_callback);
 }
 
 TimeDelta SyncManager::GetNudgeDelayTimeDelta(
     const ModelType& model_type) {
   return data_->GetNudgeDelayTimeDelta(model_type);
 }
 
+void SyncManager::SetSyncSchedulerForTest(scoped_ptr<SyncScheduler> scheduler) {
+  data_->SetSyncSchedulerForTest(scheduler.Pass());
+}
+
 syncer::ModelTypeSet SyncManager::GetEncryptedDataTypesForTest() const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return GetEncryptedTypes(&trans);
 }
 
 bool SyncManager::ReceivedExperiment(syncer::Experiments* experiments)
     const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   ReadNode node(&trans);
   if (node.InitByTagLookup(kNigoriTag) != syncer::BaseNode::INIT_OK) {
@@ skipping 69 matching lines @@
 bool InitialSyncEndedForTypes(syncer::ModelTypeSet types,
                               syncer::UserShare* share) {
   for (syncer::ModelTypeSet::Iterator i = types.First();
        i.Good(); i.Inc()) {
     if (!share->directory->initial_sync_ended_for_type(i.Get()))
       return false;
   }
   return true;
 }
 
-syncer::ModelTypeSet GetTypesWithEmptyProgressMarkerToken(
-    syncer::ModelTypeSet types,
-    syncer::UserShare* share) {
-  syncer::ModelTypeSet result;
-  for (syncer::ModelTypeSet::Iterator i = types.First();
-       i.Good(); i.Inc()) {
-    sync_pb::DataTypeProgressMarker marker;
-    share->directory->GetDownloadProgress(i.Get(), &marker);
-
-    if (marker.token().empty())
-      result.Put(i.Get());
-
-  }
-  return result;
-}
-
 }  // namespace syncer