sync: Remove SyncManager::TestingMode in favour of InternalComponentsFactory.

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/internal_components_factory_impl.h"

[Nicolas Zea, 2012/07/18 21:10:12]

this doesn't need to be the impl does it?

[tim (not reviewing), 2012/07/18 21:57:47]

Done.

 #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 32 matching lines @@
       return GetUpdatesCallerInfo::RECONFIGURATION;
     case syncer::CONFIGURE_REASON_MIGRATION:
       return GetUpdatesCallerInfo::MIGRATION;
     case syncer::CONFIGURE_REASON_NEW_CLIENT:
       return GetUpdatesCallerInfo::NEW_CLIENT;
     case syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE:
       return GetUpdatesCallerInfo::NEWLY_SUPPORTED_DATATYPE;
     default:
       NOTREACHED();
   }
-
   return GetUpdatesCallerInfo::UNKNOWN;
 }
 
 // The maximum number of times we will automatically overwrite the nigori node
 // because the encryption keys don't match (per chrome instantiation).
 static const int kNigoriOverwriteLimit = 10;
 
 } // namespace
 
 namespace syncer {
@@ skipping 18 matching lines @@
       public JsBackend,
       public SyncEngineEventListener,
       public ServerConnectionEventListener,
       public syncable::DirectoryChangeDelegate {
  public:
   explicit SyncInternal(const std::string& name)
       : name_(name),
         weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         change_delegate_(NULL),
         initialized_(false),
-        testing_mode_(NON_TEST),
         observing_ip_address_changes_(false),
         throttled_data_type_tracker_(&allstatus_),
         traffic_recorder_(kMaxMessagesToRecord, kMaxMessageSizeToRecord),
         encryptor_(NULL),
         unrecoverable_error_handler_(NULL),
         report_unrecoverable_error_function_(NULL),
-        created_on_loop_(MessageLoop::current()),
         nigori_overwrite_count_(0) {
     // Pre-fill |notification_info_map_|.
     for (int i = syncer::FIRST_REAL_MODEL_TYPE;
          i < syncer::MODEL_TYPE_COUNT; ++i) {
       notification_info_map_.insert(
           std::make_pair(syncer::ModelTypeFromInt(i), NotificationInfo()));
     }
 
     // Bind message handlers.
     BindJsMessageHandler(
@@ skipping 34 matching lines @@
             const scoped_refptr<base::TaskRunner>& blocking_task_runner,
             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,
             const std::string& restored_key_for_bootstrapping,
-            TestingMode testing_mode,
+            scoped_ptr<InternalComponentsFactory> internal_components_factory,

[Nicolas Zea, 2012/07/18 21:10:12]

see comment in SBH about whether this should take ownership or not.

             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
   // went wrong.
   bool SignIn(const SyncCredentials& credentials);
@@ skipping 381 matching lines @@
   // forwarded to the observer slightly later, at the TRANSACTION_ENDING
   // step by HandleTransactionEndingChangeEvent. The list is cleared in the
   // TRANSACTION_COMPLETE step by HandleTransactionCompleteChangeEvent.
   ChangeReorderBuffer change_buffers_[syncer::MODEL_TYPE_COUNT];
 
   SyncManager::ChangeDelegate* change_delegate_;
 
   // Set to true once Init has been called.
   bool initialized_;
 
-  // Controls the disabling of certain SyncManager features.
-  // Can be used to disable communication with the server and the use of an
-  // on-disk file for maintaining syncer state.
-  // TODO(117836): Clean up implementation of SyncManager unit tests.
-  TestingMode testing_mode_;
-
   bool observing_ip_address_changes_;
 
   // Map used to store the notification info to be displayed in
   // about:sync page.
   NotificationInfoMap notification_info_map_;
 
   // These are for interacting with chrome://sync-internals.
   JsMessageHandlerMap js_message_handlers_;
   WeakHandle<JsEventHandler> js_event_handler_;
   JsSyncManagerObserver js_sync_manager_observer_;
   JsMutationEventObserver js_mutation_event_observer_;
 
   syncer::ThrottledDataTypeTracker throttled_data_type_tracker_;
 
   // This is for keeping track of client events to send to the server.
   DebugInfoEventListener debug_info_event_listener_;
 
   syncer::TrafficRecorder traffic_recorder_;
 
   Encryptor* encryptor_;
   UnrecoverableErrorHandler* unrecoverable_error_handler_;
   ReportUnrecoverableErrorFunction report_unrecoverable_error_function_;
 
-  MessageLoop* const created_on_loop_;
-
   // The number of times we've automatically (i.e. not via SetPassphrase or
   // conflict resolver) updated the nigori's encryption keys in this chrome
   // instantiation.
   int nigori_overwrite_count_;
 };
 
 // A class to calculate nudge delays for types.
 class NudgeStrategy {
  public:
   static TimeDelta GetNudgeDelayTimeDelta(const ModelType& model_type,
@@ skipping 84 matching lines @@
     bool use_ssl,
     const scoped_refptr<base::TaskRunner>& blocking_task_runner,
     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,
     const std::string& restored_key_for_bootstrapping,
-    TestingMode testing_mode,
+    scoped_ptr<InternalComponentsFactory> internal_components_factory,
     Encryptor* encryptor,
     UnrecoverableErrorHandler* unrecoverable_error_handler,
     ReportUnrecoverableErrorFunction report_unrecoverable_error_function) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(post_factory);
   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,
                      model_safe_routing_info,
                      workers,
                      extensions_activity_monitor,
                      change_delegate,
                      credentials,
                      sync_notifier,
                      restored_key_for_bootstrapping,
-                     testing_mode,
+                     internal_components_factory.Pass(),
                      encryptor,
                      unrecoverable_error_handler,
                      report_unrecoverable_error_function);
 }
 
 void SyncManager::UpdateCredentials(const SyncCredentials& credentials) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->UpdateCredentials(credentials);
 }
 
@@ skipping 109 matching lines @@
     bool use_ssl,
     const scoped_refptr<base::TaskRunner>& blocking_task_runner,
     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,
     const std::string& restored_key_for_bootstrapping,
-    TestingMode testing_mode,
+    scoped_ptr<InternalComponentsFactory> internal_components_factory,
     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);
 
   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;
   report_unrecoverable_error_function_ = report_unrecoverable_error_function;
 
-  syncable::DirectoryBackingStore* backing_store = NULL;
-  if (testing_mode_ == TEST_IN_MEMORY) {
-    // TODO(tim): 117836. Use a factory or delegate to create this and don't
-    // depend on TEST_IN_MEMORY here.
-    backing_store =
-        new syncable::InMemoryDirectoryBackingStore(credentials.email);
-  } else {
-    FilePath absolute_db_path(database_path_);
-    file_util::AbsolutePath(&absolute_db_path);
-    backing_store = new syncable::OnDiskDirectoryBackingStore(
-        credentials.email, absolute_db_path);
-  }
+  FilePath absolute_db_path(database_path_);
+  file_util::AbsolutePath(&absolute_db_path);
+  syncable::DirectoryBackingStore* backing_store =
+      internal_components_factory->BuildDirectoryBackingStore(
+          credentials.email, absolute_db_path);
 
   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));
 
   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.";
-    std::vector<SyncEngineEventListener*> listeners;
-    listeners.push_back(&allstatus_);
-    listeners.push_back(this);
-    session_context_.reset(new SyncSessionContext(
-        connection_manager_.get(),
-        directory(),
-        model_safe_routing_info,
-        workers,
-        extensions_activity_monitor,
-        &throttled_data_type_tracker_,
-        listeners,
-        &debug_info_event_listener_,
-        &traffic_recorder_));
-    session_context()->set_account_name(credentials.email);
-    scheduler_.reset(new SyncScheduler(name_, session_context(), new Syncer()));
-  }
+  // Build a SyncSessionContext and store the worker in it.
+  DVLOG(1) << "Sync is bringing up SyncSessionContext.";
+  std::vector<SyncEngineEventListener*> listeners;
+  listeners.push_back(&allstatus_);
+  listeners.push_back(this);
+  session_context_.reset(internal_components_factory->BuildContext(
+      connection_manager_.get(),
+      directory(),
+      model_safe_routing_info,
+      workers,
+      extensions_activity_monitor,
+      &throttled_data_type_tracker_,
+      listeners,
+      &debug_info_event_listener_,
+      &traffic_recorder_));
+  session_context()->set_account_name(credentials.email);
+  scheduler_.reset(internal_components_factory->BuildScheduler(
+      name_, session_context()));
 
   bool success = SignIn(credentials);
 
   if (success) {
-    if (scheduler()) {
-      scheduler()->Start(syncer::SyncScheduler::CONFIGURATION_MODE);
-    }
+    scheduler()->Start(syncer::SyncScheduler::CONFIGURATION_MODE);
 
     initialized_ = true;
 
     // Unapplied datatypes (those that do not have initial sync ended set) get
     // re-downloaded during any configuration. But, it's possible for a datatype
     // to have a progress marker but not have initial sync ended yet, making
     // it a candidate for migration. This is a problem, as the DataTypeManager
     // does not support a migration while it's already in the middle of a
     // configuration. As a result, any partially synced datatype can stall the
     // DTM, waiting for the configuration to complete, which it never will due
@@ skipping 15 matching lines @@
 
   // Notify that initialization is complete. Note: This should be the last to
   // execute if |signed_in| is false. Reason being in that case we would
   // post a task to shutdown sync. But if this function posts any other tasks
   // on the UI thread and if shutdown wins then that tasks would execute on
   // a freed pointer. This is because UI thread is not shut down.
   FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                     OnInitializationComplete(
                         MakeWeakHandle(weak_ptr_factory_.GetWeakPtr()),
                         success));
-
-  if (!success && testing_mode_ == NON_TEST)
+  if (!success)
     return false;
 
   sync_notifier_->AddObserver(this);
 
   return success;
 }
 
 void SyncManager::SyncInternal::UpdateCryptographerAndNigori(
     const std::string& chrome_version,
     const base::Closure& done_callback) {
@@ skipping 61 matching lines @@
       Cryptographer::UpdateResult result = cryptographer->Update(nigori);
       if (result == Cryptographer::NEEDS_PASSPHRASE) {
         sync_pb::EncryptedData pending_keys;
         if (cryptographer->has_pending_keys())
           pending_keys = cryptographer->GetPendingKeys();
         FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                           OnPassphraseRequired(syncer::REASON_DECRYPTION,
                                                pending_keys));
       }
 
-
       // Add or update device information.
       bool contains_this_device = false;
       for (int i = 0; i < nigori.device_information_size(); ++i) {
         const sync_pb::DeviceInformation& device_information =
             nigori.device_information(i);
         if (device_information.cache_guid() == directory()->cache_guid()) {
           // Update the version number in case it changed due to an update.
           if (device_information.chrome_version() != chrome_version) {
             sync_pb::DeviceInformation* mutable_device_information =
                 nigori.mutable_device_information(i);
@@ skipping 47 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.
-    // 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);
-  }
+  // 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);
 }
 
 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(
       syncer::MakeWeakHandle(js_mutation_event_observer_.AsWeakPtr()));
@@ skipping 521 matching lines @@
   data_->RemoveObserver(observer);
 }
 
 void SyncManager::StopSyncingForShutdown(const base::Closure& callback) {
   data_->StopSyncingForShutdown(callback);
 }
 
 void SyncManager::SyncInternal::StopSyncingForShutdown(
     const base::Closure& callback) {
   DVLOG(2) << "StopSyncingForShutdown";
-  if (scheduler())  // May be null in tests.
-    scheduler()->RequestStop(callback);
-  else
-    created_on_loop_->PostTask(FROM_HERE, callback);
-
+  scheduler()->RequestStop(callback);
   if (connection_manager_.get())
     connection_manager_->TerminateAllIO();
 }
 
 void SyncManager::ShutdownOnSyncThread() {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->ShutdownOnSyncThread();
 }
 
 void SyncManager::SyncInternal::ShutdownOnSyncThread() {
@@ skipping 52 matching lines @@
   if (!observing_ip_address_changes_) {
     DVLOG(1) << "IP address change dropped.";
     return;
   }
 
   OnIPAddressChangedImpl();
 }
 
 void SyncManager::SyncInternal::OnIPAddressChangedImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (scheduler())
-    scheduler()->OnConnectionStatusChange();
+  scheduler()->OnConnectionStatusChange();
 }
 
 void SyncManager::SyncInternal::OnServerConnectionEvent(
     const ServerConnectionEvent& event) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (event.connection_code ==
       syncer::HttpResponse::SERVER_CONNECTION_OK) {
     FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                       OnConnectionStatusChange(CONNECTION_OK));
   }
@@ skipping 186 matching lines @@
                              it->second.original, existed_before, exists_now);
   }
 }
 
 SyncStatus SyncManager::SyncInternal::GetStatus() {
   return allstatus_.status();
 }
 
 void SyncManager::SyncInternal::RequestNudge(
     const tracked_objects::Location& location) {
-  if (scheduler()) {
-     scheduler()->ScheduleNudgeAsync(
-        TimeDelta::FromMilliseconds(0), syncer::NUDGE_SOURCE_LOCAL,
-        ModelTypeSet(), location);
-  }
+  scheduler()->ScheduleNudgeAsync(
+      TimeDelta::FromMilliseconds(0), syncer::NUDGE_SOURCE_LOCAL,
+      ModelTypeSet(), location);
 }
 
 TimeDelta SyncManager::SyncInternal::GetNudgeDelayTimeDelta(
     const ModelType& model_type) {
   return NudgeStrategy::GetNudgeDelayTimeDelta(model_type, this);
 }
 
 void SyncManager::SyncInternal::RequestNudgeForDataTypes(
     const tracked_objects::Location& nudge_location,
     ModelTypeSet types) {
@@ skipping 307 matching lines @@
        it != type_payloads.end(); ++it) {
     NotificationInfo* info = &notification_info_map_[it->first];
     info->total_count++;
     info->payload = it->second;
   }
 }
 
 void SyncManager::SyncInternal::OnNotificationsEnabled() {
   DVLOG(1) << "Notifications enabled";
   allstatus_.SetNotificationsEnabled(true);
-  if (scheduler()) {
-    scheduler()->set_notifications_enabled(true);
-  }
+  scheduler()->SetNotificationsEnabled(true);
+
   // TODO(akalin): Separate onNotificationStateChange into
   // enabled/disabled events.
   if (js_event_handler_.IsInitialized()) {
     DictionaryValue details;
     details.Set("enabled", Value::CreateBooleanValue(true));
     js_event_handler_.Call(FROM_HERE,
                            &JsEventHandler::HandleJsEvent,
                            "onNotificationStateChange",
                            JsEventDetails(&details));
   }
 }
 
 void SyncManager::SyncInternal::OnNotificationsDisabled(
     syncer::NotificationsDisabledReason reason) {
   DVLOG(1) << "Notifications disabled with reason "
            << syncer::NotificationsDisabledReasonToString(reason);
   allstatus_.SetNotificationsEnabled(false);
-  if (scheduler()) {
-    scheduler()->set_notifications_enabled(false);
-  }
+  scheduler()->SetNotificationsEnabled(false);
   if (js_event_handler_.IsInitialized()) {
     DictionaryValue details;
     details.Set("enabled", Value::CreateBooleanValue(false));
     js_event_handler_.Call(FROM_HERE,
                            &JsEventHandler::HandleJsEvent,
                            "onNotificationStateChange",
                            JsEventDetails(&details));
   }
   // TODO(akalin): Treat a CREDENTIALS_REJECTED state as an auth
   // error.
 }
 
 void SyncManager::SyncInternal::OnIncomingNotification(
     const syncer::ModelTypePayloadMap& type_payloads,
     syncer::IncomingNotificationSource source) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (source == syncer::LOCAL_NOTIFICATION) {
-    if (scheduler()) {
-      scheduler()->ScheduleNudgeWithPayloadsAsync(
-          TimeDelta::FromMilliseconds(kSyncRefreshDelayMsec),
-          syncer::NUDGE_SOURCE_LOCAL_REFRESH,
-          type_payloads, FROM_HERE);
-    }
+    scheduler()->ScheduleNudgeWithPayloadsAsync(
+        TimeDelta::FromMilliseconds(kSyncRefreshDelayMsec),
+        syncer::NUDGE_SOURCE_LOCAL_REFRESH,
+        type_payloads, FROM_HERE);
   } else if (!type_payloads.empty()) {
-    if (scheduler()) {
-      scheduler()->ScheduleNudgeWithPayloadsAsync(
-          TimeDelta::FromMilliseconds(kSyncSchedulerDelayMsec),
-          syncer::NUDGE_SOURCE_NOTIFICATION,
-          type_payloads, FROM_HERE);
-    }
+    scheduler()->ScheduleNudgeWithPayloadsAsync(
+        TimeDelta::FromMilliseconds(kSyncSchedulerDelayMsec),
+        syncer::NUDGE_SOURCE_NOTIFICATION,
+        type_payloads, FROM_HERE);
     allstatus_.IncrementNotificationsReceived();
     UpdateNotificationInfo(type_payloads);
     debug_info_event_listener_.OnIncomingNotification(type_payloads);
   } else {
     LOG(WARNING) << "Sync received notification without any type information.";
   }
 
   if (js_event_handler_.IsInitialized()) {
     DictionaryValue details;
     ListValue* changed_types = new ListValue();
@@ skipping 146 matching lines @@
                               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;
 }
 
 }  // namespace syncer