[Sync] Refactor sync manager into interface.

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/public/sync_manager.h"
+#include "sync/internal_api/sync_manager_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/observer_list.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "net/base/network_change_notifier.h"
 #include "sync/engine/all_status.h"
 #include "sync/engine/net/server_connection_manager.h"
 #include "sync/engine/sync_scheduler.h"
 #include "sync/engine/syncer_types.h"
 #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 15 matching lines @@
 #include "sync/util/cryptographer.h"
 #include "sync/util/get_session_name.h"
 #include "sync/util/time.h"
 
 using base::TimeDelta;
 using sync_pb::GetUpdatesCallerInfo;
 
 namespace {
 
 // Delays for syncer nudges.
+static const int kDefaultNudgeDelayMilliseconds = 200;
+static const int kPreferencesNudgeDelayMilliseconds = 2000;
 static const int kSyncRefreshDelayMsec = 500;
 static const int kSyncSchedulerDelayMsec = 250;
 
 GetUpdatesCallerInfo::GetUpdatesSource GetSourceFromReason(
     syncer::ConfigureReason reason) {
   switch (reason) {
     case syncer::CONFIGURE_REASON_RECONFIGURATION:
       return GetUpdatesCallerInfo::RECONFIGURATION;
     case syncer::CONFIGURE_REASON_MIGRATION:
       return GetUpdatesCallerInfo::MIGRATION;
@@ skipping 13 matching lines @@
 static const int kNigoriOverwriteLimit = 10;
 
 } // namespace
 
 namespace syncer {
 
 using sessions::SyncSessionContext;
 using syncable::ImmutableWriteTransactionInfo;
 using syncable::SPECIFICS;
 
-const int SyncManager::kDefaultNudgeDelayMilliseconds = 200;
-const int SyncManager::kPreferencesNudgeDelayMilliseconds = 2000;
-
 // Maximum count and size for traffic recorder.
 const unsigned int kMaxMessagesToRecord = 10;
 const unsigned int kMaxMessageSizeToRecord = 5 * 1024;
 
 //////////////////////////////////////////////////////////////////////////
-// SyncManager's implementation: SyncManager::SyncInternal
-class SyncManager::SyncInternal
+// SyncManager's implementation: SyncManagerImpl::SyncInternal
+class SyncManagerImpl::SyncInternal
     : public net::NetworkChangeNotifier::IPAddressObserver,
       public syncer::Cryptographer::Observer,
       public syncer::SyncNotifierObserver,
       public JsBackend,
       public SyncEngineEventListener,
       public ServerConnectionEventListener,
       public syncable::DirectoryChangeDelegate {
  public:
   explicit SyncInternal(const std::string& name)
       : name_(name),
@@ skipping 12 matching lines @@
     // 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(
         "getNotificationState",
-        &SyncManager::SyncInternal::GetNotificationState);
+        &SyncManagerImpl::SyncInternal::GetNotificationState);
     BindJsMessageHandler(
         "getNotificationInfo",
-        &SyncManager::SyncInternal::GetNotificationInfo);
+        &SyncManagerImpl::SyncInternal::GetNotificationInfo);
     BindJsMessageHandler(
         "getRootNodeDetails",
-        &SyncManager::SyncInternal::GetRootNodeDetails);
+        &SyncManagerImpl::SyncInternal::GetRootNodeDetails);
     BindJsMessageHandler(
         "getNodeSummariesById",
-        &SyncManager::SyncInternal::GetNodeSummariesById);
+        &SyncManagerImpl::SyncInternal::GetNodeSummariesById);
     BindJsMessageHandler(
         "getNodeDetailsById",
-        &SyncManager::SyncInternal::GetNodeDetailsById);
+        &SyncManagerImpl::SyncInternal::GetNodeDetailsById);
     BindJsMessageHandler(
         "getAllNodes",
-        &SyncManager::SyncInternal::GetAllNodes);
+        &SyncManagerImpl::SyncInternal::GetAllNodes);
     BindJsMessageHandler(
         "getChildNodeIds",
-        &SyncManager::SyncInternal::GetChildNodeIds);
+        &SyncManagerImpl::SyncInternal::GetChildNodeIds);
     BindJsMessageHandler(
         "getClientServerTraffic",
-        &SyncManager::SyncInternal::GetClientServerTraffic);
+        &SyncManagerImpl::SyncInternal::GetClientServerTraffic);
   }
 
   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 107 matching lines @@
       bool encrypt_everything) OVERRIDE;
 
   // SyncNotifierObserver implementation.
   virtual void OnNotificationsEnabled() OVERRIDE;
   virtual void OnNotificationsDisabled(
       syncer::NotificationsDisabledReason reason) OVERRIDE;
   virtual void OnIncomingNotification(
       const syncer::ModelTypePayloadMap& type_payloads,
       syncer::IncomingNotificationSource source) OVERRIDE;
 
-  void AddObserver(SyncManager::Observer* observer);
-  void RemoveObserver(SyncManager::Observer* observer);
+  void AddObserver(SyncManagerImpl::Observer* observer);

[tim (not reviewing), 2012/07/16 21:25:30]

SyncManager::Observer is still correct (here and all over this file).

[Nicolas Zea, 2012/07/16 21:54:23]

Done.

+  void RemoveObserver(SyncManagerImpl::Observer* observer);
 
   // Accessors for the private members.
   syncable::Directory* directory() { return share_.directory.get(); }
   SyncAPIServerConnectionManager* connection_manager() {
     return connection_manager_.get();
   }
   SyncSessionContext* session_context() { return session_context_.get(); }
   SyncScheduler* scheduler() const { return scheduler_.get(); }
   UserShare* GetUserShare() {
     DCHECK(initialized_);
@@ skipping 11 matching lines @@
   void RequestNudge(const tracked_objects::Location& nudge_location);
 
   void RequestNudgeForDataTypes(
       const tracked_objects::Location& nudge_location,
       ModelTypeSet type);
 
   TimeDelta GetNudgeDelayTimeDelta(const ModelType& model_type);
 
   void NotifyCryptographerState(Cryptographer* cryptographer);
 
-  // See SyncManager::Shutdown* for information.
+  // See SyncManagerImpl::Shutdown* for information.

[tim (not reviewing), 2012/07/16 21:25:30]

The comments are actually @ SyncManager::Shutdown.

[Nicolas Zea, 2012/07/16 21:54:23]

Done.

   void StopSyncingForShutdown(const base::Closure& callback);
   void ShutdownOnSyncThread();
 
   // If this is a deletion for a password, sets the legacy
   // ExtraPasswordChangeRecordData field of |buffer|. Otherwise sets
   // |buffer|'s specifics field to contain the unencrypted data.
   void SetExtraChangeRecordData(int64 id,
                                 syncer::ModelType type,
                                 ChangeReorderBuffer* buffer,
                                 Cryptographer* cryptographer,
@@ skipping 53 matching lines @@
     DictionaryValue* ToValue() const {
       DictionaryValue* value = new DictionaryValue();
       value->SetInteger("totalCount", total_count);
       value->SetString("payload", payload);
       return value;
     }
   };
 
   typedef std::map<syncer::ModelType, NotificationInfo> NotificationInfoMap;
   typedef JsArgList
-      (SyncManager::SyncInternal::*UnboundJsMessageHandler)(const JsArgList&);
+      (SyncManagerImpl::SyncInternal::*UnboundJsMessageHandler)(
+           const JsArgList&);
   typedef base::Callback<JsArgList(const JsArgList&)> JsMessageHandler;
   typedef std::map<std::string, JsMessageHandler> JsMessageHandlerMap;
 
   // Internal callback of UpdateCryptographerAndNigoriCallback.
   void UpdateCryptographerAndNigoriCallback(
       const std::string& chrome_version,
       const base::Closure& done_callback,
       const std::string& session_name);
 
   // Determine if the parents or predecessors differ between the old and new
@@ skipping 112 matching lines @@
   // |blocking_task_runner| is a TaskRunner to be used for tasks that
   // may block on disk I/O.
   scoped_refptr<base::TaskRunner> blocking_task_runner_;
 
   // We give a handle to share_ to clients of the API for use when constructing
   // any transaction type.
   UserShare share_;
 
   // This can be called from any thread, but only between calls to
   // OpenDirectory() and ShutdownOnSyncThread().
-  syncer::WeakHandle<SyncManager::ChangeObserver> change_observer_;
+  syncer::WeakHandle<SyncManagerImpl::ChangeObserver> change_observer_;

[tim (not reviewing), 2012/07/16 21:25:30]

SyncManager::ChangeObserver is still correct (here and all over this file).

[Nicolas Zea, 2012/07/16 21:54:23]

Done.

 
-  ObserverList<SyncManager::Observer> observers_;
+  ObserverList<SyncManagerImpl::Observer> observers_;
 
   // The ServerConnectionManager used to abstract communication between the
   // client (the Syncer) and the sync server.
   scoped_ptr<SyncAPIServerConnectionManager> connection_manager_;
 
   // A container of various bits of information used by the SyncScheduler to
   // create SyncSessions.  Must outlive the SyncScheduler.
   scoped_ptr<SyncSessionContext> session_context_;
 
   // The scheduler that runs the Syncer. Needs to be explicitly
   // Start()ed.
   scoped_ptr<SyncScheduler> scheduler_;
 
   // The SyncNotifier which notifies us when updates need to be downloaded.
   scoped_ptr<syncer::SyncNotifier> sync_notifier_;
 
   // A multi-purpose status watch object that aggregates stats from various
   // sync components.
   AllStatus allstatus_;
 
   // Each element of this array is a store of change records produced by
   // HandleChangeEvent during the CALCULATE_CHANGES step.  The changes are
   // segregated by model type, and are stored here to be processed and
   // 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_;
+  SyncManagerImpl::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_;
 
@@ skipping 25 matching lines @@
   // 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,
-                                          SyncManager::SyncInternal* core) {
+                                          SyncManagerImpl::SyncInternal* core) {
     NudgeDelayStrategy delay_type = GetNudgeDelayStrategy(model_type);
     return GetNudgeDelayTimeDeltaFromType(delay_type,
                                           model_type,
                                           core);
   }
 
  private:
   // Possible types of nudge delay for datatypes.
   // Note: These are just hints. If a sync happens then all dirty entries
   // would be committed as part of the sync.
@@ skipping 16 matching lines @@
      case syncer::PREFERENCES:
      case syncer::SESSIONS:
        return CUSTOM;
      default:
        return IMMEDIATE;
     }
   }
 
   static TimeDelta GetNudgeDelayTimeDeltaFromType(
       const NudgeDelayStrategy& delay_type, const ModelType& model_type,
-      const SyncManager::SyncInternal* core) {
+      const SyncManagerImpl::SyncInternal* core) {
     CHECK(core);
     TimeDelta delay = TimeDelta::FromMilliseconds(
-       SyncManager::kDefaultNudgeDelayMilliseconds);
+       kDefaultNudgeDelayMilliseconds);
     switch (delay_type) {
      case IMMEDIATE:
        delay = TimeDelta::FromMilliseconds(
-           SyncManager::kDefaultNudgeDelayMilliseconds);
+           kDefaultNudgeDelayMilliseconds);
        break;
      case ACCOMPANY_ONLY:
        delay = TimeDelta::FromSeconds(
            syncer::kDefaultShortPollIntervalSeconds);
        break;
      case CUSTOM:
        switch (model_type) {
          case syncer::PREFERENCES:
            delay = TimeDelta::FromMilliseconds(
-               SyncManager::kPreferencesNudgeDelayMilliseconds);
+               kPreferencesNudgeDelayMilliseconds);
            break;
          case syncer::SESSIONS:
            delay = core->scheduler()->sessions_commit_delay();
            break;
          default:
            NOTREACHED();
        }
        break;
      default:
        NOTREACHED();
     }
     return delay;
   }
 };
 
-SyncManager::ChangeDelegate::~ChangeDelegate() {}
-
-SyncManager::ChangeObserver::~ChangeObserver() {}
-
-SyncManager::Observer::~Observer() {}
-
-SyncManager::SyncManager(const std::string& name)
+SyncManagerImpl::SyncManagerImpl(const std::string& name)
     : data_(new SyncInternal(name)) {}
 
-bool SyncManager::Init(
+bool SyncManagerImpl::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) {
+void SyncManagerImpl::UpdateCredentials(const SyncCredentials& credentials) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->UpdateCredentials(credentials);
 }
 
-void SyncManager::UpdateEnabledTypes(const ModelTypeSet& enabled_types) {
+void SyncManagerImpl::UpdateEnabledTypes(const ModelTypeSet& enabled_types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->UpdateEnabledTypes(enabled_types);
 }
 
-void SyncManager::ThrowUnrecoverableError() {
+void SyncManagerImpl::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() {
+syncer::ModelTypeSet SyncManagerImpl::InitialSyncEndedTypes() {
   return data_->InitialSyncEndedTypes();
 }
 
-syncer::ModelTypeSet SyncManager::GetTypesWithEmptyProgressMarkerToken(
+syncer::ModelTypeSet SyncManagerImpl::GetTypesWithEmptyProgressMarkerToken(
     syncer::ModelTypeSet types) {
   return data_->GetTypesWithEmptyProgressMarkerToken(types);
 }
 
-bool SyncManager::PurgePartiallySyncedTypes() {
+bool SyncManagerImpl::PurgePartiallySyncedTypes() {
   return data_->PurgePartiallySyncedTypes();
 }
 
-void SyncManager::StartSyncingNormally(
+void SyncManagerImpl::StartSyncingNormally(
     const syncer::ModelSafeRoutingInfo& routing_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->StartSyncingNormally(routing_info);
 }
 
-void SyncManager::SetEncryptionPassphrase(const std::string& passphrase,
+void SyncManagerImpl::SetEncryptionPassphrase(const std::string& passphrase,
                                           bool is_explicit) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->SetEncryptionPassphrase(passphrase, is_explicit);
 }
 
-void SyncManager::SetDecryptionPassphrase(const std::string& passphrase) {
+void SyncManagerImpl::SetDecryptionPassphrase(const std::string& passphrase) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->SetDecryptionPassphrase(passphrase);
 }
 
-void SyncManager::EnableEncryptEverything() {
+void SyncManagerImpl::EnableEncryptEverything() {
   DCHECK(thread_checker_.CalledOnValidThread());
   {
     // Update the cryptographer to know we're now encrypting everything.
     WriteTransaction trans(FROM_HERE, GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     // Only set encrypt everything if we know we can encrypt. This allows the
     // user to cancel encryption if they have forgotten their passphrase.
     if (cryptographer->is_ready())
       cryptographer->set_encrypt_everything();
   }
 
   // Reads from cryptographer so will automatically encrypt all
   // datatypes and update the nigori node as necessary. Will trigger
   // OnPassphraseRequired if necessary.
   data_->RefreshEncryption();
 }
 
-bool SyncManager::EncryptEverythingEnabledForTest() const {
+bool SyncManagerImpl::EncryptEverythingEnabledForTest() const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return trans.GetCryptographer()->encrypt_everything();
 }
 
-bool SyncManager::IsUsingExplicitPassphrase() {
+bool SyncManagerImpl::IsUsingExplicitPassphrase() {
   return data_ && data_->IsUsingExplicitPassphrase();
 }
 
-void SyncManager::ConfigureSyncer(
+void SyncManagerImpl::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());
   DCHECK(!ready_task.is_null());
   DCHECK(!retry_task.is_null());
 
   // 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::ConfigureSyncer: could not configure because "
+        << "SyncManagerImpl::ConfigureSyncer: could not configure because "
         << "scheduler is null";
     params.ready_task.Run();
     return;
   }
 
   data_->scheduler()->Start(syncer::SyncScheduler::CONFIGURATION_MODE);
   if (!data_->scheduler()->ScheduleConfiguration(params))
     retry_task.Run();
 
 }
 
-bool SyncManager::SyncInternal::Init(
+bool SyncManagerImpl::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 44 matching lines @@
     ReadTransaction trans(FROM_HERE, GetUserShare());
     trans.GetCryptographer()->Bootstrap(restored_key_for_bootstrapping);
     trans.GetCryptographer()->AddObserver(this);
   }
 
   // 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_,
+  FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,
                     OnInitializationComplete(
                         MakeWeakHandle(weak_ptr_factory_.GetWeakPtr()),
                         success));
 
   if (!success && testing_mode_ == NON_TEST)
     return false;
 
   sync_notifier_->AddObserver(this);
 
   return success;
 }
 
-void SyncManager::SyncInternal::UpdateCryptographerAndNigori(
+void SyncManagerImpl::SyncInternal::UpdateCryptographerAndNigori(
     const std::string& chrome_version,
     const base::Closure& done_callback) {
   DCHECK(initialized_);
   syncer::GetSessionName(
       blocking_task_runner_,
       base::Bind(
-          &SyncManager::SyncInternal::UpdateCryptographerAndNigoriCallback,
+          &SyncManagerImpl::SyncInternal::UpdateCryptographerAndNigoriCallback,
           weak_ptr_factory_.GetWeakPtr(),
           chrome_version,
           done_callback));
 }
 
-void SyncManager::SyncInternal::UpdateNigoriEncryptionState(
+void SyncManagerImpl::SyncInternal::UpdateNigoriEncryptionState(
     Cryptographer* cryptographer,
     WriteNode* nigori_node) {
   DCHECK(nigori_node);
   sync_pb::NigoriSpecifics nigori = nigori_node->GetNigoriSpecifics();
 
   if (cryptographer->is_ready() &&
       nigori_overwrite_count_ < kNigoriOverwriteLimit) {
     // Does not modify the encrypted blob if the unencrypted data already
     // matches what is about to be written.
     sync_pb::EncryptedData original_keys = nigori.encrypted();
@@ skipping 13 matching lines @@
     // Note: we don't try to set using_explicit_passphrase here since if that
     // is lost the user can always set it again. The main point is to preserve
     // the encryption keys so all data remains decryptable.
   }
   cryptographer->UpdateNigoriFromEncryptedTypes(&nigori);
 
   // If nothing has changed, this is a no-op.
   nigori_node->SetNigoriSpecifics(nigori);
 }
 
-void SyncManager::SyncInternal::UpdateCryptographerAndNigoriCallback(
+void SyncManagerImpl::SyncInternal::UpdateCryptographerAndNigoriCallback(
     const std::string& chrome_version,
     const base::Closure& done_callback,
     const std::string& session_name) {
   if (!directory()->initial_sync_ended_for_type(syncer::NIGORI)) {
     done_callback.Run();  // Should only happen during first time sync.
     return;
   }
 
   bool success = false;
   {
     WriteTransaction trans(FROM_HERE, GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     WriteNode node(&trans);
 
     if (node.InitByTagLookup(kNigoriTag) == syncer::BaseNode::INIT_OK) {
       sync_pb::NigoriSpecifics nigori(node.GetNigoriSpecifics());
       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_,
+        FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,

[tim (not reviewing), 2012/07/16 21:25:30]

SyncManager::Observer is still correct.

[Nicolas Zea, 2012/07/16 21:54:23]

Done.

                           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);
@@ skipping 38 matching lines @@
     } else {
       NOTREACHED();
     }
   }
 
   if (success)
     RefreshEncryption();
   done_callback.Run();
 }
 
-void SyncManager::SyncInternal::NotifyCryptographerState(
+void SyncManagerImpl::SyncInternal::NotifyCryptographerState(
     Cryptographer * cryptographer) {
   // TODO(lipalani): Explore the possibility of hooking this up to
-  // SyncManager::Observer and making |AllStatus| a listener for that.
+  // SyncManagerImpl::Observer and making |AllStatus| a listener for that.
   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(
+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);
   }
 }
 
-bool SyncManager::SyncInternal::OpenDirectory() {
+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()));
 
   syncable::DirOpenResult open_result = syncable::NOT_INITIALIZED;
   open_result = directory()->Open(username_for_share(), this,
                                   transaction_observer);
   if (open_result != syncable::OPENED) {
     LOG(ERROR) << "Could not open share for:" << username_for_share();
     return false;
   }
 
   connection_manager()->set_client_id(directory()->cache_guid());
   return true;
 }
 
-bool SyncManager::SyncInternal::SignIn(const SyncCredentials& credentials) {
+bool SyncManagerImpl::SyncInternal::SignIn(const SyncCredentials& credentials) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(share_.name.empty());
   share_.name = credentials.email;
 
   DVLOG(1) << "Signing in user: " << username_for_share();
   if (!OpenDirectory())
     return false;
 
   // Retrieve and set the sync notifier state. This should be done
   // only after OpenDirectory is called.
   std::string unique_id = directory()->cache_guid();
   std::string state = directory()->GetNotificationState();
   DVLOG(1) << "Read notification unique ID: " << unique_id;
   if (VLOG_IS_ON(1)) {
     std::string encoded_state;
     base::Base64Encode(state, &encoded_state);
     DVLOG(1) << "Read notification state: " << encoded_state;
   }
   allstatus_.SetUniqueId(unique_id);
   sync_notifier_->SetUniqueId(unique_id);
   // TODO(tim): Remove once invalidation state has been migrated to new
   // InvalidationStateTracker store. Bug 124140.
   sync_notifier_->SetStateDeprecated(state);
 
   UpdateCredentials(credentials);
   return true;
 }
 
-bool SyncManager::SyncInternal::PurgePartiallySyncedTypes() {
+bool SyncManagerImpl::SyncInternal::PurgePartiallySyncedTypes() {
   syncer::ModelTypeSet partially_synced_types =
       syncer::ModelTypeSet::All();
   partially_synced_types.RemoveAll(InitialSyncEndedTypes());
   partially_synced_types.RemoveAll(GetTypesWithEmptyProgressMarkerToken(
       syncer::ModelTypeSet::All()));
 
   UMA_HISTOGRAM_COUNTS("Sync.PartiallySyncedTypes",
                        partially_synced_types.Size());
   if (partially_synced_types.Empty())
     return true;
   return directory()->PurgeEntriesWithTypeIn(partially_synced_types);
 }
 
-void SyncManager::SyncInternal::UpdateCredentials(
+void SyncManagerImpl::SyncInternal::UpdateCredentials(
     const SyncCredentials& credentials) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(credentials.email, share_.name);
   DCHECK(!credentials.email.empty());
   DCHECK(!credentials.sync_token.empty());
 
   observing_ip_address_changes_ = true;
   if (connection_manager()->set_auth_token(credentials.sync_token)) {
     sync_notifier_->UpdateCredentials(
         credentials.email, credentials.sync_token);
     if (initialized_ && scheduler()) {
       scheduler()->OnCredentialsUpdated();
     }
   }
 }
 
-void SyncManager::SyncInternal::UpdateEnabledTypes(
+void SyncManagerImpl::SyncInternal::UpdateEnabledTypes(
     const ModelTypeSet& enabled_types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   sync_notifier_->UpdateEnabledTypes(enabled_types);
 }
 
-void SyncManager::SyncInternal::SetEncryptionPassphrase(
+void SyncManagerImpl::SyncInternal::SetEncryptionPassphrase(
     const std::string& passphrase,
     bool is_explicit) {
   // We do not accept empty passphrases.
   if (passphrase.empty()) {
     NOTREACHED() << "Cannot encrypt with an empty passphrase.";
     return;
   }
 
   // All accesses to the cryptographer are protected by a transaction.
   WriteTransaction trans(FROM_HERE, GetUserShare());
@@ skipping 94 matching lines @@
   DVLOG_IF(1, !success)
       << "Failure in SetEncryptionPassphrase; notifying and returning.";
   DVLOG_IF(1, success)
       << "Successfully set encryption passphrase; updating nigori and "
          "reencrypting.";
 
   FinishSetPassphrase(
       success, bootstrap_token, is_explicit, &trans, &node);
 }
 
-void SyncManager::SyncInternal::SetDecryptionPassphrase(
+void SyncManagerImpl::SyncInternal::SetDecryptionPassphrase(
     const std::string& passphrase) {
   // We do not accept empty passphrases.
   if (passphrase.empty()) {
     NOTREACHED() << "Cannot decrypt with an empty passphrase.";
     return;
   }
 
   // All accesses to the cryptographer are protected by a transaction.
   WriteTransaction trans(FROM_HERE, GetUserShare());
   Cryptographer* cryptographer = trans.GetCryptographer();
@@ skipping 121 matching lines @@
       << "Successfully set decryption passphrase; updating nigori and "
          "reencrypting.";
 
   FinishSetPassphrase(success,
                       bootstrap_token,
                       nigori_has_explicit_passphrase,
                       &trans,
                       &node);
 }
 
-void SyncManager::SyncInternal::FinishSetPassphrase(
+void SyncManagerImpl::SyncInternal::FinishSetPassphrase(
     bool success,
     const std::string& bootstrap_token,
     bool is_explicit,
     WriteTransaction* trans,
     WriteNode* nigori_node) {
   Cryptographer* cryptographer = trans->GetCryptographer();
   NotifyCryptographerState(cryptographer);
 
   // It's possible we need to change the bootstrap token even if we failed to
   // set the passphrase (for example if we need to preserve the new GAIA
   // passphrase).
   if (!bootstrap_token.empty()) {
     DVLOG(1) << "Bootstrap token updated.";
-    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
+    FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,
                       OnBootstrapTokenUpdated(bootstrap_token));
   }
 
   if (!success) {
     if (cryptographer->is_ready()) {
       LOG(ERROR) << "Attempt to change passphrase failed while cryptographer "
                  << "was ready.";
     } else if (cryptographer->has_pending_keys()) {
-      FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
+      FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,
                         OnPassphraseRequired(syncer::REASON_DECRYPTION,
                                              cryptographer->GetPendingKeys()));
     } else {
-      FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
+      FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,
                         OnPassphraseRequired(syncer::REASON_ENCRYPTION,
                                              sync_pb::EncryptedData()));
     }
     return;
   }
 
-  FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
+  FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,
                     OnPassphraseAccepted());
   DCHECK(cryptographer->is_ready());
 
   // TODO(tim): Bug 58231. It would be nice if setting a passphrase didn't
   // require messing with the Nigori node, because we can't set a passphrase
   // until download conditions are met vs Cryptographer init.  It seems like
   // it's safe to defer this work.
   sync_pb::NigoriSpecifics specifics(nigori_node->GetNigoriSpecifics());
   // Does not modify specifics.encrypted() if the original decrypted data was
   // the same.
   if (!cryptographer->GetKeys(specifics.mutable_encrypted())) {
     NOTREACHED();
     return;
   }
   specifics.set_using_explicit_passphrase(is_explicit);
   nigori_node->SetNigoriSpecifics(specifics);
 
   // Does nothing if everything is already encrypted or the cryptographer has
   // pending keys.
   ReEncryptEverything(trans);
 }
 
-bool SyncManager::SyncInternal::IsUsingExplicitPassphrase() {
+bool SyncManagerImpl::SyncInternal::IsUsingExplicitPassphrase() {
   ReadTransaction trans(FROM_HERE, &share_);
   ReadNode node(&trans);
   if (node.InitByTagLookup(kNigoriTag) != syncer::BaseNode::INIT_OK) {
     // TODO(albertb): Plumb an UnrecoverableError all the way back to the PSS.
     NOTREACHED();
     return false;
   }
 
   return node.GetNigoriSpecifics().using_explicit_passphrase();
 }
 
-void SyncManager::SyncInternal::RefreshEncryption() {
+void SyncManagerImpl::SyncInternal::RefreshEncryption() {
   DCHECK(initialized_);
 
   WriteTransaction trans(FROM_HERE, GetUserShare());
   WriteNode node(&trans);
   if (node.InitByTagLookup(kNigoriTag) != syncer::BaseNode::INIT_OK) {
     NOTREACHED() << "Unable to set encrypted datatypes because Nigori node not "
                  << "found.";
     return;
   }
 
   Cryptographer* cryptographer = trans.GetCryptographer();
 
   if (!cryptographer->is_ready()) {
     DVLOG(1) << "Attempting to encrypt datatypes when cryptographer not "
              << "initialized, prompting for passphrase.";
     // TODO(zea): this isn't really decryption, but that's the only way we have
     // to prompt the user for a passsphrase. See http://crbug.com/91379.
     sync_pb::EncryptedData pending_keys;
     if (cryptographer->has_pending_keys())
       pending_keys = cryptographer->GetPendingKeys();
-    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
+    FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,
                       OnPassphraseRequired(syncer::REASON_DECRYPTION,
                                            pending_keys));
     return;
   }
 
   UpdateNigoriEncryptionState(cryptographer, &node);
 
   allstatus_.SetEncryptedTypes(cryptographer->GetEncryptedTypes());
 
   // We reencrypt everything regardless of whether the set of encrypted
   // types changed to ensure that any stray unencrypted entries are overwritten.
   ReEncryptEverything(&trans);
 }
 
 // This function iterates over all encrypted types.  There are many scenarios in
 // which data for some or all types is not currently available.  In that case,
 // the lookup of the root node will fail and we will skip encryption for that
 // type.
-void SyncManager::SyncInternal::ReEncryptEverything(WriteTransaction* trans) {
+void SyncManagerImpl::SyncInternal::ReEncryptEverything(
+      WriteTransaction* trans) {
   Cryptographer* cryptographer = trans->GetCryptographer();
   if (!cryptographer || !cryptographer->is_ready())
     return;
   syncer::ModelTypeSet encrypted_types = GetEncryptedTypes(trans);
   for (syncer::ModelTypeSet::Iterator iter = encrypted_types.First();
        iter.Good(); iter.Inc()) {
     if (iter.Get() == syncer::PASSWORDS || iter.Get() == syncer::NIGORI)
       continue; // These types handle encryption differently.
 
     ReadNode type_root(trans);
@@ skipping 40 matching lines @@
       if (child.InitByIdLookup(child_id) != syncer::BaseNode::INIT_OK) {
         NOTREACHED();
         return;
       }
       child.SetPasswordSpecifics(child.GetPasswordSpecifics());
       child_id = child.GetSuccessorId();
     }
   }
 
   // NOTE: We notify from within a transaction.
-  FOR_EACH_OBSERVER(SyncManager::Observer, observers_, OnEncryptionComplete());
+  FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,
+                    OnEncryptionComplete());
 }
 
-SyncManager::~SyncManager() {
+SyncManagerImpl::~SyncManagerImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   delete data_;
 }
 
-void SyncManager::AddObserver(Observer* observer) {
+void SyncManagerImpl::AddObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->AddObserver(observer);
 }
 
-void SyncManager::RemoveObserver(Observer* observer) {
+void SyncManagerImpl::RemoveObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->RemoveObserver(observer);
 }
 
-void SyncManager::StopSyncingForShutdown(const base::Closure& callback) {
+void SyncManagerImpl::StopSyncingForShutdown(const base::Closure& callback) {
   data_->StopSyncingForShutdown(callback);
 }
 
-void SyncManager::SyncInternal::StopSyncingForShutdown(
+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);
 
   if (connection_manager_.get())
     connection_manager_->TerminateAllIO();
 }
 
-void SyncManager::ShutdownOnSyncThread() {
+void SyncManagerImpl::ShutdownOnSyncThread() {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->ShutdownOnSyncThread();
 }
 
-void SyncManager::SyncInternal::ShutdownOnSyncThread() {
+void SyncManagerImpl::SyncInternal::ShutdownOnSyncThread() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Prevent any in-flight method calls from running.  Also
   // invalidates |weak_handle_this_| and |change_observer_|.
   weak_ptr_factory_.InvalidateWeakPtrs();
   js_mutation_event_observer_.InvalidateWeakPtrs();
 
   scheduler_.reset();
   session_context_.reset();
 
@@ skipping 30 matching lines @@
   change_delegate_ = NULL;
 
   initialized_ = false;
 
   // We reset these here, since only now we know they will not be
   // accessed from other threads (since we shut down everything).
   change_observer_.Reset();
   weak_handle_this_.Reset();
 }
 
-void SyncManager::SyncInternal::OnIPAddressChanged() {
+void SyncManagerImpl::SyncInternal::OnIPAddressChanged() {
   DVLOG(1) << "IP address change detected";
   if (!observing_ip_address_changes_) {
     DVLOG(1) << "IP address change dropped.";
     return;
   }
 
   OnIPAddressChangedImpl();
 }
 
-void SyncManager::SyncInternal::OnIPAddressChangedImpl() {
+void SyncManagerImpl::SyncInternal::OnIPAddressChangedImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (scheduler())
     scheduler()->OnConnectionStatusChange();
 }
 
-void SyncManager::SyncInternal::OnServerConnectionEvent(
+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_,
+    FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,
                       OnConnectionStatusChange(CONNECTION_OK));
   }
 
   if (event.connection_code == syncer::HttpResponse::SYNC_AUTH_ERROR) {
     observing_ip_address_changes_ = false;
-    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
+    FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,
                       OnConnectionStatusChange(CONNECTION_AUTH_ERROR));
   }
 
   if (event.connection_code ==
       syncer::HttpResponse::SYNC_SERVER_ERROR) {
-    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
+    FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,
                       OnConnectionStatusChange(CONNECTION_SERVER_ERROR));
   }
 }
 
-void SyncManager::SyncInternal::HandleTransactionCompleteChangeEvent(
+void SyncManagerImpl::SyncInternal::HandleTransactionCompleteChangeEvent(
     ModelTypeSet models_with_changes) {
   // This notification happens immediately after the transaction mutex is
   // released. This allows work to be performed without blocking other threads
   // from acquiring a transaction.
   if (!change_delegate_)
     return;
 
   // Call commit.
   for (ModelTypeSet::Iterator it = models_with_changes.First();
        it.Good(); it.Inc()) {
     change_delegate_->OnChangesComplete(it.Get());
     change_observer_.Call(
-        FROM_HERE, &SyncManager::ChangeObserver::OnChangesComplete, it.Get());
+        FROM_HERE,
+        &SyncManagerImpl::ChangeObserver::OnChangesComplete,
+        it.Get());
   }
 }
 
 ModelTypeSet
-    SyncManager::SyncInternal::HandleTransactionEndingChangeEvent(
+    SyncManagerImpl::SyncInternal::HandleTransactionEndingChangeEvent(
         const ImmutableWriteTransactionInfo& write_transaction_info,
         syncable::BaseTransaction* trans) {
   // This notification happens immediately before a syncable WriteTransaction
   // falls out of scope. It happens while the channel mutex is still held,
   // and while the transaction mutex is held, so it cannot be re-entrant.
   if (!change_delegate_ || ChangeBuffersAreEmpty())
     return ModelTypeSet();
 
   // This will continue the WriteTransaction using a read only wrapper.
   // This is the last chance for read to occur in the WriteTransaction
@@ skipping 10 matching lines @@
 
     ImmutableChangeRecordList ordered_changes;
     // TODO(akalin): Propagate up the error further (see
     // http://crbug.com/100907).
     CHECK(change_buffers_[type].GetAllChangesInTreeOrder(&read_trans,
                                                          &ordered_changes));
     if (!ordered_changes.Get().empty()) {
       change_delegate_->
           OnChangesApplied(type, &read_trans, ordered_changes);
       change_observer_.Call(FROM_HERE,
-          &SyncManager::ChangeObserver::OnChangesApplied,
+          &SyncManagerImpl::ChangeObserver::OnChangesApplied,
           type, write_transaction_info.Get().id, ordered_changes);
       models_with_changes.Put(type);
     }
     change_buffers_[i].Clear();
   }
   return models_with_changes;
 }
 
-void SyncManager::SyncInternal::HandleCalculateChangesChangeEventFromSyncApi(
+void SyncManagerImpl::SyncInternal::
+    HandleCalculateChangesChangeEventFromSyncApi(
     const ImmutableWriteTransactionInfo& write_transaction_info,
     syncable::BaseTransaction* trans) {
   if (!scheduler()) {
     return;
   }
 
   // We have been notified about a user action changing a sync model.
   LOG_IF(WARNING, !ChangeBuffersAreEmpty()) <<
       "CALCULATE_CHANGES called with unapplied old changes.";
 
@@ skipping 28 matching lines @@
       weak_handle_this_.Call(FROM_HERE,
                              &SyncInternal::RequestNudgeForDataTypes,
                              FROM_HERE,
                              mutated_model_types);
     } else {
       NOTREACHED();
     }
   }
 }
 
-void SyncManager::SyncInternal::SetExtraChangeRecordData(int64 id,
+void SyncManagerImpl::SyncInternal::SetExtraChangeRecordData(int64 id,
     syncer::ModelType type, ChangeReorderBuffer* buffer,
     Cryptographer* cryptographer, const syncable::EntryKernel& original,
     bool existed_before, bool exists_now) {
   // If this is a deletion and the datatype was encrypted, we need to decrypt it
   // and attach it to the buffer.
   if (!exists_now && existed_before) {
     sync_pb::EntitySpecifics original_specifics(original.ref(SPECIFICS));
     if (type == syncer::PASSWORDS) {
       // Passwords must use their own legacy ExtraPasswordChangeRecordData.
       scoped_ptr<sync_pb::PasswordSpecificsData> data(
           DecryptPasswordSpecifics(original_specifics, cryptographer));
       if (!data.get()) {
         NOTREACHED();
         return;
       }
       buffer->SetExtraDataForId(id, new ExtraPasswordChangeRecordData(*data));
     } else if (original_specifics.has_encrypted()) {
       // All other datatypes can just create a new unencrypted specifics and
       // attach it.
       const sync_pb::EncryptedData& encrypted = original_specifics.encrypted();
       if (!cryptographer->Decrypt(encrypted, &original_specifics)) {
         NOTREACHED();
         return;
       }
     }
     buffer->SetSpecificsForId(id, original_specifics);
   }
 }
 
-void SyncManager::SyncInternal::HandleCalculateChangesChangeEventFromSyncer(
+void SyncManagerImpl::SyncInternal::HandleCalculateChangesChangeEventFromSyncer(
     const ImmutableWriteTransactionInfo& write_transaction_info,
     syncable::BaseTransaction* trans) {
   // We only expect one notification per sync step, so change_buffers_ should
   // contain no pending entries.
   LOG_IF(WARNING, !ChangeBuffersAreEmpty()) <<
       "CALCULATE_CHANGES called with unapplied old changes.";
 
   Cryptographer* crypto = directory()->GetCryptographer(trans);
   const syncable::ImmutableEntryKernelMutationMap& mutations =
       write_transaction_info.Get().mutations;
@@ skipping 18 matching lines @@
              VisiblePropertiesDiffer(it->second, crypto)) {
       change_buffers_[type].PushUpdatedItem(
           handle, VisiblePositionsDiffer(it->second));
     }
 
     SetExtraChangeRecordData(handle, type, &change_buffers_[type], crypto,
                              it->second.original, existed_before, exists_now);
   }
 }
 
-SyncStatus SyncManager::SyncInternal::GetStatus() {
+SyncStatus SyncManagerImpl::SyncInternal::GetStatus() {
   return allstatus_.status();
 }
 
-void SyncManager::SyncInternal::RequestNudge(
+void SyncManagerImpl::SyncInternal::RequestNudge(
     const tracked_objects::Location& location) {
   if (scheduler()) {
      scheduler()->ScheduleNudgeAsync(
         TimeDelta::FromMilliseconds(0), syncer::NUDGE_SOURCE_LOCAL,
         ModelTypeSet(), location);
   }
 }
 
-TimeDelta SyncManager::SyncInternal::GetNudgeDelayTimeDelta(
+TimeDelta SyncManagerImpl::SyncInternal::GetNudgeDelayTimeDelta(
     const ModelType& model_type) {
   return NudgeStrategy::GetNudgeDelayTimeDelta(model_type, this);
 }
 
-void SyncManager::SyncInternal::RequestNudgeForDataTypes(
+void SyncManagerImpl::SyncInternal::RequestNudgeForDataTypes(
     const tracked_objects::Location& nudge_location,
     ModelTypeSet types) {
   if (!scheduler()) {
     NOTREACHED();
     return;
   }
 
   debug_info_event_listener_.OnNudgeFromDatatype(types.First().Get());
 
   // TODO(lipalani) : Calculate the nudge delay based on all types.
   base::TimeDelta nudge_delay = NudgeStrategy::GetNudgeDelayTimeDelta(
       types.First().Get(),
       this);
   scheduler()->ScheduleNudgeAsync(nudge_delay,
                                   syncer::NUDGE_SOURCE_LOCAL,
                                   types,
                                   nudge_location);
 }
 
-void SyncManager::SyncInternal::OnSyncEngineEvent(
+void SyncManagerImpl::SyncInternal::OnSyncEngineEvent(
     const SyncEngineEvent& event) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Only send an event if this is due to a cycle ending and this cycle
   // concludes a canonical "sync" process; that is, based on what is known
   // locally we are "all happy" and up-to-date.  There may be new changes on
   // the server, but we'll get them on a subsequent sync.
   //
   // Notifications are sent at the end of every sync cycle, regardless of
   // whether we should sync again.
   if (event.what_happened == SyncEngineEvent::SYNC_CYCLE_ENDED) {
     {
       // Check to see if we need to notify the frontend that we have newly
       // encrypted types or that we require a passphrase.
       ReadTransaction trans(FROM_HERE, GetUserShare());
       Cryptographer* cryptographer = trans.GetCryptographer();
       // If we've completed a sync cycle and the cryptographer isn't ready
       // yet, prompt the user for a passphrase.
       if (cryptographer->has_pending_keys()) {
         DVLOG(1) << "OnPassPhraseRequired Sent";
         sync_pb::EncryptedData pending_keys = cryptographer->GetPendingKeys();
-        FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
+        FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,
                           OnPassphraseRequired(syncer::REASON_DECRYPTION,
                                                pending_keys));
       } else if (!cryptographer->is_ready() &&
                  event.snapshot.initial_sync_ended().Has(syncer::NIGORI)) {
         DVLOG(1) << "OnPassphraseRequired sent because cryptographer is not "
                  << "ready";
-        FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
+        FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,
                           OnPassphraseRequired(syncer::REASON_ENCRYPTION,
                                                sync_pb::EncryptedData()));
       }
 
       NotifyCryptographerState(cryptographer);
       allstatus_.SetEncryptedTypes(cryptographer->GetEncryptedTypes());
     }
 
     if (!initialized_) {
       LOG(INFO) << "OnSyncCycleCompleted not sent because sync api is not "
                 << "initialized";
       return;
     }
 
     if (!event.snapshot.has_more_to_sync()) {
       // To account for a nigori node arriving with stale/bad data, we ensure
       // that the nigori node is up to date at the end of each cycle.
       WriteTransaction trans(FROM_HERE, GetUserShare());
       WriteNode nigori_node(&trans);
       if (nigori_node.InitByTagLookup(kNigoriTag) ==
               syncer::BaseNode::INIT_OK) {
         Cryptographer* cryptographer = trans.GetCryptographer();
         UpdateNigoriEncryptionState(cryptographer, &nigori_node);
       }
 
       DVLOG(1) << "Sending OnSyncCycleCompleted";
-      FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
+      FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,
                         OnSyncCycleCompleted(event.snapshot));
     }
 
     // This is here for tests, which are still using p2p notifications.
     //
     // TODO(chron): Consider changing this back to track has_more_to_sync
     // only notify peers if a successful commit has occurred.
     bool is_notifiable_commit =
         (event.snapshot.model_neutral_state().num_successful_commits > 0);
     if (is_notifiable_commit) {
       if (sync_notifier_.get()) {
         const ModelTypeSet changed_types =
             syncer::ModelTypePayloadMapToEnumSet(
                 event.snapshot.source().types);
         sync_notifier_->SendNotification(changed_types);
       } else {
         DVLOG(1) << "Not sending notification: sync_notifier_ is NULL";
       }
     }
   }
 
   if (event.what_happened == SyncEngineEvent::STOP_SYNCING_PERMANENTLY) {
-    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
+    FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,
                       OnStopSyncingPermanently());
     return;
   }
 
   if (event.what_happened == SyncEngineEvent::UPDATED_TOKEN) {
-    FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
+    FOR_EACH_OBSERVER(SyncManagerImpl::Observer, observers_,
                       OnUpdatedToken(event.updated_token));
     return;
   }
 
   if (event.what_happened == SyncEngineEvent::ACTIONABLE_ERROR) {
     FOR_EACH_OBSERVER(
-        SyncManager::Observer, observers_,
+        SyncManagerImpl::Observer, observers_,
         OnActionableError(
             event.snapshot.model_neutral_state().sync_protocol_error));
     return;
   }
 
 }
 
-void SyncManager::SyncInternal::SetJsEventHandler(
+void SyncManagerImpl::SyncInternal::SetJsEventHandler(
     const WeakHandle<JsEventHandler>& event_handler) {
   js_event_handler_ = event_handler;
   js_sync_manager_observer_.SetJsEventHandler(js_event_handler_);
   js_mutation_event_observer_.SetJsEventHandler(js_event_handler_);
 }
 
-void SyncManager::SyncInternal::ProcessJsMessage(
+void SyncManagerImpl::SyncInternal::ProcessJsMessage(
     const std::string& name, const JsArgList& args,
     const WeakHandle<JsReplyHandler>& reply_handler) {
   if (!initialized_) {
     NOTREACHED();
     return;
   }
 
   if (!reply_handler.IsInitialized()) {
     DVLOG(1) << "Uninitialized reply handler; dropping unknown message "
             << name << " with args " << args.ToString();
     return;
   }
 
   JsMessageHandler js_message_handler = js_message_handlers_[name];
   if (js_message_handler.is_null()) {
     DVLOG(1) << "Dropping unknown message " << name
              << " with args " << args.ToString();
     return;
   }
 
   reply_handler.Call(FROM_HERE,
                      &JsReplyHandler::HandleJsReply,
                      name, js_message_handler.Run(args));
 }
 
-void SyncManager::SyncInternal::BindJsMessageHandler(
+void SyncManagerImpl::SyncInternal::BindJsMessageHandler(
     const std::string& name,
     UnboundJsMessageHandler unbound_message_handler) {
   js_message_handlers_[name] =
       base::Bind(unbound_message_handler, base::Unretained(this));
 }
 
-DictionaryValue* SyncManager::SyncInternal::NotificationInfoToValue(
+DictionaryValue* SyncManagerImpl::SyncInternal::NotificationInfoToValue(
     const NotificationInfoMap& notification_info) {
   DictionaryValue* value = new DictionaryValue();
 
   for (NotificationInfoMap::const_iterator it = notification_info.begin();
       it != notification_info.end(); ++it) {
     const std::string& model_type_str =
         syncer::ModelTypeToString(it->first);
     value->Set(model_type_str, it->second.ToValue());
   }
 
   return value;
 }
 
-JsArgList SyncManager::SyncInternal::GetNotificationState(
+JsArgList SyncManagerImpl::SyncInternal::GetNotificationState(
     const JsArgList& args) {
   bool notifications_enabled = allstatus_.status().notifications_enabled;
   ListValue return_args;
   return_args.Append(Value::CreateBooleanValue(notifications_enabled));
   return JsArgList(&return_args);
 }
 
-JsArgList SyncManager::SyncInternal::GetNotificationInfo(
+JsArgList SyncManagerImpl::SyncInternal::GetNotificationInfo(
     const JsArgList& args) {
   ListValue return_args;
   return_args.Append(NotificationInfoToValue(notification_info_map_));
   return JsArgList(&return_args);
 }
 
-JsArgList SyncManager::SyncInternal::GetRootNodeDetails(
+JsArgList SyncManagerImpl::SyncInternal::GetRootNodeDetails(
     const JsArgList& args) {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   ReadNode root(&trans);
   root.InitByRootLookup();
   ListValue return_args;
   return_args.Append(root.GetDetailsAsValue());
   return JsArgList(&return_args);
 }
 
-JsArgList SyncManager::SyncInternal::GetClientServerTraffic(
+JsArgList SyncManagerImpl::SyncInternal::GetClientServerTraffic(
     const JsArgList& args) {
   ListValue return_args;
   ListValue* value = traffic_recorder_.ToValue();
   if (value != NULL)
     return_args.Append(value);
   return JsArgList(&return_args);
 }
 
 namespace {
 
@@ skipping 30 matching lines @@
         continue;
       }
       node_summaries->Append((node.*info_getter)());
     }
   }
   return JsArgList(&return_args);
 }
 
 }  // namespace
 
-JsArgList SyncManager::SyncInternal::GetNodeSummariesById(
+JsArgList SyncManagerImpl::SyncInternal::GetNodeSummariesById(
     const JsArgList& args) {
   return GetNodeInfoById(args, GetUserShare(), &BaseNode::GetSummaryAsValue);
 }
 
-JsArgList SyncManager::SyncInternal::GetNodeDetailsById(
+JsArgList SyncManagerImpl::SyncInternal::GetNodeDetailsById(
     const JsArgList& args) {
   return GetNodeInfoById(args, GetUserShare(), &BaseNode::GetDetailsAsValue);
 }
 
-JsArgList SyncManager::SyncInternal::GetAllNodes(
+JsArgList SyncManagerImpl::SyncInternal::GetAllNodes(
     const JsArgList& args) {
   ListValue return_args;
   ListValue* result = new ListValue();
   return_args.Append(result);
 
   ReadTransaction trans(FROM_HERE, GetUserShare());
   std::vector<const syncable::EntryKernel*> entry_kernels;
   trans.GetDirectory()->GetAllEntryKernels(trans.GetWrappedTrans(),
                                            &entry_kernels);
 
   for (std::vector<const syncable::EntryKernel*>::const_iterator it =
            entry_kernels.begin(); it != entry_kernels.end(); ++it) {
     result->Append((*it)->ToValue());
   }
 
   return JsArgList(&return_args);
 }
 
-JsArgList SyncManager::SyncInternal::GetChildNodeIds(
+JsArgList SyncManagerImpl::SyncInternal::GetChildNodeIds(
     const JsArgList& args) {
   ListValue return_args;
   ListValue* child_ids = new ListValue();
   return_args.Append(child_ids);
   int64 id = GetId(args.Get(), 0);
   if (id != kInvalidId) {
     ReadTransaction trans(FROM_HERE, GetUserShare());
     syncable::Directory::ChildHandles child_handles;
     trans.GetDirectory()->GetChildHandlesByHandle(trans.GetWrappedTrans(),
                                                   id, &child_handles);
     for (syncable::Directory::ChildHandles::const_iterator it =
              child_handles.begin(); it != child_handles.end(); ++it) {
       child_ids->Append(Value::CreateStringValue(
           base::Int64ToString(*it)));
     }
   }
   return JsArgList(&return_args);
 }
 
-void SyncManager::SyncInternal::OnEncryptedTypesChanged(
+void SyncManagerImpl::SyncInternal::OnEncryptedTypesChanged(
     syncer::ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   // NOTE: We're in a transaction.
   FOR_EACH_OBSERVER(
-      SyncManager::Observer, observers_,
+      SyncManagerImpl::Observer, observers_,
       OnEncryptedTypesChanged(encrypted_types, encrypt_everything));
 }
 
-void SyncManager::SyncInternal::UpdateNotificationInfo(
+void SyncManagerImpl::SyncInternal::UpdateNotificationInfo(
     const syncer::ModelTypePayloadMap& type_payloads) {
   for (syncer::ModelTypePayloadMap::const_iterator it = type_payloads.begin();
        it != type_payloads.end(); ++it) {
     NotificationInfo* info = &notification_info_map_[it->first];
     info->total_count++;
     info->payload = it->second;
   }
 }
 
-void SyncManager::SyncInternal::OnNotificationsEnabled() {
+void SyncManagerImpl::SyncInternal::OnNotificationsEnabled() {
   DVLOG(1) << "Notifications enabled";
   allstatus_.SetNotificationsEnabled(true);
   if (scheduler()) {
     scheduler()->set_notifications_enabled(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(
+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);
   }
   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(
+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);
     }
@@ skipping 24 matching lines @@
     }
     details.SetString("source", (source == syncer::LOCAL_NOTIFICATION) ?
         "LOCAL_NOTIFICATION" : "REMOTE_NOTIFICATION");
     js_event_handler_.Call(FROM_HERE,
                            &JsEventHandler::HandleJsEvent,
                            "onIncomingNotification",
                            JsEventDetails(&details));
   }
 }
 
-void SyncManager::SyncInternal::AddObserver(
-    SyncManager::Observer* observer) {
+void SyncManagerImpl::SyncInternal::AddObserver(
+    SyncManagerImpl::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
-void SyncManager::SyncInternal::RemoveObserver(
-    SyncManager::Observer* observer) {
+void SyncManagerImpl::SyncInternal::RemoveObserver(
+    SyncManagerImpl::Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void SyncManager::SyncInternal::SetSyncSchedulerForTest(
+void SyncManagerImpl::SyncInternal::SetSyncSchedulerForTest(
     scoped_ptr<SyncScheduler> sync_scheduler) {
   scheduler_ = sync_scheduler.Pass();
 }
 
-SyncStatus SyncManager::GetDetailedStatus() const {
+SyncStatus SyncManagerImpl::GetDetailedStatus() const {
   return data_->GetStatus();
 }
 
-void SyncManager::SaveChanges() {
+void SyncManagerImpl::SaveChanges() {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->SaveChanges();
 }
 
-void SyncManager::SyncInternal::SaveChanges() {
+void SyncManagerImpl::SyncInternal::SaveChanges() {
   directory()->SaveChanges();
 }
 
-UserShare* SyncManager::GetUserShare() const {
+UserShare* SyncManagerImpl::GetUserShare() const {
   return data_->GetUserShare();
 }
 
-void SyncManager::RefreshNigori(const std::string& chrome_version,
+void SyncManagerImpl::RefreshNigori(const std::string& chrome_version,
                                 const base::Closure& done_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->UpdateCryptographerAndNigori(
       chrome_version,
       done_callback);
 }
 
-TimeDelta SyncManager::GetNudgeDelayTimeDelta(
+TimeDelta SyncManagerImpl::GetNudgeDelayTimeDelta(
     const ModelType& model_type) {
   return data_->GetNudgeDelayTimeDelta(model_type);
 }
 
-void SyncManager::SetSyncSchedulerForTest(scoped_ptr<SyncScheduler> scheduler) {
+void SyncManagerImpl::SetSyncSchedulerForTest(
+    scoped_ptr<SyncScheduler> scheduler) {
   data_->SetSyncSchedulerForTest(scheduler.Pass());
 }
 
-syncer::ModelTypeSet SyncManager::GetEncryptedDataTypesForTest() const {
+syncer::ModelTypeSet SyncManagerImpl::GetEncryptedDataTypesForTest() const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return GetEncryptedTypes(&trans);
 }
 
-bool SyncManager::ReceivedExperiment(syncer::Experiments* experiments)
-    const {
+bool SyncManagerImpl::ReceivedExperiment(
+    syncer::Experiments* experiments) const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   ReadNode node(&trans);
   if (node.InitByTagLookup(kNigoriTag) != syncer::BaseNode::INIT_OK) {
     DVLOG(1) << "Couldn't find Nigori node.";
     return false;
   }
   bool found_experiment = false;
   if (node.GetNigoriSpecifics().sync_tab_favicons()) {
     experiments->sync_tab_favicons = true;
     found_experiment = true;
   }
   return found_experiment;
 }
 
-bool SyncManager::HasUnsyncedItems() const {
+bool SyncManagerImpl::HasUnsyncedItems() const {
   syncer::ReadTransaction trans(FROM_HERE, GetUserShare());
   return (trans.GetWrappedTrans()->directory()->unsynced_entity_count() != 0);
 }
 
-void SyncManager::SimulateEnableNotificationsForTest() {
+void SyncManagerImpl::SimulateEnableNotificationsForTest() {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->OnNotificationsEnabled();
 }
 
-void SyncManager::SimulateDisableNotificationsForTest(int reason) {
+void SyncManagerImpl::SimulateDisableNotificationsForTest(int reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_->OnNotificationsDisabled(
       static_cast<syncer::NotificationsDisabledReason>(reason));
 }
 
-void SyncManager::TriggerOnIncomingNotificationForTest(
+void SyncManagerImpl::TriggerOnIncomingNotificationForTest(
     ModelTypeSet model_types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   syncer::ModelTypePayloadMap model_types_with_payloads =
       syncer::ModelTypePayloadMapFromEnumSet(model_types,
           std::string());
 
   data_->OnIncomingNotification(model_types_with_payloads,
                                 syncer::REMOTE_NOTIFICATION);
 }
 
-const char* ConnectionStatusToString(ConnectionStatus status) {
-  switch (status) {
-    case CONNECTION_OK:
-      return "CONNECTION_OK";
-    case CONNECTION_AUTH_ERROR:
-      return "CONNECTION_AUTH_ERROR";
-    case CONNECTION_SERVER_ERROR:
-      return "CONNECTION_SERVER_ERROR";
-    default:
-      NOTREACHED();
-      return "INVALID_CONNECTION_STATUS";
-  }
+// static.
+int SyncManagerImpl::GetDefaultNudgeDelay() {
+  return kDefaultNudgeDelayMilliseconds;
 }
 
-// Helper function that converts a PassphraseRequiredReason value to a string.
-const char* PassphraseRequiredReasonToString(
-    PassphraseRequiredReason reason) {
-  switch (reason) {
-    case REASON_PASSPHRASE_NOT_REQUIRED:
-      return "REASON_PASSPHRASE_NOT_REQUIRED";
-    case REASON_ENCRYPTION:
-      return "REASON_ENCRYPTION";
-    case REASON_DECRYPTION:
-      return "REASON_DECRYPTION";
-    default:
-      NOTREACHED();
-      return "INVALID_REASON";
-  }
-}
-
-// Helper function to determine if initial sync had ended for types.
-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;
+// static.
+int SyncManagerImpl::GetPreferencesNudgeDelay() {
+  return kPreferencesNudgeDelayMilliseconds;
 }
 
 }  // namespace syncer