Add PrefStore::GetValues

components/user_prefs/tracked/segregated_pref_store_unittest.cc

 // Copyright 2014 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/user_prefs/tracked/segregated_pref_store.h"
 
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/values.h"
 #include "components/prefs/persistent_pref_store.h"
 #include "components/prefs/pref_store_observer_mock.h"
 #include "components/prefs/testing_pref_store.h"
 #include "components/user_prefs/tracked/segregated_pref_store.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kSelectedPref[] = "selected_pref";
 const char kUnselectedPref[] = "unselected_pref";
+const char kSharedPref[] = "shared_pref";
 
 const char kValue1[] = "value1";
 const char kValue2[] = "value2";
 
 class MockReadErrorDelegate : public PersistentPrefStore::ReadErrorDelegate {
  public:
   struct Data {
     Data(bool invoked_in, PersistentPrefStore::PrefReadError read_error_in)
         : invoked(invoked_in), read_error(read_error_in) {}
 
@@ skipping 26 matching lines @@
                                   PersistentPrefStore::PREF_READ_ERROR_NONE),
         read_error_delegate_(
             new MockReadErrorDelegate(&read_error_delegate_data_)) {}
 
   void SetUp() override {
     selected_store_ = new TestingPrefStore;
     default_store_ = new TestingPrefStore;
 
     std::set<std::string> selected_pref_names;
     selected_pref_names.insert(kSelectedPref);
+    selected_pref_names.insert(kSharedPref);
 
     segregated_store_ = new SegregatedPrefStore(default_store_, selected_store_,
                                                 selected_pref_names);
 
     segregated_store_->AddObserver(&observer_);
   }
 
   void TearDown() override { segregated_store_->RemoveObserver(&observer_); }
 
  protected:
@@ skipping 184 matching lines @@
   selected_store_->SetBlockAsyncRead(true);
   default_store_->SetBlockAsyncRead(true);
   EXPECT_FALSE(segregated_store_->IsInitializationComplete());
   segregated_store_->ReadPrefsAsync(NULL);
   EXPECT_FALSE(segregated_store_->IsInitializationComplete());
   selected_store_->SetBlockAsyncRead(false);
   EXPECT_FALSE(segregated_store_->IsInitializationComplete());
   default_store_->SetBlockAsyncRead(false);
   EXPECT_TRUE(segregated_store_->IsInitializationComplete());
 }
+
+TEST_F(SegregatedPrefStoreTest, GetValues) {
+  // To check merge behavior, create selected and default stores so each has a
+  // key the other doesn't have and they have one key in common.
+  selected_store_->SetValue(kSelectedPref,
+                            base::MakeUnique<base::StringValue>(kValue1),
+                            WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+  default_store_->SetValue(kUnselectedPref,
+                           base::MakeUnique<base::StringValue>(kValue2),
+                           WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+  selected_store_->SetValue(kSharedPref,
+                            base::MakeUnique<base::StringValue>(kValue1),
+                            WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+
+  auto values = segregated_store_->GetValues();
+  const base::Value* value = nullptr;
+  // Check that a selected preference is returned.
+  ASSERT_TRUE(values->Get(kSelectedPref, &value));
+  EXPECT_TRUE(base::FundamentalValue(kValue1).Equals(value));
+
+  // Check that a a default preference is returned.
+  ASSERT_TRUE(values->Get(kUnselectedPref, &value));
+  EXPECT_TRUE(base::FundamentalValue(kValue2).Equals(value));
+
+  // Check that the selected preference is preferred.
+  ASSERT_TRUE(values->Get(kSharedPref, &value));
+  EXPECT_TRUE(base::FundamentalValue(kValue1).Equals(value));
+}