[Smart Lock, Prefs reconciliation] Prefs migration logic for desktop platforms.

chrome/browser/sync/test/integration/single_client_password_manager_setting_migrater_service_sync_test.cc

Index: chrome/browser/sync/test/integration/single_client_password_manager_setting_migrater_service_sync_test.cc
diff --git a/chrome/browser/sync/test/integration/single_client_password_manager_setting_migrater_service_sync_test.cc b/chrome/browser/sync/test/integration/single_client_password_manager_setting_migrater_service_sync_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d4f19495120d091b2e5930b823bbe890adbeabce
--- /dev/null
+++ b/chrome/browser/sync/test/integration/single_client_password_manager_setting_migrater_service_sync_test.cc
@@ -0,0 +1,256 @@
+// Copyright (c) 2015 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 "base/guid.h"
+#include "base/json/json_string_value_serializer.h"
+#include "base/metrics/field_trial.h"
+#include "base/prefs/pref_service.h"
+#include "base/test/mock_entropy_provider.h"
+#include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/password_manager/password_manager_setting_migrater_service.h"
+#include "chrome/browser/prefs/pref_service_syncable.h"
+#include "chrome/browser/sync/test/integration/password_manager_setting_migrater_helper.h"
+#include "chrome/browser/sync/test/integration/preferences_helper.h"
+#include "chrome/browser/sync/test/integration/profile_sync_service_harness.h"
+#include "chrome/browser/sync/test/integration/sync_integration_test_util.h"
+#include "chrome/browser/sync/test/integration/sync_test.h"
+#include "chrome/common/pref_names.h"
+#include "components/password_manager/core/common/password_manager_pref_names.h"
+#include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_source.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "sync/internal_api/public/base/model_type.h"
+#include "sync/protocol/preference_specifics.pb.h"
+#include "sync/protocol/priority_preference_specifics.pb.h"
+#include "sync/protocol/sync.pb.h"
+#include "sync/test/fake_server/unique_client_entity.h"
+
+using password_manager_setting_migrater_helper::AssertPrefValuesOnClient;
+using preferences_helper::AwaitBooleanPrefMatches;
+using preferences_helper::BooleanPrefMatches;
+using preferences_helper::ChangeBooleanPref;
+using preferences_helper::GetPrefs;
+
+namespace {
+
+void InjectDataToFakeServer(fake_server::FakeServer* fake_server,
+                            const std::string& name,
+                            bool value) {
+  std::string serialized;
+  JSONStringValueSerializer json(&serialized);
+  base::FundamentalValue bool_value(value);
+  json.Serialize(bool_value);
+  sync_pb::EntitySpecifics specifics;
+  sync_pb::PreferenceSpecifics* pref = nullptr;
+  if (name == password_manager::prefs::kPasswordManagerSavingEnabled) {
+    pref = specifics.mutable_preference();
+  } else if (name == password_manager::prefs::kCredentialsEnableService) {
+    pref = specifics.mutable_priority_preference()->mutable_preference();
+  } else {
+    NOTREACHED() << "Wrong preference name: " << name;
+  }
+  pref->set_name(name);
+  pref->set_value(serialized);
+  const std::string id = "settings_reconciliation";
+  fake_server->InjectEntity(
+      fake_server::UniqueClientEntity::CreateForInjection(id, specifics));
+}
+
+class SyncStateObserver : public PrefServiceSyncableObserver {
+ public:
+  SyncStateObserver() : profile_(nullptr) {}
+
+  ~SyncStateObserver() override {}
+
+  void InitWithProfile(Profile* profile) {
+    profile_ = profile;
+    PrefServiceSyncable* prefs = PrefServiceSyncable::FromProfile(profile_);
+    prefs->AddObserver(this);
+  }
+
+  void OnIsSyncingChanged() override {
+    PrefServiceSyncable* prefs = PrefServiceSyncable::FromProfile(profile_);
+    if (!prefs->IsSyncing() && !prefs->IsPrioritySyncing()) {
+      prefs->RemoveObserver(this);
+      password_manager_setting_migrater_helper::SendProfileAddNotification(
+          profile_);
+    }
+  }
+
+ private:
+  Profile* profile_;
+
+  DISALLOW_COPY_AND_ASSIGN(SyncStateObserver);
+};
+
+}  // namespace
+
+class SingleClientPasswordManagerSettingMigraterServiceSyncTest
+    : public SyncTest {
+ public:
+  SingleClientPasswordManagerSettingMigraterServiceSyncTest()
+      : SyncTest(SINGLE_CLIENT) {}
+
+  ~SingleClientPasswordManagerSettingMigraterServiceSyncTest() override {}
+
+  void AssertPrefValues(bool new_pref_value, bool old_pref_value) {
+    AssertPrefValuesOnClient(0, new_pref_value, old_pref_value);
+  }
+
+  void SetLocalPrefValues(bool new_pref_local_value,
+                          bool old_pref_local_value) {
+    using namespace password_manager::prefs;
+    PrefService* prefs = GetPrefs(0);
+    prefs->SetBoolean(kCredentialsEnableService, new_pref_local_value);
+    prefs->SetBoolean(kPasswordManagerSavingEnabled, old_pref_local_value);
+    AssertPrefValues(new_pref_local_value, old_pref_local_value);
+  }
+
+  void InjectNewValues(bool new_pref_sync_value, bool old_pref_sync_value) {
+    using namespace password_manager::prefs;
+    InjectDataToFakeServer(GetFakeServer(), kCredentialsEnableService,
+                           new_pref_sync_value);
+    InjectDataToFakeServer(GetFakeServer(), kPasswordManagerSavingEnabled,
+                           old_pref_sync_value);
+  }
+
+  void InitMigrationService() {
+    trial_ = password_manager_setting_migrater_helper::MigrationFieldTrial();
+    sync_state_observer_.InitWithProfile(GetProfile(0));
+  }
+
+ private:
+  SyncStateObserver sync_state_observer_;
+  scoped_refptr<base::FieldTrial> trial_;
+
+  DISALLOW_COPY_AND_ASSIGN(
+      SingleClientPasswordManagerSettingMigraterServiceSyncTest);
+};
+
+IN_PROC_BROWSER_TEST_F(
+    SingleClientPasswordManagerSettingMigraterServiceSyncTest,
+    LocalOnOnSyncOffOff) {
+  ASSERT_TRUE(SetupClients());
+  SetLocalPrefValues(true /* kCredentialsEnableService */,
+                     true /* kPasswordManagerSavingEnabled */);
+  InjectNewValues(false /* kCredentialsEnableService */,
+                  false /* kPasswordManagerSavingEnabled */);
+  InitMigrationService();
+  ASSERT_TRUE(SetupSync());
+  ASSERT_TRUE(sync_integration_test_util::AwaitCommitActivityCompletion(
+      GetSyncService((0))));
+  AssertPrefValues(false /* kCredentialsEnableService */,
+                   false /* kPasswordManagerSavingEnabled */);
+}
+
+IN_PROC_BROWSER_TEST_F(
+    SingleClientPasswordManagerSettingMigraterServiceSyncTest,
+    LocalOnOnSyncOnOff) {
+  ASSERT_TRUE(SetupClients());
+  InjectNewValues(true /* kCredentialsEnableService */,
+                  false /* kPasswordManagerSavingEnabled */);
+  InitMigrationService();
+  ASSERT_TRUE(SetupSync());
+  ASSERT_TRUE(sync_integration_test_util::AwaitCommitActivityCompletion(
+      GetSyncService((0))));
+  AssertPrefValues(false /* kCredentialsEnableService */,
+                   false /* kPasswordManagerSavingEnabled */);
+}
+
+IN_PROC_BROWSER_TEST_F(
+    SingleClientPasswordManagerSettingMigraterServiceSyncTest,
+    LocalOnOnSyncOffOn) {
+  ASSERT_TRUE(SetupClients());
+  SetLocalPrefValues(true /* kCredentialsEnableService */,
+                     true /* kPasswordManagerSavingEnabled */);
+  InjectNewValues(false /* kCredentialsEnableService */,
+                  true /* kPasswordManagerSavingEnabled */);
+  InitMigrationService();
+  ASSERT_TRUE(SetupSync());
+  ASSERT_TRUE(sync_integration_test_util::AwaitCommitActivityCompletion(
+      GetSyncService((0))));
+  AssertPrefValues(false /* kCredentialsEnableService */,
+                   false /* kPasswordManagerSavingEnabled */);
+}
+
+IN_PROC_BROWSER_TEST_F(
+    SingleClientPasswordManagerSettingMigraterServiceSyncTest,
+    LocalOnOffSyncOnOn) {
+  ASSERT_TRUE(SetupClients());
+  SetLocalPrefValues(true /* kCredentialsEnableService */,
+                     false /* kPasswordManagerSavingEnabled */);
+  InjectNewValues(true /* kCredentialsEnableService */,
+                  true /* kPasswordManagerSavingEnabled */);
+  InitMigrationService();
+  ASSERT_TRUE(SetupSync());
+  ASSERT_TRUE(sync_integration_test_util::AwaitCommitActivityCompletion(
+      GetSyncService((0))));
+  AssertPrefValues(true /* kCredentialsEnableService */,
+                   true /* kPasswordManagerSavingEnabled */);
+}
+
+IN_PROC_BROWSER_TEST_F(
+    SingleClientPasswordManagerSettingMigraterServiceSyncTest,
+    LocalOnOffSyncOnOff) {
+  ASSERT_TRUE(SetupClients());
+  SetLocalPrefValues(true /* kCredentialsEnableService */,
+                     false /* kPasswordManagerSavingEnabled */);
+  InjectNewValues(true /* kCredentialsEnableService */,
+                  false /* kPasswordManagerSavingEnabled */);
+  InitMigrationService();
+  ASSERT_TRUE(SetupSync());
+  ASSERT_TRUE(sync_integration_test_util::AwaitCommitActivityCompletion(
+      GetSyncService((0))));
+  AssertPrefValues(false /* kCredentialsEnableService */,
+                   false /* kPasswordManagerSavingEnabled */);
+}
+
+IN_PROC_BROWSER_TEST_F(
+    SingleClientPasswordManagerSettingMigraterServiceSyncTest,
+    LocalOnOffSyncOffOn) {
+  ASSERT_TRUE(SetupClients());
+  SetLocalPrefValues(true /* kCredentialsEnableService */,
+                     false /* kPasswordManagerSavingEnabled */);
+  InjectNewValues(false /* kCredentialsEnableService */,
+                  true /* kPasswordManagerSavingEnabled */);
+  InitMigrationService();
+  ASSERT_TRUE(SetupSync());
+  ASSERT_TRUE(sync_integration_test_util::AwaitCommitActivityCompletion(
+      GetSyncService((0))));
+  AssertPrefValues(false /* kCredentialsEnableService */,
+                   false /* kPasswordManagerSavingEnabled */);
+}
+
+IN_PROC_BROWSER_TEST_F(
+    SingleClientPasswordManagerSettingMigraterServiceSyncTest,
+    LocalOffOffSyncOffOn) {
+  ASSERT_TRUE(SetupClients());
+  SetLocalPrefValues(false /* kCredentialsEnableService */,
+                     false /* kPasswordManagerSavingEnabled */);
+  InjectNewValues(false /* kCredentialsEnableService */,
+                  true /* kPasswordManagerSavingEnabled */);
+  InitMigrationService();
+  ASSERT_TRUE(SetupSync());
+  ASSERT_TRUE(sync_integration_test_util::AwaitCommitActivityCompletion(
+      GetSyncService((0))));
+  AssertPrefValues(true /* kCredentialsEnableService */,
+                   true /* kPasswordManagerSavingEnabled */);
+}
+
+IN_PROC_BROWSER_TEST_F(
+    SingleClientPasswordManagerSettingMigraterServiceSyncTest,
+    LocalOffOffSyncOnOff) {
+  ASSERT_TRUE(SetupClients());
+  SetLocalPrefValues(false /* kCredentialsEnableService */,
+                     false /* kPasswordManagerSavingEnabled */);
+  InjectNewValues(true /* kCredentialsEnableService */,
+                  false /* kPasswordManagerSavingEnabled */);
+  InitMigrationService();
+  ASSERT_TRUE(SetupSync());
+  ASSERT_TRUE(sync_integration_test_util::AwaitCommitActivityCompletion(
+      GetSyncService((0))));
+  AssertPrefValues(true /* kCredentialsEnableService */,
+                   true /* kPasswordManagerSavingEnabled */);
+}