[Sync] SyncEngine refactor part 1: interfaces.

components/sync/driver/glue/sync_backend_host_impl.cc

 // Copyright 2013 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/sync/driver/glue/sync_backend_host_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/invalidation/public/invalidation_service.h"
 #include "components/invalidation/public/object_id_invalidation_map.h"
 #include "components/signin/core/browser/signin_client.h"
 #include "components/sync/base/experiments.h"
 #include "components/sync/base/invalidation_helper.h"
 #include "components/sync/base/sync_prefs.h"
 #include "components/sync/driver/glue/sync_backend_host_core.h"
 #include "components/sync/driver/glue/sync_backend_registrar.h"
 #include "components/sync/driver/sync_client.h"
 #include "components/sync/driver/sync_driver_switches.h"
-#include "components/sync/driver/sync_frontend.h"
 #include "components/sync/engine/activation_context.h"
 #include "components/sync/engine/engine_components_factory.h"
 #include "components/sync/engine/engine_components_factory_impl.h"
 #include "components/sync/engine/events/protocol_event.h"
 #include "components/sync/engine/net/http_bridge.h"
+#include "components/sync/engine/sync_engine_host.h"
 #include "components/sync/engine/sync_manager_factory.h"
 #include "components/sync/engine/sync_string_conversions.h"
 #include "components/sync/syncable/base_transaction.h"
 
 // Helper macros to log with the syncer thread name; useful when there
 // are multiple syncers involved.
 
 #define SLOG(severity) LOG(severity) << name_ << ": "
 
 #define SDVLOG(verbose_level) DVLOG(verbose_level) << name_ << ": "
 
 namespace syncer {
 
 SyncBackendHostImpl::SyncBackendHostImpl(
     const std::string& name,
     SyncClient* sync_client,
     invalidation::InvalidationService* invalidator,
     const base::WeakPtr<SyncPrefs>& sync_prefs,
     const base::FilePath& sync_folder)
     : sync_client_(sync_client),
       name_(name),
-      initialized_(false),
       sync_prefs_(sync_prefs),
-      frontend_(nullptr),
-      cached_passphrase_type_(PassphraseType::IMPLICIT_PASSPHRASE),
       invalidator_(invalidator),
-      invalidation_handler_registered_(false),
       weak_ptr_factory_(this) {
   core_ = new SyncBackendHostCore(name_, sync_folder,
                                   weak_ptr_factory_.GetWeakPtr());
 }
 
 SyncBackendHostImpl::~SyncBackendHostImpl() {
-  DCHECK(!core_.get() && !frontend_) << "Must call Shutdown before destructor.";
+  DCHECK(!core_.get() && !host_) << "Must call Shutdown before destructor.";
   DCHECK(!registrar_.get());
 }
 
 void SyncBackendHostImpl::Initialize(
-    SyncFrontend* frontend,
+    SyncEngineHost* host,
     scoped_refptr<base::SingleThreadTaskRunner> sync_task_runner,
     const WeakHandle<JsEventHandler>& event_handler,
     const GURL& sync_service_url,
     const std::string& sync_user_agent,
     const SyncCredentials& credentials,
     bool delete_sync_data_folder,
     bool enable_local_sync_backend,
     const base::FilePath& local_sync_backend_folder,
     std::unique_ptr<SyncManagerFactory> sync_manager_factory,
     const WeakHandle<UnrecoverableErrorHandler>& unrecoverable_error_handler,
     const base::Closure& report_unrecoverable_error_function,
     const HttpPostProviderFactoryGetter& http_post_provider_factory_getter,
     std::unique_ptr<SyncEncryptionHandler::NigoriState> saved_nigori_state) {
   CHECK(sync_task_runner);
   sync_task_runner_ = sync_task_runner;
 
   registrar_ = base::MakeUnique<SyncBackendRegistrar>(
       name_, base::Bind(&SyncClient::CreateModelWorkerForGroup,
                         base::Unretained(sync_client_)));
 
-  DCHECK(frontend);
-  frontend_ = frontend;
+  DCHECK(host);
+  host_ = host;
 
   std::vector<scoped_refptr<ModelSafeWorker>> workers;
   registrar_->GetWorkers(&workers);
 
   EngineComponentsFactory::Switches factory_switches = {
       EngineComponentsFactory::ENCRYPTION_KEYSTORE,
       EngineComponentsFactory::BACKOFF_NORMAL};
 
   base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
   if (cl->HasSwitch(switches::kSyncShortInitialRetryOverride)) {
@@ skipping 58 matching lines @@
                                                   bool is_explicit) {
   if (!IsNigoriEnabled()) {
     NOTREACHED() << "SetEncryptionPassphrase must never be called when nigori"
                     " is disabled.";
     return;
   }
 
   // We should never be called with an empty passphrase.
   DCHECK(!passphrase.empty());
 
-  // This should only be called by the frontend.
+  // This should only be called by the host.

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

Do we really need this comment? This isn't verifying that we're actually being
called by the PSS, we're only doing a thread check. It should be interfaces and
accessibility that forces this.

Are any of these methods allowed to be called from the wrong thread anymore? I
thought you fixed that part.

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

Removed it. They aren't allowed to be called from the wrong thread.

   DCHECK(thread_checker_.CalledOnValidThread());

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

Is it just me, or is it a bit odd that these CalledOnValidThread checks are not
the first thing happening in these methods? Is it okay to call from the wrong
thread when nigori is disabled?

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

No you're right. Moved to the top.

 
   // SetEncryptionPassphrase should never be called if we are currently
   // encrypted with an explicit passphrase.
   DCHECK(cached_passphrase_type_ == PassphraseType::KEYSTORE_PASSPHRASE ||
          cached_passphrase_type_ == PassphraseType::IMPLICIT_PASSPHRASE);
 
   // Post an encryption task on the syncer thread.
   sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoSetEncryptionPassphrase,
                             core_, passphrase, is_explicit));
 }
 
 bool SyncBackendHostImpl::SetDecryptionPassphrase(
     const std::string& passphrase) {
   if (!IsNigoriEnabled()) {
     NOTREACHED() << "SetDecryptionPassphrase must never be called when nigori"
                     " is disabled.";
     return false;
   }
 
   // We should never be called with an empty passphrase.
   DCHECK(!passphrase.empty());
 
-  // This should only be called by the frontend.
+  // This should only be called by the host.

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

Same

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

Done.

   DCHECK(thread_checker_.CalledOnValidThread());

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

Same

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

Done.

 
   // This should only be called when we have cached pending keys.
   DCHECK(cached_pending_keys_.has_blob());
 
   // Check the passphrase that was provided against our local cache of the
   // cryptographer's pending keys. If this was unsuccessful, the UI layer can
   // immediately call OnPassphraseRequired without showing the user a spinner.
   if (!CheckPassphraseAgainstCachedPendingKeys(passphrase))
     return false;
 
@@ skipping 13 matching lines @@
   // trigger a new OnPassphraseRequired if it needs to.
   NotifyPassphraseAccepted();
   return true;
 }
 
 void SyncBackendHostImpl::StopSyncingForShutdown() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Stop getting messages from the sync thread.
   weak_ptr_factory_.InvalidateWeakPtrs();
-  // Immediately stop sending messages to the frontend.
-  frontend_ = nullptr;
+  // Immediately stop sending messages to the host.
+  host_ = nullptr;
 
   registrar_->RequestWorkerStopOnUIThread();
 
   core_->ShutdownOnUIThread();
 }
 
 void SyncBackendHostImpl::Shutdown(ShutdownReason reason) {
-  // StopSyncingForShutdown() (which nulls out |frontend_|) should be
+  // StopSyncingForShutdown() (which nulls out |host_|) should be
   // called first.
-  DCHECK(!frontend_);
+  DCHECK(!host_);
 
   if (invalidation_handler_registered_) {
     if (reason == DISABLE_SYNC) {
       UnregisterInvalidationIds();
     }
     invalidator_->UnregisterInvalidationHandler(this);
     invalidator_ = nullptr;
   }
   invalidation_handler_registered_ = false;
 
@@ skipping 281 matching lines @@
   }
 
   if (!ready_task.is_null())
     ready_task.Run(succeeded_configuration_types, failed_configuration_types);
 }
 
 void SyncBackendHostImpl::AddExperimentalTypes() {
   CHECK(initialized());
   Experiments experiments;
   if (core_->sync_manager()->ReceivedExperiment(&experiments))
-    frontend_->OnExperimentsChanged(experiments);
+    host_->OnExperimentsChanged(experiments);
 }
 
 void SyncBackendHostImpl::HandleInitializationSuccessOnFrontendLoop(
     const WeakHandle<JsBackend> js_backend,
     const WeakHandle<DataTypeDebugInfoListener> debug_info_listener,
     std::unique_ptr<ModelTypeConnector> model_type_connector,
     const std::string& cache_guid) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   model_type_connector_ = std::move(model_type_connector);
 
   initialized_ = true;
 
   if (invalidator_) {
     invalidator_->RegisterInvalidationHandler(this);
     invalidation_handler_registered_ = true;
 
     // Fake a state change to initialize the SyncManager's cached invalidator
     // state.
     OnInvalidatorStateChange(invalidator_->GetInvalidatorState());
   }
 
   // Now that we've downloaded the control types, we can see if there are any
   // experimental types to enable. This should be done before we inform
-  // the frontend to ensure they're visible in the customize screen.
+  // the host to ensure they're visible in the customize screen.
   AddExperimentalTypes();
-  frontend_->OnBackendInitialized(js_backend, debug_info_listener, cache_guid,
-                                  true);
+  host_->OnBackendInitialized(js_backend, debug_info_listener, cache_guid,
+                              true);
 }
 
 void SyncBackendHostImpl::HandleInitializationFailureOnFrontendLoop() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  frontend_->OnBackendInitialized(WeakHandle<JsBackend>(),
-                                  WeakHandle<DataTypeDebugInfoListener>(), "",
-                                  false);
+  host_->OnBackendInitialized(WeakHandle<JsBackend>(),
+                              WeakHandle<DataTypeDebugInfoListener>(), "",
+                              false);
 }
 
 void SyncBackendHostImpl::HandleSyncCycleCompletedOnFrontendLoop(
     const SyncCycleSnapshot& snapshot) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   last_snapshot_ = snapshot;
 
   SDVLOG(1) << "Got snapshot " << snapshot.ToString();
 
   if (!snapshot.poll_finish_time().is_null())
     sync_prefs_->SetLastPollTime(snapshot.poll_finish_time());
 
   // Process any changes to the datatypes we're syncing.
   // TODO(sync): add support for removing types.
   if (initialized())
     AddExperimentalTypes();
 
   if (initialized())
-    frontend_->OnSyncCycleCompleted();
+    host_->OnSyncCycleCompleted();
 }
 
 void SyncBackendHostImpl::RetryConfigurationOnFrontendLoop(
     const base::Closure& retry_callback) {
   SDVLOG(1) << "Failed to complete configuration, informing of retry.";
   retry_callback.Run();
 }
 
 void SyncBackendHostImpl::PersistEncryptionBootstrapToken(
     const std::string& token,
     BootstrapTokenType token_type) {
   CHECK(sync_prefs_.get());
   if (token_type == PASSPHRASE_BOOTSTRAP_TOKEN)
     sync_prefs_->SetEncryptionBootstrapToken(token);
   else
     sync_prefs_->SetKeystoreEncryptionBootstrapToken(token);
 }
 
 void SyncBackendHostImpl::HandleActionableErrorEventOnFrontendLoop(
     const SyncProtocolError& sync_error) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  frontend_->OnActionableError(sync_error);
+  host_->OnActionableError(sync_error);
 }
 
 void SyncBackendHostImpl::HandleMigrationRequestedOnFrontendLoop(
     ModelTypeSet types) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  frontend_->OnMigrationNeededForTypes(types);
+  host_->OnMigrationNeededForTypes(types);
 }
 
 void SyncBackendHostImpl::OnInvalidatorStateChange(InvalidatorState state) {
   sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoOnInvalidatorStateChange,
                             core_, state));
 }
 
 void SyncBackendHostImpl::OnIncomingInvalidation(
     const ObjectIdInvalidationMap& invalidation_map) {
@@ skipping 19 matching lines @@
 }
 
 void SyncBackendHostImpl::NotifyPassphraseRequired(
     PassphraseRequiredReason reason,
     sync_pb::EncryptedData pending_keys) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Update our cache of the cryptographer's pending keys.
   cached_pending_keys_ = pending_keys;
 
-  frontend_->OnPassphraseRequired(reason, pending_keys);
+  host_->OnPassphraseRequired(reason, pending_keys);
 }
 
 void SyncBackendHostImpl::NotifyPassphraseAccepted() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Clear our cache of the cryptographer's pending keys.
   cached_pending_keys_.clear_blob();
-  frontend_->OnPassphraseAccepted();
+  host_->OnPassphraseAccepted();
 }
 
 void SyncBackendHostImpl::NotifyEncryptedTypesChanged(
     ModelTypeSet encrypted_types,
     bool encrypt_everything) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  frontend_->OnEncryptedTypesChanged(encrypted_types, encrypt_everything);
+  host_->OnEncryptedTypesChanged(encrypted_types, encrypt_everything);
 }
 
 void SyncBackendHostImpl::NotifyEncryptionComplete() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  frontend_->OnEncryptionComplete();
+  host_->OnEncryptionComplete();
 }
 
 void SyncBackendHostImpl::HandlePassphraseTypeChangedOnFrontendLoop(
     PassphraseType type,
     base::Time explicit_passphrase_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "Passphrase type changed to " << PassphraseTypeToString(type);
   cached_passphrase_type_ = type;
   cached_explicit_passphrase_time_ = explicit_passphrase_time;
 }
 
 void SyncBackendHostImpl::HandleLocalSetPassphraseEncryptionOnFrontendLoop(
     const SyncEncryptionHandler::NigoriState& nigori_state) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  frontend_->OnLocalSetPassphraseEncryption(nigori_state);
+  host_->OnLocalSetPassphraseEncryption(nigori_state);
 }
 
 void SyncBackendHostImpl::HandleConnectionStatusChangeOnFrontendLoop(
     ConnectionStatus status) {
   DCHECK(thread_checker_.CalledOnValidThread());
-
   DVLOG(1) << "Connection status changed: " << ConnectionStatusToString(status);
-  frontend_->OnConnectionStatusChange(status);
+  host_->OnConnectionStatusChange(status);
 }
 
 void SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop(
     std::unique_ptr<ProtocolEvent> event) {
-  frontend_->OnProtocolEvent(*event);
+  DCHECK(thread_checker_.CalledOnValidThread());
+  host_->OnProtocolEvent(*event);
 }
 
 void SyncBackendHostImpl::HandleDirectoryCommitCountersUpdatedOnFrontendLoop(
     ModelType type,
     const CommitCounters& counters) {
-  frontend_->OnDirectoryTypeCommitCounterUpdated(type, counters);
+  DCHECK(thread_checker_.CalledOnValidThread());
+  host_->OnDirectoryTypeCommitCounterUpdated(type, counters);
 }
 
 void SyncBackendHostImpl::HandleDirectoryUpdateCountersUpdatedOnFrontendLoop(
     ModelType type,
     const UpdateCounters& counters) {
-  frontend_->OnDirectoryTypeUpdateCounterUpdated(type, counters);
+  DCHECK(thread_checker_.CalledOnValidThread());
+  host_->OnDirectoryTypeUpdateCounterUpdated(type, counters);
 }
 
 void SyncBackendHostImpl::HandleDirectoryStatusCountersUpdatedOnFrontendLoop(
     ModelType type,
     const StatusCounters& counters) {
-  frontend_->OnDatatypeStatusCounterUpdated(type, counters);
+  DCHECK(thread_checker_.CalledOnValidThread());
+  host_->OnDatatypeStatusCounterUpdated(type, counters);
 }
 
 void SyncBackendHostImpl::UpdateInvalidationVersions(
     const std::map<ModelType, int64_t>& invalidation_versions) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   sync_prefs_->UpdateInvalidationVersions(invalidation_versions);
 }
 
 void SyncBackendHostImpl::RefreshTypesForTest(ModelTypeSet types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncBackendHostCore::DoRefreshTypes, core_, types));
 }
 
@@ skipping 17 matching lines @@
     const SyncManager::ClearServerDataCallback& frontend_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   frontend_callback.Run();
 }
 
 }  // namespace syncer
 
 #undef SDVLOG
 
 #undef SLOG