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

sync/internal_api/sync_manager_impl.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/sync_manager_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 15 matching lines @@
 #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/internal_components_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 34 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 15 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,
             scoped_ptr<HttpPostProviderFactory> post_factory,
             const syncer::ModelSafeRoutingInfo& model_safe_routing_info,
             const std::vector<syncer::ModelSafeWorker*>& workers,
             syncer::ExtensionsActivityMonitor*
                 extensions_activity_monitor,
             SyncManager::ChangeDelegate* change_delegate,
             const SyncCredentials& credentials,
             scoped_ptr<syncer::SyncNotifier> sync_notifier,
             const std::string& restored_key_for_bootstrapping,
-            SyncManager::TestingMode testing_mode,
+            scoped_ptr<InternalComponentsFactory> internal_components_factory,
             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 190 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 170 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.
-  SyncManager::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 47 matching lines @@
        delay = TimeDelta::FromSeconds(
            syncer::kDefaultShortPollIntervalSeconds);
        break;
      case CUSTOM:
        switch (model_type) {
          case syncer::PREFERENCES:
            delay = TimeDelta::FromMilliseconds(
                kPreferencesNudgeDelayMilliseconds);
            break;
          case syncer::SESSIONS:
-           delay = core->scheduler()->sessions_commit_delay();
+           delay = core->scheduler()->GetSessionsCommitDelay();
            break;
          default:
            NOTREACHED();
        }
        break;
      default:
        NOTREACHED();
     }
     return delay;
   }
@@ skipping 10 matching lines @@
     bool use_ssl,
     const scoped_refptr<base::TaskRunner>& blocking_task_runner,
     scoped_ptr<HttpPostProviderFactory> post_factory,
     const syncer::ModelSafeRoutingInfo& model_safe_routing_info,
     const std::vector<syncer::ModelSafeWorker*>& workers,
     syncer::ExtensionsActivityMonitor* extensions_activity_monitor,
     SyncManager::ChangeDelegate* change_delegate,
     const SyncCredentials& credentials,
     scoped_ptr<syncer::SyncNotifier> sync_notifier,
     const std::string& restored_key_for_bootstrapping,
-    SyncManager::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.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.Pass(),
                      model_safe_routing_info,
                      workers,
                      extensions_activity_monitor,
                      change_delegate,
                      credentials,
                      sync_notifier.Pass(),
                      restored_key_for_bootstrapping,
-                     testing_mode,
+                     internal_components_factory.Pass(),
                      encryptor,
                      unrecoverable_error_handler,
                      report_unrecoverable_error_function);
 }
 
 void SyncManagerImpl::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,
     scoped_ptr<HttpPostProviderFactory> post_factory,
     const syncer::ModelSafeRoutingInfo& model_safe_routing_info,
     const std::vector<syncer::ModelSafeWorker*>& workers,
     syncer::ExtensionsActivityMonitor* extensions_activity_monitor,
     SyncManager::ChangeDelegate* change_delegate,
     const SyncCredentials& credentials,
     scoped_ptr<syncer::SyncNotifier> sync_notifier,
     const std::string& restored_key_for_bootstrapping,
-    SyncManager::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_ = 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;
   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);
+  scoped_ptr<syncable::DirectoryBackingStore> backing_store =
+      internal_components_factory->BuildDirectoryBackingStore(
+          credentials.email, absolute_db_path).Pass();
 
-  DCHECK(backing_store);
+  DCHECK(backing_store.get());
   share_.directory.reset(
       new syncable::Directory(encryptor_,
                               unrecoverable_error_handler_,
                               report_unrecoverable_error_function_,
-                              backing_store));
+                              backing_store.release()));
 
   connection_manager_.reset(new SyncAPIServerConnectionManager(
       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.";
-    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_ = 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_).Pass();
+  session_context()->set_account_name(credentials.email);
+  scheduler_ = internal_components_factory->BuildScheduler(
+      name_, session_context()).Pass();
 
   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 SyncManagerImpl::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 SyncManagerImpl::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 SyncManagerImpl::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 523 matching lines @@
   data_->RemoveObserver(observer);
 }
 
 void SyncManagerImpl::StopSyncingForShutdown(const base::Closure& callback) {
   data_->StopSyncingForShutdown(callback);
 }
 
 void SyncManagerImpl::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 SyncManagerImpl::ShutdownOnSyncThread() {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->ShutdownOnSyncThread();
 }
 
 void SyncManagerImpl::SyncInternal::ShutdownOnSyncThread() {
@@ skipping 52 matching lines @@
   if (!observing_ip_address_changes_) {
     DVLOG(1) << "IP address change dropped.";
     return;
   }
 
   OnIPAddressChangedImpl();
 }
 
 void SyncManagerImpl::SyncInternal::OnIPAddressChangedImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (scheduler())
-    scheduler()->OnConnectionStatusChange();
+  scheduler()->OnConnectionStatusChange();
 }
 
 void SyncManagerImpl::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 189 matching lines @@
                              it->second.original, existed_before, exists_now);
   }
 }
 
 SyncStatus SyncManagerImpl::SyncInternal::GetStatus() {
   return allstatus_.status();
 }
 
 void SyncManagerImpl::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 SyncManagerImpl::SyncInternal::GetNudgeDelayTimeDelta(
     const ModelType& model_type) {
   return NudgeStrategy::GetNudgeDelayTimeDelta(model_type, this);
 }
 
 void SyncManagerImpl::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 SyncManagerImpl::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 SyncManagerImpl::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 SyncManagerImpl::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 17 matching lines @@
 void SyncManagerImpl::SyncInternal::AddObserver(
     SyncManager::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void SyncManagerImpl::SyncInternal::RemoveObserver(
     SyncManager::Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void SyncManagerImpl::SyncInternal::SetSyncSchedulerForTest(
-    scoped_ptr<SyncScheduler> sync_scheduler) {
-  scheduler_ = sync_scheduler.Pass();
-}
-
 SyncStatus SyncManagerImpl::GetDetailedStatus() const {
   return data_->GetStatus();
 }
 
 void SyncManagerImpl::SaveChanges() {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->SaveChanges();
 }
 
 void SyncManagerImpl::SyncInternal::SaveChanges() {
@@ skipping 10 matching lines @@
   data_->UpdateCryptographerAndNigori(
       chrome_version,
       done_callback);
 }
 
 TimeDelta SyncManagerImpl::GetNudgeDelayTimeDelta(
     const ModelType& model_type) {
   return data_->GetNudgeDelayTimeDelta(model_type);
 }
 
-void SyncManagerImpl::SetSyncSchedulerForTest(
-    scoped_ptr<SyncScheduler> scheduler) {
-  data_->SetSyncSchedulerForTest(scheduler.Pass());
-}
-
 syncer::ModelTypeSet SyncManagerImpl::GetEncryptedDataTypesForTest() const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return GetEncryptedTypes(&trans);
 }
 
 bool SyncManagerImpl::ReceivedExperiment(
     syncer::Experiments* experiments) const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   ReadNode node(&trans);
   if (node.InitByTagLookup(kNigoriTag) != syncer::BaseNode::INIT_OK) {
@@ skipping 39 matching lines @@
 int SyncManagerImpl::GetDefaultNudgeDelay() {
   return kDefaultNudgeDelayMilliseconds;
 }
 
 // static.
 int SyncManagerImpl::GetPreferencesNudgeDelay() {
   return kPreferencesNudgeDelayMilliseconds;
 }
 
 }  // namespace syncer