[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 407 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 60 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 139 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>());
 
   // Move aside the backend so nobody else tries to use it while we are
   // shutting it down.
-  std::unique_ptr<SyncBackendHost> doomed_backend(backend_.release());
+  std::unique_ptr<SyncEngine> doomed_backend(backend_.release());
   if (doomed_backend) {
     doomed_backend->Shutdown(reason);
     doomed_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());
@@ skipping 23 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 SyncEngine itself.

[skym, 2016/12/02 20:54:54]

This is so ambiguous and confusing with this name. Are you advocating for moving
this logic into the SyncEngine facade? Or the interface? Or onto some logic
that's inside the "engine"?

[maxbogue, 2016/12/02 23:59:27]

Clarified it to "sync engine" (aka the last of the options you mentioned).

       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 90 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 511 matching lines @@
     case DATATYPES_NOT_INITIALIZED:
       return "Datatypes not fully initialized";
     case INITIALIZED:
       return "Sync service initialized";
     default:
       return "Status unknown: Internal error?";
   }
 }
 
 std::string ProfileSyncService::GetBackendInitializationStateString() const {
-  return startup_controller_->GetBackendInitializationStateString();
+  return startup_controller_->GetEngineInitializationStateString();
 }
 
 bool ProfileSyncService::IsSetupInProgress() const {
   return startup_controller_->IsSetupInProgress();
 }
 
-bool ProfileSyncService::QueryDetailedSyncStatus(
-    SyncBackendHost::Status* result) {
+bool ProfileSyncService::QueryDetailedSyncStatus(SyncEngine::Status* result) {
   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 {
   return last_auth_error_;
 }
 
@@ skipping 357 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 654 matching lines @@
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsBackendInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 }  // namespace browser_sync