Allow whitelisted prefs to be displayed in ChromeOS in chrome://local-state.

components/prefs/pref_service.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 "components/prefs/pref_service.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 34 matching lines @@
   uint32_t write_flags = WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS;
 
   if (!pref)
     return write_flags;
 
   if (pref->registration_flags() & PrefRegistry::LOSSY_PREF)
     write_flags |= WriteablePrefStore::LOSSY_PREF_WRITE_FLAG;
   return write_flags;
 }
 
+bool HasValidPrefix(const std::string& pref_name,
+                    const std::vector<std::string> valid_prefixes) {
+  for (const std::string& prefix : valid_prefixes) {
+    if (pref_name.compare(0, prefix.size(), prefix) == 0)
+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 PrefService::PrefService(
     PrefNotifierImpl* pref_notifier,
     PrefValueStore* pref_value_store,
     PersistentPrefStore* user_prefs,
     PrefRegistry* pref_registry,
     base::Callback<void(PersistentPrefStore::PrefReadError)>
         read_error_callback,
     bool async)
@@ skipping 129 matching lines @@
 
 scoped_ptr<base::DictionaryValue> PrefService::GetPreferenceValues() const {
   DCHECK(CalledOnValidThread());
   scoped_ptr<base::DictionaryValue> out(new base::DictionaryValue);
   for (const auto& it : *pref_registry_) {
     out->Set(it.first, GetPreferenceValue(it.first)->CreateDeepCopy());
   }
   return out;
 }
 
+void PrefService::SetPreferenceOmitdefault(const std::string& pref_name,
+                                           base::DictionaryValue* out) const {
+  const Preference* pref = FindPreference(pref_name);
+  if (pref->IsDefaultValue())
+    return;
+  out->Set(pref_name, pref->GetValue()->CreateDeepCopy());
+}
+
 scoped_ptr<base::DictionaryValue> PrefService::GetPreferenceValuesOmitDefaults()
     const {
   DCHECK(CalledOnValidThread());
   scoped_ptr<base::DictionaryValue> out(new base::DictionaryValue);
   for (const auto& it : *pref_registry_) {
-    const Preference* pref = FindPreference(it.first);
-    if (pref->IsDefaultValue())
-      continue;
-    out->Set(it.first, pref->GetValue()->CreateDeepCopy());
+    SetPreferenceOmitdefault(it.first, out.get());
   }
   return out;
 }
+
+scoped_ptr<base::DictionaryValue>
+PrefService::GetWhitelistedPreferenceValuesOmitDefaults(
+    const std::vector<std::string>& whitelisted_prefixes) const {
+  DCHECK(CalledOnValidThread());
+  scoped_ptr<base::DictionaryValue> out(new base::DictionaryValue);
+  for (const auto& it : *pref_registry_) {
+    if (HasValidPrefix(it.first, whitelisted_prefixes))
+      SetPreferenceOmitdefault(it.first, out.get());
+  }
+  return out;
+}
 
 scoped_ptr<base::DictionaryValue>
 PrefService::GetPreferenceValuesWithoutPathExpansion() const {
   DCHECK(CalledOnValidThread());
   scoped_ptr<base::DictionaryValue> out(new base::DictionaryValue);
   for (const auto& it : *pref_registry_) {
     const base::Value* value = GetPreferenceValue(it.first);
     DCHECK(value);
     out->SetWithoutPathExpansion(it.first, value->CreateDeepCopy());
   }
@@ skipping 385 matching lines @@
       DCHECK(found_value->IsType(default_type));
       return found_value;
     } else {
       // Every registered preference has at least a default value.
       NOTREACHED() << "no valid value found for registered pref " << path;
     }
   }
 
   return NULL;
 }