Unify Preferences Mojom Naming to PreferencesService

chrome/browser/prefs/preferences_service_unittest.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 "chrome/browser/prefs/preferences_manager.h"
+#include "chrome/browser/prefs/preferences_service.h"
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "components/prefs/pref_service.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "services/preferences/public/interfaces/preferences.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
-// Test implementation of prefs::mojom::PreferencesObserver which just tracks
+// Test implementation of prefs::mojom::PreferencesServiceClient which just
+// tracks
 // calls to OnPreferencesChanged.
-class TestPreferencesObserver : public prefs::mojom::PreferencesObserver {
+class TestPreferencesServiceClient
+    : public prefs::mojom::PreferencesServiceClient {
  public:
-  TestPreferencesObserver(
-      mojo::InterfaceRequest<prefs::mojom::PreferencesObserver> request)
+  TestPreferencesServiceClient(
+      mojo::InterfaceRequest<prefs::mojom::PreferencesServiceClient> request)
       : on_preferences_changed_called_(false),
         binding_(this, std::move(request)) {}
-  ~TestPreferencesObserver() override {}
+  ~TestPreferencesServiceClient() override {}
 
   // Returns true is |key| was in the last set of preferences changed.
   bool KeyReceived(const std::string& key);
 
   // Clears the values set from the last OnPreferencesChanged.
   void Reset();
 
   bool on_preferences_changed_called() {
     return on_preferences_changed_called_;
   }
 
   const base::Value* on_preferences_changed_values() {
     return on_preferences_changed_values_.get();
   }
 
  private:
-  // prefs::mojom::PreferencesObserver:
+  // prefs::mojom::PreferencesServiceClient:
   void OnPreferencesChanged(
       std::unique_ptr<base::DictionaryValue> preferences) override {
     on_preferences_changed_called_ = true;
     on_preferences_changed_values_ = std::move(preferences);
   }
 
   bool on_preferences_changed_called_;
   std::unique_ptr<base::Value> on_preferences_changed_values_;
 
-  mojo::Binding<PreferencesObserver> binding_;
+  mojo::Binding<PreferencesServiceClient> binding_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestPreferencesObserver);
+  DISALLOW_COPY_AND_ASSIGN(TestPreferencesServiceClient);
 };
 
-bool TestPreferencesObserver::KeyReceived(const std::string& key) {
+bool TestPreferencesServiceClient::KeyReceived(const std::string& key) {
   base::DictionaryValue* dictionary = nullptr;
   on_preferences_changed_values_->GetAsDictionary(&dictionary);
   return dictionary->HasKey(key);
 }
 
-void TestPreferencesObserver::Reset() {
+void TestPreferencesServiceClient::Reset() {
   on_preferences_changed_called_ = false;
   on_preferences_changed_values_.reset();
 }
 
 }  // namespace
 
 namespace test {
-class PreferencesManagerTest : public testing::Test {
+class PreferencesServiceTest : public testing::Test {
  public:
-  PreferencesManagerTest();
-  ~PreferencesManagerTest() override;
+  PreferencesServiceTest();
+  ~PreferencesServiceTest() override;
 
-  // Initializes the connection between |observer_| and |manager_|, subscribing
+  // Initializes the connection between |client_| and |service_|, subscribing
   // to changes to |preferences|.
   void InitObserver(const std::vector<std::string>& preferences);
 
   // Initializes a preference with |registry_| with a default |value|.
   void InitPreference(const std::string& key, int value);
 
-  // Has |manager_| update the PrefStore with |preferences|.
+  // Has |service_| update the PrefStore with |preferences|.
   void SetPreferences(std::unique_ptr<base::DictionaryValue> preferences);
 
-  PreferencesManager* manager() { return manager_.get(); }
-  TestPreferencesObserver* observer() { return observer_.get(); }
+  TestPreferencesServiceClient* client() { return client_.get(); }
   PrefChangeRegistrar* preferences_change_registrar() {
-    return manager_->preferences_change_registrar_.get();
+    return service_->preferences_change_registrar_.get();
   }
   TestingProfile* profile() { return profile_; }
   user_prefs::PrefRegistrySyncable* registry() { return registry_; }
   PrefService* service() { return profile_->GetPrefs(); }
 
   // testing::Test:
   void SetUp() override;
   void TearDown() override;
 
  private:
   // Sets up threads needed for |testing_profile_manager_|
   content::TestBrowserThreadBundle thread_bundle_;
 
   // Handles creation of profiles for testing.
   TestingProfileManager testing_profile_manager_;
 
   // Not owned
   TestingProfile* profile_;
   user_prefs::PrefRegistrySyncable* registry_;
 
-  prefs::mojom::PreferencesObserverPtr proxy_;
-  std::unique_ptr<TestPreferencesObserver> observer_;
-  std::unique_ptr<PreferencesManager> manager_;
+  prefs::mojom::PreferencesServiceClientPtr proxy_;
+  std::unique_ptr<TestPreferencesServiceClient> client_;
+  std::unique_ptr<PreferencesService> service_;
 
-  DISALLOW_COPY_AND_ASSIGN(PreferencesManagerTest);
+  DISALLOW_COPY_AND_ASSIGN(PreferencesServiceTest);
 };
 
-PreferencesManagerTest::PreferencesManagerTest()
+PreferencesServiceTest::PreferencesServiceTest()
     : testing_profile_manager_(TestingBrowserProcess::GetGlobal()) {}
 
-PreferencesManagerTest::~PreferencesManagerTest() {}
+PreferencesServiceTest::~PreferencesServiceTest() {}
 
-void PreferencesManagerTest::InitObserver(
+void PreferencesServiceTest::InitObserver(
     const std::vector<std::string>& preferences) {
-  manager_->Subscribe(preferences);
+  service_->Subscribe(preferences);
   base::RunLoop().RunUntilIdle();
 }
 
-void PreferencesManagerTest::InitPreference(const std::string& key, int value) {
+void PreferencesServiceTest::InitPreference(const std::string& key, int value) {
   registry_->RegisterIntegerPref(key, value);
   base::FundamentalValue fundamental_value(value);
   profile_->GetPrefs()->Set(key, fundamental_value);
 }
 
-void PreferencesManagerTest::SetPreferences(
+void PreferencesServiceTest::SetPreferences(
     std::unique_ptr<base::DictionaryValue> preferences) {
-  manager_->SetPreferences(std::move(preferences));
+  service_->SetPreferences(std::move(preferences));
   base::RunLoop().RunUntilIdle();
 }
 
-void PreferencesManagerTest::SetUp() {
+void PreferencesServiceTest::SetUp() {
   ASSERT_TRUE(testing_profile_manager_.SetUp());
 
   std::unique_ptr<sync_preferences::TestingPrefServiceSyncable> service(
       base::MakeUnique<sync_preferences::TestingPrefServiceSyncable>());
   registry_ = service->registry();
   chrome::RegisterUserProfilePrefs(registry_);
 
   const std::string kName = "navi";
   profile_ = testing_profile_manager_.CreateTestingProfile(
       kName, std::move(service), base::UTF8ToUTF16(kName), 0, std::string(),
       TestingProfile::TestingFactories());
   ASSERT_NE(nullptr, profile_->GetPrefs());
 
-  observer_.reset(new TestPreferencesObserver(mojo::MakeRequest(&proxy_)));
-  manager_ = base::MakeUnique<PreferencesManager>(std::move(proxy_), profile_);
-  ASSERT_TRUE(manager_->preferences_change_registrar_->IsEmpty());
+  client_.reset(new TestPreferencesServiceClient(mojo::MakeRequest(&proxy_)));
+  service_ = base::MakeUnique<PreferencesService>(std::move(proxy_), profile_);
+  ASSERT_TRUE(service_->preferences_change_registrar_->IsEmpty());
 }
 
-void PreferencesManagerTest::TearDown() {
+void PreferencesServiceTest::TearDown() {
   testing_profile_manager_.DeleteAllTestingProfiles();
 }
 
 // Tests that when the PrefService is empty that no subscriptions are made.
-TEST_F(PreferencesManagerTest, EmptyService) {
+TEST_F(PreferencesServiceTest, EmptyService) {
   const std::string kKey = "hey";
   std::vector<std::string> preferences;
   preferences.push_back(kKey);
   InitObserver(preferences);
   EXPECT_FALSE(preferences_change_registrar()->IsObserved(kKey));
-  EXPECT_FALSE(observer()->on_preferences_changed_called());
+  EXPECT_FALSE(client()->on_preferences_changed_called());
 }
 
 // Tests that when the PrefService has the desired key, that a subscription is
 // setup and that the PreferenceObserver is notified.
-TEST_F(PreferencesManagerTest, ServiceHasValues) {
+TEST_F(PreferencesServiceTest, ServiceHasValues) {
   const std::string kKey = "hey";
   const int kValue = 42;
   InitPreference(kKey, kValue);
 
   std::vector<std::string> preferences;
   preferences.push_back(kKey);
   InitObserver(preferences);
   EXPECT_TRUE(preferences_change_registrar()->IsObserved(kKey));
-  EXPECT_TRUE(observer()->on_preferences_changed_called());
-  EXPECT_TRUE(observer()->KeyReceived(kKey));
+  EXPECT_TRUE(client()->on_preferences_changed_called());
+  EXPECT_TRUE(client()->KeyReceived(kKey));
 }
 
 // Tests that mulitple keys can be subscribed to.
-TEST_F(PreferencesManagerTest, MultipleSubscriptions) {
+TEST_F(PreferencesServiceTest, MultipleSubscriptions) {
   const std::string kKey1 = "hey";
   const int kValue1 = 42;
   InitPreference(kKey1, kValue1);
 
   const std::string kKey2 = "listen";
   const int kValue2 = 9001;
   InitPreference(kKey2, kValue2);
 
   std::vector<std::string> preferences;
   preferences.push_back(kKey1);
   preferences.push_back(kKey2);
   InitObserver(preferences);
   EXPECT_TRUE(preferences_change_registrar()->IsObserved(kKey1));
   EXPECT_TRUE(preferences_change_registrar()->IsObserved(kKey2));
-  EXPECT_TRUE(observer()->KeyReceived(kKey1));
-  EXPECT_TRUE(observer()->KeyReceived(kKey2));
+  EXPECT_TRUE(client()->KeyReceived(kKey1));
+  EXPECT_TRUE(client()->KeyReceived(kKey2));
 }
 
 // Tests that when all keys are not in the PrefService that subscriptions are
 // set for the available key.
-TEST_F(PreferencesManagerTest, PartialSubsriptionAvailable) {
+TEST_F(PreferencesServiceTest, PartialSubsriptionAvailable) {
   const std::string kKey1 = "hey";
   const int kValue1 = 42;
   InitPreference(kKey1, kValue1);
 
   const std::string kKey2 = "listen";
   std::vector<std::string> preferences;
   preferences.push_back(kKey1);
   preferences.push_back(kKey2);
   InitObserver(preferences);
   EXPECT_TRUE(preferences_change_registrar()->IsObserved(kKey1));
   EXPECT_FALSE(preferences_change_registrar()->IsObserved(kKey2));
-  EXPECT_TRUE(observer()->KeyReceived(kKey1));
-  EXPECT_FALSE(observer()->KeyReceived(kKey2));
+  EXPECT_TRUE(client()->KeyReceived(kKey1));
+  EXPECT_FALSE(client()->KeyReceived(kKey2));
 }
 
 // Tests that when a preference is changed that the PreferenceObserver is
 // notified.
-TEST_F(PreferencesManagerTest, PreferenceChanged) {
+TEST_F(PreferencesServiceTest, PreferenceChanged) {
   const std::string kKey = "hey";
   const int kValue = 42;
   InitPreference(kKey, kValue);
 
   std::vector<std::string> preferences;
   preferences.push_back(kKey);
   InitObserver(preferences);
-  observer()->Reset();
+  client()->Reset();
 
   const int kNewValue = 1337;
   service()->SetInteger(kKey, kNewValue);
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_TRUE(observer()->on_preferences_changed_called());
-  const base::Value* values = observer()->on_preferences_changed_values();
+  EXPECT_TRUE(client()->on_preferences_changed_called());
+  const base::Value* values = client()->on_preferences_changed_values();
   const base::DictionaryValue* dictionary = nullptr;
   values->GetAsDictionary(&dictionary);
   int result = 0;
   dictionary->GetInteger(kKey, &result);
   EXPECT_EQ(kNewValue, result);
 }
 
 // Tests that when a non subscribed preference is changed that the
 // PreferenceObserver is not notified.
-TEST_F(PreferencesManagerTest, UnrelatedPreferenceChanged) {
+TEST_F(PreferencesServiceTest, UnrelatedPreferenceChanged) {
   const std::string kKey1 = "hey";
   const int kValue1 = 42;
   InitPreference(kKey1, kValue1);
 
   const std::string kKey2 = "listen";
   const int kValue2 = 9001;
   InitPreference(kKey2, kValue2);
 
   std::vector<std::string> preferences;
   preferences.push_back(kKey1);
   InitObserver(preferences);
-  observer()->Reset();
+  client()->Reset();
 
   const int kNewValue = 1337;
   service()->SetInteger(kKey2, kNewValue);
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_FALSE(observer()->on_preferences_changed_called());
+  EXPECT_FALSE(client()->on_preferences_changed_called());
 }
 
 // Tests that when the PreferenceManager updates a preference that the
 // PreferenceObserver is not notified.
-TEST_F(PreferencesManagerTest, NoNotificationsForSelfChange) {
+TEST_F(PreferencesServiceTest, NoNotificationsForSelfChange) {
   const std::string kKey = "hey";
   const int kValue = 42;
   InitPreference(kKey, kValue);
 
   std::vector<std::string> preferences;
   preferences.push_back(kKey);
   InitObserver(preferences);
-  observer()->Reset();
+  client()->Reset();
 
   const int kNewValue = 1337;
   std::unique_ptr<base::DictionaryValue> dictionary =
       base::MakeUnique<base::DictionaryValue>();
   dictionary->SetInteger(kKey, kNewValue);
   SetPreferences(std::move(dictionary));
 
-  EXPECT_FALSE(observer()->on_preferences_changed_called());
+  EXPECT_FALSE(client()->on_preferences_changed_called());
   EXPECT_EQ(kNewValue, service()->GetInteger(kKey));
 }
 
 }  // namespace test