[Sync] Split encryption state and logic out of PSS and SBHI.

components/sync/driver/sync_service_base.cc

 // Copyright 2016 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/sync_service_base.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 46 matching lines @@
                                  const version_info::Channel& channel,
                                  const base::FilePath& base_directory,
                                  const std::string& debug_identifier)
     : sync_client_(std::move(sync_client)),
       signin_(std::move(signin)),
       channel_(channel),
       base_directory_(base_directory),
       sync_data_folder_(
           base_directory_.Append(base::FilePath(kSyncDataFolderName))),
       debug_identifier_(debug_identifier),
-      sync_prefs_(sync_client_->GetPrefService()) {}
+      sync_prefs_(sync_client_->GetPrefService()) {
+  ResetCryptoState();
+}
 
 SyncServiceBase::~SyncServiceBase() = default;
 
+void SyncServiceBase::AddObserver(SyncServiceObserver* observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  observers_.AddObserver(observer);
+}
+
+void SyncServiceBase::RemoveObserver(SyncServiceObserver* observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  observers_.RemoveObserver(observer);
+}
+
+bool SyncServiceBase::HasObserver(const SyncServiceObserver* observer) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return observers_.HasObserver(observer);
+}
+
+void SyncServiceBase::NotifyObservers() {
+  for (auto& observer : observers_) {
+    observer.OnStateChanged();
+  }
+}
+
 void SyncServiceBase::InitializeEngine() {
   DCHECK(engine_);
 
   if (!sync_thread_) {
     sync_thread_ = base::MakeUnique<base::Thread>("Chrome_SyncThread");
     base::Thread::Options options;
     options.timer_slack = base::TIMER_SLACK_MAXIMUM;
     CHECK(sync_thread_->StartWithOptions(options));
   }
 
   SyncEngine::InitParams params;
   params.sync_task_runner = sync_thread_->task_runner();
   params.host = this;
   params.registrar = base::MakeUnique<SyncBackendRegistrar>(
       debug_identifier_, base::Bind(&SyncClient::CreateModelWorkerForGroup,
                                     base::Unretained(sync_client_.get())));
+  params.encryption_observer_proxy = crypto_->GetEncryptionObserverProxy();
   params.extensions_activity = sync_client_->GetExtensionsActivity();
   params.event_handler = GetJsEventHandler();
   params.service_url = sync_service_url();
   params.sync_user_agent = GetLocalDeviceInfoProvider()->GetSyncUserAgent();
   params.http_factory_getter = MakeHttpPostProviderFactoryGetter();
   params.credentials = GetCredentials();
   invalidation::InvalidationService* invalidator =
       sync_client_->GetInvalidationService();
   params.invalidator_client_id =
       invalidator ? invalidator->GetInvalidatorClientId() : "",
   params.sync_manager_factory = base::MakeUnique<SyncManagerFactory>();
   // The first time we start up the engine we want to ensure we have a clean
   // directory, so delete any old one that might be there.
   params.delete_sync_data_folder = !IsFirstSetupComplete();
   params.enable_local_sync_backend =
       GetLocalSyncConfig(&params.local_sync_backend_folder);
   params.restored_key_for_bootstrapping =
       sync_prefs_.GetEncryptionBootstrapToken();
   params.restored_keystore_key_for_bootstrapping =
       sync_prefs_.GetKeystoreEncryptionBootstrapToken();
   params.engine_components_factory =
       base::MakeUnique<EngineComponentsFactoryImpl>(
           EngineSwitchesFromCommandLine());
   params.unrecoverable_error_handler = GetUnrecoverableErrorHandler();
   params.report_unrecoverable_error_function =
       base::Bind(ReportUnrecoverableError, channel_);
-  params.saved_nigori_state = MoveSavedNigoriState();
+  params.saved_nigori_state = crypto_->TakeSavedNigoriState();
   sync_prefs_.GetInvalidationVersions(&params.invalidation_versions);
 
   engine_->Initialize(std::move(params));
 }
 
 bool SyncServiceBase::GetLocalSyncConfig(
     base::FilePath* local_sync_backend_folder) const {
   bool enable_local_sync_backend = false;
   *local_sync_backend_folder = sync_prefs_.GetLocalSyncBackendDir();
 #if defined(OS_WIN)
@@ skipping 14 matching lines @@
   // considered roamed.
   // See http://crbug.com/674928.
   *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)
   return enable_local_sync_backend;
 }
 
+void SyncServiceBase::ResetCryptoState() {
+  crypto_ = base::MakeUnique<SyncServiceCrypto>(
+      base::BindRepeating(&SyncServiceBase::NotifyObservers,
+                          base::Unretained(this)),
+      base::BindRepeating(&SyncService::GetPreferredDataTypes,
+                          base::Unretained(this)),
+      &sync_prefs_);
+}
+
 }  // namespace syncer