Provide access to recommended pref values

chrome/browser/prefs/pref_value_store_unittest.cc

 // Copyright (c) 2012 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 <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_model_associator.h"
@@ skipping 251 matching lines @@
 
   // Test getting a preference value that the |PrefValueStore|
   // does not contain.
   base::FundamentalValue tmp_dummy_value(true);
   value = &tmp_dummy_value;
   ASSERT_FALSE(pref_value_store_->GetValue(prefs::kMissingPref,
                                            Value::TYPE_STRING, &value));
   ASSERT_TRUE(value == NULL);
 }
 
+TEST_F(PrefValueStoreTest, GetRecommendedValue) {
+  const Value* value;
+
+  // The following tests read a value from the PrefService. The preferences are
+  // set in a way such that all lower-priority stores have a value and we can
+  // test whether overrides do not clutter the recommended value.
+
+  // Test getting recommended value when a managed value is present.
+  value = NULL;
+  ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
+      prefs::kManagedPref,
+      Value::TYPE_STRING, &value));
+  std::string actual_str_value;
+  EXPECT_TRUE(value->GetAsString(&actual_str_value));
+  EXPECT_EQ(recommended_pref::kManagedValue, actual_str_value);
+
+  // Test getting recommended value when an extension value is present.
+  value = NULL;
+  ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
+      prefs::kExtensionPref,
+      Value::TYPE_STRING, &value));
+  EXPECT_TRUE(value->GetAsString(&actual_str_value));
+  EXPECT_EQ(recommended_pref::kExtensionValue, actual_str_value);
+
+  // Test getting recommended value when a command-line value is present.
+  value = NULL;
+  ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
+      prefs::kCommandLinePref,
+      Value::TYPE_STRING, &value));
+  EXPECT_TRUE(value->GetAsString(&actual_str_value));
+  EXPECT_EQ(recommended_pref::kCommandLineValue, actual_str_value);
+
+  // Test getting recommended value when a user-set value is present.
+  value = NULL;
+  ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
+      prefs::kUserPref,
+      Value::TYPE_STRING, &value));
+  EXPECT_TRUE(value->GetAsString(&actual_str_value));
+  EXPECT_EQ(recommended_pref::kUserValue, actual_str_value);
+
+  // Test getting recommended value when no higher-priority value is present.
+  value = NULL;
+  ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
+      prefs::kRecommendedPref,
+      Value::TYPE_STRING, &value));
+  EXPECT_TRUE(value->GetAsString(&actual_str_value));
+  EXPECT_EQ(recommended_pref::kRecommendedValue,
+            actual_str_value);
+
+  // Test getting recommended value when no recommended value is present.
+  base::FundamentalValue tmp_dummy_value(true);
+  value = &tmp_dummy_value;
+  ASSERT_FALSE(pref_value_store_->GetRecommendedValue(
+      prefs::kDefaultPref,
+      Value::TYPE_STRING, &value));
+  ASSERT_TRUE(value == NULL);
+
+  // Test getting a preference value that the |PrefValueStore|
+  // does not contain.
+  value = &tmp_dummy_value;
+  ASSERT_FALSE(pref_value_store_->GetRecommendedValue(
+      prefs::kMissingPref,
+      Value::TYPE_STRING, &value));
+  ASSERT_TRUE(value == NULL);
+}
+
 TEST_F(PrefValueStoreTest, PrefChanges) {
   // Check pref controlled by highest-priority store.
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kManagedPref));
   EXPECT_CALL(*sync_associator_,
       ProcessPrefChange(prefs::kManagedPref));
   managed_pref_store_->NotifyPrefValueChanged(
       prefs::kManagedPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
   Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_)).Times(0);
   EXPECT_CALL(*sync_associator_, ProcessPrefChange(_)).Times(0);
-  extension_pref_store_->NotifyPrefValueChanged(
-      prefs::kManagedPref);
-  command_line_pref_store_->NotifyPrefValueChanged(
-      prefs::kManagedPref);
-  user_pref_store_->NotifyPrefValueChanged(
-      prefs::kManagedPref);
-  recommended_pref_store_->NotifyPrefValueChanged(
-      prefs::kManagedPref);
-  default_pref_store_->NotifyPrefValueChanged(
-      prefs::kManagedPref);
+  extension_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
+  command_line_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
+  user_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
   Mock::VerifyAndClearExpectations(sync_associator_.get());
 
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kManagedPref));
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(_)).Times(0);
+  recommended_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
+  Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
+
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_)).Times(0);
+  EXPECT_CALL(*sync_associator_, ProcessPrefChange(_)).Times(0);
+  default_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
+  Mock::VerifyAndClearExpectations(&pref_notifier_);
+  Mock::VerifyAndClearExpectations(sync_associator_.get());
+
   // Check pref controlled by user store.
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kUserPref));
   EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kUserPref));
   managed_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
   Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kUserPref));
   EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kUserPref));
   extension_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
   Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kUserPref));
   EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kUserPref));
   command_line_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
   Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kUserPref));
   EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kUserPref));
   user_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
   Mock::VerifyAndClearExpectations(sync_associator_.get());
 
-  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(_)).Times(0);
+  EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kUserPref));
   EXPECT_CALL(*sync_associator_, ProcessPrefChange(_)).Times(0);
-  recommended_pref_store_->NotifyPrefValueChanged(
-      prefs::kUserPref);
-  default_pref_store_->NotifyPrefValueChanged(
-      prefs::kUserPref);
+  recommended_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
+  default_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
   Mock::VerifyAndClearExpectations(sync_associator_.get());
 
   // Check pref controlled by default-pref store.
   EXPECT_CALL(pref_notifier_, OnPreferenceChanged(prefs::kDefaultPref));
   EXPECT_CALL(*sync_associator_, ProcessPrefChange(prefs::kDefaultPref));
   managed_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
   Mock::VerifyAndClearExpectations(&pref_notifier_);
   Mock::VerifyAndClearExpectations(sync_associator_.get());
 
@@ skipping 188 matching lines @@
       prefs::kCommandLinePref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kUserPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kRecommendedPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kDefaultPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kMissingPref));
 }