Add ability to change default pref values, and use in BrowserInstantController.

base/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 "base/prefs/pref_service.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 164 matching lines @@
 }
 
 bool PrefService::HasPrefPath(const char* path) const {
   const Preference* pref = FindPreference(path);
   return pref && !pref->IsDefaultValue();
 }
 
 DictionaryValue* PrefService::GetPreferenceValues() const {
   DCHECK(CalledOnValidThread());
   DictionaryValue* out = new DictionaryValue;
-  PrefRegistry::const_iterator i = pref_registry_->begin();
-  for (; i != pref_registry_->end(); ++i) {
+  PrefRegistry::const_iterator i = pref_registry_->defaults()->begin();
+  for (; i != pref_registry_->defaults()->end(); ++i) {
     const Value* value = GetPreferenceValue(i->first);
     DCHECK(value);
     out->Set(i->first, value->DeepCopy());
   }
   return out;
 }
 
 const PrefService::Preference* PrefService::FindPreference(
     const char* pref_name) const {
   DCHECK(CalledOnValidThread());
@@ skipping 69 matching lines @@
     return NULL;
 
   if (!value->IsType(pref->GetType())) {
     NOTREACHED() << "Pref value type doesn't match registered type.";
     return NULL;
   }
 
   return value;
 }
 
+void PrefService::SetDefaultPrefValue(const char* path,
+                                      base::Value* value) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(pref_registry_->defaults()->GetValue(path, NULL))
+      << "Setting default for unregistered pref: " << path;
+  pref_registry_->defaults()->SetDefaultValue(path, value);

[Mattias Nissler (ping if slow), 2013/02/27 10:50:52]

We should CHECK() that the type doesn't change here, and make sure that |value|
!= NULL

[Jói, 2013/02/27 16:30:56]

Done.

+}
+
 const base::Value* PrefService::GetDefaultPrefValue(const char* path) const {
   DCHECK(CalledOnValidThread());
   // Lookup the preference in the default store.
   const base::Value* value = NULL;
   if (!pref_registry_->defaults()->GetValue(path, &value)) {
     NOTREACHED() << "Default value missing for pref: " << path;
     return NULL;
   }
   return value;
 }
@@ skipping 23 matching lines @@
 
 void PrefService::AddPrefInitObserver(base::Callback<void(bool)> obs) {
   pref_notifier_->AddInitObserver(obs);
 }
 
 PrefRegistry* PrefService::DeprecatedGetPrefRegistry() {
   return pref_registry_.get();
 }
 
 void PrefService::AddInitialPreferences() {
-  for (PrefRegistry::const_iterator it = pref_registry_->begin();
-       it != pref_registry_->end();
+  for (PrefRegistry::const_iterator it = pref_registry_->defaults()->begin();
+       it != pref_registry_->defaults()->end();
        ++it) {
     AddRegisteredPreference(it->first.c_str(), it->second);
   }
 }
 
 // TODO(joi): Once MarkNeedsEmptyValue is gone, we can probably
 // completely get rid of this method. There will be one difference in
 // semantics; currently all registered preferences are stored right
 // away in the prefs_map_, if we remove this they would be stored only
 // opportunistically.
@@ skipping 244 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;
 }