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

components/sync/driver/glue/sync_backend_host_impl_unittest.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 <cstddef>
 #include <utility>
 
 #include "base/files/file_util.h"
@@ skipping 123 matching lines @@
       ModelSafeGroup group) override {
     switch (group) {
       case GROUP_PASSIVE:
         return new PassiveModelWorker();
       default:
         return nullptr;
     }
   }
 };
 
+class NullEncryptionObserver : public SyncEncryptionHandler::Observer {
+ public:
+  void OnPassphraseRequired(
+      PassphraseRequiredReason reason,
+      const sync_pb::EncryptedData& pending_keys) override {}
+  void OnPassphraseAccepted() override {}
+  void OnBootstrapTokenUpdated(const std::string& bootstrap_token,
+                               BootstrapTokenType type) override {}
+  void OnEncryptedTypesChanged(ModelTypeSet encrypted_types,
+                               bool encrypt_everything) override {}
+  void OnEncryptionComplete() override {}
+  void OnCryptographerStateChanged(Cryptographer* cryptographer) override {}
+  void OnPassphraseTypeChanged(PassphraseType type,
+                               base::Time passphrase_time) override {}
+  void OnLocalSetPassphraseEncryption(
+      const SyncEncryptionHandler::NigoriState& nigori_state) override {}
+};
+
 class SyncEngineTest : public testing::Test {
  protected:
   SyncEngineTest()
       : sync_thread_("SyncThreadForTest"),
         host_(base::Bind(&SyncEngineTest::SetEngineTypes,
                          base::Unretained(this))),
         fake_manager_(nullptr) {}
 
   ~SyncEngineTest() override {}
 
@@ skipping 48 matching lines @@
             base::Bind(&NetworkResources::GetHttpPostProviderFactory,
                        base::Unretained(network_resources_.get()), nullptr,
                        base::Bind(&EmptyNetworkTimeUpdate));
 
     SyncEngine::InitParams params;
     params.sync_task_runner = sync_thread_.task_runner();
     params.host = &host_;
     params.registrar = base::MakeUnique<SyncBackendRegistrar>(
         std::string(), base::Bind(&SyncClient::CreateModelWorkerForGroup,
                                   base::Unretained(&sync_client_)));
+    params.encryption_observer_proxy =
+        base::MakeUnique<NullEncryptionObserver>();
     params.http_factory_getter = http_post_provider_factory_getter;
     params.credentials = credentials_;
     params.sync_manager_factory = std::move(fake_manager_factory_);
     params.delete_sync_data_folder = true;
     params.unrecoverable_error_handler =
         MakeWeakHandle(test_unrecoverable_error_handler_.GetWeakPtr()),
     params.saved_nigori_state = std::move(saved_nigori_state_);
     sync_prefs_->GetInvalidationVersions(&params.invalidation_versions);
 
     backend_->Initialize(std::move(params));
@@ skipping 578 matching lines @@
   backend_->StopSyncingForShutdown();
   // Verify that call to DeactivateNonBlockingDataType doesn't assert.
   backend_->DeactivateNonBlockingDataType(AUTOFILL);
   backend_->Shutdown(STOP_SYNC);
   backend_.reset();
 }
 
 }  // namespace
 
 }  // namespace syncer