[Sync] SyncEngine refactor part 1: interfaces.

components/browser_sync/profile_sync_service.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 "components/browser_sync/profile_sync_service.h"
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <map>
@@ skipping 90 matching lines @@
 using syncer::JsBackend;
 using syncer::JsController;
 using syncer::JsEventDetails;
 using syncer::JsEventHandler;
 using syncer::ModelSafeRoutingInfo;
 using syncer::ModelType;
 using syncer::ModelTypeChangeProcessor;
 using syncer::ModelTypeSet;
 using syncer::ModelTypeStore;
 using syncer::ProtocolEventObserver;
-using syncer::SyncBackendHost;
+using syncer::SyncEngine;
 using syncer::SyncCredentials;
 using syncer::SyncProtocolError;
 using syncer::WeakHandle;
 
 namespace browser_sync {
 
 typedef GoogleServiceAuthError AuthError;
 
 const char kSyncUnrecoverableErrorHistogram[] = "Sync.UnrecoverableErrors";
 
@@ skipping 413 matching lines @@
   // profile should get this treatment or all profile as is the case now. The
   // solution for now will be to assume profiles are created in the same order
   // on all machines and in the future decide if only the Default one should be
   // considered roamed.
   local_sync_backend_folder =
       local_sync_backend_folder.Append(base_directory_.BaseName());
   local_sync_backend_folder =
       local_sync_backend_folder.Append(kLoopbackServerBackendFilename);
 #endif  // defined(OS_WIN)
 
-  SyncBackendHost::HttpPostProviderFactoryGetter
-      http_post_provider_factory_getter =
-          base::Bind(&syncer::NetworkResources::GetHttpPostProviderFactory,
-                     base::Unretained(network_resources_.get()),
-                     url_request_context_, network_time_update_callback_);
+  SyncEngine::HttpPostProviderFactoryGetter http_post_provider_factory_getter =
+      base::Bind(&syncer::NetworkResources::GetHttpPostProviderFactory,
+                 base::Unretained(network_resources_.get()),
+                 url_request_context_, network_time_update_callback_);
 
   backend_->Initialize(
       this, sync_thread_->task_runner(), GetJsEventHandler(), sync_service_url_,
       local_device_->GetSyncUserAgent(), credentials, delete_stale_data,
       enable_local_sync_backend, local_sync_backend_folder,
       base::MakeUnique<syncer::SyncManagerFactory>(),
       MakeWeakHandle(sync_enabled_weak_factory_.GetWeakPtr()),
       base::Bind(syncer::ReportUnrecoverableError, channel_),
       http_post_provider_factory_getter, std::move(saved_nigori_state_));
 }
@@ skipping 65 matching lines @@
     return;
   }
 
   startup_controller_->OnDataTypeRequestsSyncStartup(type);
 }
 
 void ProfileSyncService::StartUpSlowBackendComponents() {
   invalidation::InvalidationService* invalidator =
       sync_client_->GetInvalidationService();
 
-  backend_.reset(
-      sync_client_->GetSyncApiComponentFactory()->CreateSyncBackendHost(
-          debug_identifier_, invalidator, sync_prefs_.AsWeakPtr(),
-          directory_path_));
+  backend_.reset(sync_client_->GetSyncApiComponentFactory()->CreateSyncEngine(
+      debug_identifier_, invalidator, sync_prefs_.AsWeakPtr(),
+      directory_path_));
 
-  // Initialize the backend.  Every time we start up a new SyncBackendHost,
-  // we'll want to start from a fresh SyncDB, so delete any old one that might
-  // be there.
+  // Initialize the backend. Every time we start up a new SyncEngine, we'll want
+  // to start from a fresh SyncDB, so delete any old one that might be there.
   InitializeBackend(ShouldDeleteSyncFolder());
 
   UpdateFirstSyncTimePref();
 
   ReportPreviousSessionMemoryWarningCount();
 }
 
 void ProfileSyncService::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
@@ skipping 145 matching lines @@
     data_type_manager_.reset();
   }
 
   // Shutdown the migrator before the backend to ensure it doesn't pull a null
   // snapshot.
   migrator_.reset();
   sync_js_controller_.AttachJsBackend(WeakHandle<syncer::JsBackend>());
 
   backend_->Shutdown(reason);
   backend_.reset();
+
   base::TimeDelta shutdown_time = base::Time::Now() - shutdown_start_time;
   UMA_HISTOGRAM_TIMES("Sync.Shutdown.BackendDestroyedTime", shutdown_time);
 
   sync_enabled_weak_factory_.InvalidateWeakPtrs();
 
   startup_controller_->Reset(GetRegisteredDataTypes());
 
   // If the sync DB is getting destroyed, the local DeviceInfo is no longer
   // valid and should be cleared from the cache.
   if (reason == syncer::ShutdownReason::DISABLE_SYNC) {
@@ skipping 19 matching lines @@
   NotifyObservers();
 
   // Mark this as a clean shutdown(without crash).
   sync_prefs_.SetCleanShutdown(true);
 }
 
 void ProfileSyncService::StopImpl(SyncStopDataFate data_fate) {
   switch (data_fate) {
     case KEEP_DATA:
       // TODO(maxbogue): Investigate whether this logic can/should be moved
-      // into ShutdownImpl or SyncBackendHost itself.
+      // into ShutdownImpl or the sync engine itself.
       if (HasSyncingBackend()) {
         backend_->UnregisterInvalidationIds();
       }
       ShutdownImpl(syncer::STOP_SYNC);
       break;
     case CLEAR_DATA:
       // Clear prefs (including SyncSetupHasCompleted) before shutting down so
       // PSS clients don't think we're set up while we're shutting down.
       sync_prefs_.ClearPreferences();
       ClearUnrecoverableError();
@@ skipping 94 matching lines @@
   is_first_time_sync_configure_ = !IsFirstSetupComplete();
 
   if (is_first_time_sync_configure_) {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeFirstTimeSuccess", success);
   } else {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeRestoreSuccess", success);
   }
 
   base::Time on_backend_initialized_time = base::Time::Now();
   base::TimeDelta delta =
-      on_backend_initialized_time - startup_controller_->start_backend_time();
+      on_backend_initialized_time - startup_controller_->start_engine_time();
   if (is_first_time_sync_configure_) {
     UMA_HISTOGRAM_LONG_TIMES("Sync.BackendInitializeFirstTime", delta);
   } else {
     UMA_HISTOGRAM_LONG_TIMES("Sync.BackendInitializeRestoreTime", delta);
   }
 }
 
 void ProfileSyncService::PostBackendInitialization() {
   if (protocol_event_observers_.might_have_observers()) {
     backend_->RequestBufferedProtocolEventsAndEnableForwarding();
@@ skipping 523 matching lines @@
       return "Datatypes not fully initialized";
     case INITIALIZED:
       return "Sync service initialized";
     default:
       return "Status unknown: Internal error?";
   }
 }
 
 std::string ProfileSyncService::GetBackendInitializationStateString() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return startup_controller_->GetBackendInitializationStateString();
+  return startup_controller_->GetEngineInitializationStateString();
 }
 
 bool ProfileSyncService::IsSetupInProgress() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return startup_controller_->IsSetupInProgress();
 }
 
-bool ProfileSyncService::QueryDetailedSyncStatus(
-    SyncBackendHost::Status* result) {
+bool ProfileSyncService::QueryDetailedSyncStatus(SyncEngine::Status* result) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (backend_.get() && backend_initialized_) {
     *result = backend_->GetDetailedStatus();
     return true;
   } else {
-    SyncBackendHost::Status status;
+    SyncEngine::Status status;
     status.sync_protocol_error = last_actionable_error_;
     *result = status;
     return false;
   }
 }
 
 const AuthError& ProfileSyncService::GetAuthError() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return last_auth_error_;
 }
@@ skipping 390 matching lines @@
   backend_->GetModelSafeRoutingInfo(&routing_info);
   for (ModelSafeRoutingInfo::const_iterator it = routing_info.begin();
        it != routing_info.end(); ++it) {
     if (it->second == syncer::GROUP_PASSIVE) {
       passive_types.Put(it->first);
     } else {
       active_types.Put(it->first);
     }
   }
 
-  SyncBackendHost::Status detailed_status = backend_->GetDetailedStatus();
+  SyncEngine::Status detailed_status = backend_->GetDetailedStatus();
   ModelTypeSet& throttled_types(detailed_status.throttled_types);
   ModelTypeSet& backed_off_types(detailed_status.backed_off_types);
   ModelTypeSet registered = GetRegisteredDataTypes();
   std::unique_ptr<base::DictionaryValue> type_status_header(
       new base::DictionaryValue());
 
   type_status_header->SetString("name", "Model Type");
   type_status_header->SetString("status", "header");
   type_status_header->SetString("value", "Group Type");
   type_status_header->SetString("num_entries", "Total Entries");
@@ skipping 701 matching lines @@
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsBackendInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 }  // namespace browser_sync