Switch Preferences to use Factory

services/preferences/public/cpp/tests/pref_observer_store_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 "services/preferences/public/cpp/pref_observer_store.h"
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "components/prefs/pref_store_observer_mock.h"
 #include "services/preferences/public/interfaces/preferences.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // Test implmentation of prefs::mojom::PreferenceManager which simply tracks
 // calls. Allows for testing to be done in process, without mojo IPC.
 class TestPreferenceManager : public prefs::mojom::PreferencesManager {
  public:
   TestPreferenceManager(
       mojo::InterfaceRequest<prefs::mojom::PreferencesManager> request)
-      : add_observer_called_(false),
-        set_preferences_called_(false),
-        binding_(this, std::move(request)) {}
+      : set_preferences_called_(false), binding_(this, std::move(request)) {}
   ~TestPreferenceManager() override {}
 
-  bool add_observer_called() { return add_observer_called_; }
   const std::set<std::string>& last_preference_set() {
     return last_preference_set_;
   }
   bool set_preferences_called() { return set_preferences_called_; }
 
   // prefs::mojom::TestPreferenceManager:
-  void AddObserver(prefs::mojom::PreferencesObserverPtr client) override;
   void SetPreferences(
       std::unique_ptr<base::DictionaryValue> preferences) override;
   void Subscribe(const std::vector<std::string>& preferences) override;
 
  private:
-  bool add_observer_called_;
   std::set<std::string> last_preference_set_;
   bool set_preferences_called_;
-  mojo::Binding<PreferencesManager> binding_;
+  mojo::Binding<prefs::mojom::PreferencesManager> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPreferenceManager);
 };
 
-void TestPreferenceManager::AddObserver(
-    prefs::mojom::PreferencesObserverPtr client) {
-  add_observer_called_ = true;
-}
-
 void TestPreferenceManager::SetPreferences(
     std::unique_ptr<base::DictionaryValue> preferences) {
   set_preferences_called_ = true;
 }
 
 void TestPreferenceManager::Subscribe(
     const std::vector<std::string>& preferences) {
   last_preference_set_.clear();
   last_preference_set_.insert(preferences.begin(), preferences.end());
 }
 
+// Test implementation of prefs::mojom::PreferencesFactory which simply creates
+// the TestPreferenceManager used for testing.
+class TestPreferenceFactory : public prefs::mojom::PreferencesFactory {
+ public:
+  TestPreferenceFactory(
+      mojo::InterfaceRequest<prefs::mojom::PreferencesFactory> request)
+      : binding_(this, std::move(request)) {}
+  ~TestPreferenceFactory() override {}
+
+  TestPreferenceManager* manager() { return manager_.get(); }
+
+  void Create(prefs::mojom::PreferencesObserverPtr observer,
+              prefs::mojom::PreferencesManagerRequest manager) override;
+
+ private:
+  mojo::Binding<prefs::mojom::PreferencesFactory> binding_;
+  std::unique_ptr<TestPreferenceManager> manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestPreferenceFactory);
+};
+
+void TestPreferenceFactory::Create(
+    prefs::mojom::PreferencesObserverPtr observer,
+    prefs::mojom::PreferencesManagerRequest manager) {
+  manager_.reset(new TestPreferenceManager(std::move(manager)));
+}
+
 }  // namespace
 
 namespace preferences {
 
 class PrefObserverStoreTest : public testing::Test {
  public:
   PrefObserverStoreTest() {}
   ~PrefObserverStoreTest() override {}
 
-  TestPreferenceManager* manager() { return manager_.get(); }
+  TestPreferenceManager* manager() { return factory_->manager(); }
   PrefStoreObserverMock* observer() { return &observer_; }
   PrefObserverStore* store() { return store_.get(); }
 
   bool Initialized() { return store_->initialized_; }
   void OnPreferencesChanged(const base::DictionaryValue& preferences) {
     store_->OnPreferencesChanged(preferences.CreateDeepCopy());
   }
 
   // testing::Test:
   void SetUp() override;
   void TearDown() override;
 
  private:
   scoped_refptr<PrefObserverStore> store_;
-  prefs::mojom::PreferencesManagerPtr proxy_;
-  std::unique_ptr<TestPreferenceManager> manager_;
+  prefs::mojom::PreferencesFactoryPtr factory_proxy_;
+  std::unique_ptr<TestPreferenceFactory> factory_;
   PrefStoreObserverMock observer_;
   // Required by mojo binding code within PrefObserverStore.
   base::MessageLoop message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefObserverStoreTest);
 };
 
 void PrefObserverStoreTest::SetUp() {
-  manager_.reset(new TestPreferenceManager(mojo::MakeRequest(&proxy_)));
-  store_ = new PrefObserverStore(std::move(proxy_));
+  factory_.reset(new TestPreferenceFactory(mojo::MakeRequest(&factory_proxy_)));
+  store_ = new PrefObserverStore(std::move(factory_proxy_));
+  base::RunLoop().RunUntilIdle();
   store_->AddObserver(&observer_);
 }
 
 void PrefObserverStoreTest::TearDown() {
   store_->RemoveObserver(&observer_);
 }
 
 // Tests that observers are notified upon the completion of initialization, and
 // that values become available.
 TEST_F(PrefObserverStoreTest, Initialization) {
@@ skipping 271 matching lines @@
   EXPECT_TRUE(observer2.initialized);
   EXPECT_TRUE(observer()->initialization_success);
   EXPECT_TRUE(observer2.initialization_success);
   observer()->VerifyAndResetChangedKey(key);
   observer2.VerifyAndResetChangedKey(key);
 
   store()->RemoveObserver(&observer2);
 }
 
 }  // namespace preferences