Unify Preferences Mojom Naming to PreferencesService

chrome/browser/prefs/preferences_service_unittest.cc

Index: chrome/browser/prefs/preferences_service_unittest.cc
diff --git a/chrome/browser/prefs/preferences_manager_unittest.cc b/chrome/browser/prefs/preferences_service_unittest.cc
similarity index 71%
rename from chrome/browser/prefs/preferences_manager_unittest.cc
rename to chrome/browser/prefs/preferences_service_unittest.cc
index 73302cca7cda98b4c11393be0a8dda5a12348704..02b4ce82aa8922b70cd33f66f09c86203f582fc0 100644
--- a/chrome/browser/prefs/preferences_manager_unittest.cc
+++ b/chrome/browser/prefs/preferences_service_unittest.cc
@@ -2,7 +2,7 @@
 // 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"
@@ -24,15 +24,17 @@
 
 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);
@@ -49,7 +51,7 @@ class TestPreferencesObserver : public prefs::mojom::PreferencesObserver {
   }
 
  private:
-  // prefs::mojom::PreferencesObserver:
+  // prefs::mojom::PreferencesServiceClient:
   void OnPreferencesChanged(
       std::unique_ptr<base::DictionaryValue> preferences) override {
     on_preferences_changed_called_ = true;
@@ -59,18 +61,18 @@ class TestPreferencesObserver : public prefs::mojom::PreferencesObserver {
   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();
 }
@@ -78,25 +80,24 @@ void TestPreferencesObserver::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_; }
@@ -117,37 +118,37 @@ class PreferencesManagerTest : public testing::Test {
   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(
@@ -161,28 +162,28 @@ void PreferencesManagerTest::SetUp() {
       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);
@@ -191,12 +192,12 @@ TEST_F(PreferencesManagerTest, ServiceHasValues) {
   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);
@@ -211,13 +212,13 @@ TEST_F(PreferencesManagerTest, MultipleSubscriptions) {
   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);
@@ -229,13 +230,13 @@ TEST_F(PreferencesManagerTest, PartialSubsriptionAvailable) {
   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);
@@ -243,14 +244,14 @@ TEST_F(PreferencesManagerTest, PreferenceChanged) {
   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;
@@ -260,7 +261,7 @@ TEST_F(PreferencesManagerTest, PreferenceChanged) {
 
 // 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);
@@ -272,18 +273,18 @@ TEST_F(PreferencesManagerTest, UnrelatedPreferenceChanged) {
   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);
@@ -291,7 +292,7 @@ TEST_F(PreferencesManagerTest, NoNotificationsForSelfChange) {
   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 =
@@ -299,7 +300,7 @@ TEST_F(PreferencesManagerTest, NoNotificationsForSelfChange) {
   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));
 }