Improve performance of registering font preferences

chrome/browser/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 "chrome/browser/prefs/pref_service.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 453 matching lines @@
 
 void PrefService::RegisterStringPref(const char* path,
                                      const std::string& default_value,
                                      PrefSyncStatus sync_status) {
   DCHECK(IsProfilePrefService(this));
   RegisterPreference(path,
                      Value::CreateStringValue(default_value),
                      sync_status);
 }
 
+void PrefService::RegisterStringPrefIfNew(const char* path,
+                                          const std::string& default_value,
+                                     PrefSyncStatus sync_status) {
+  DCHECK(IsProfilePrefService(this));
+  RegisterPreferenceIfNew(path,
+                          Value::CreateStringValue(default_value),
+                          sync_status);
+  }
+
 void PrefService::RegisterFilePathPref(const char* path,
                                        const FilePath& default_value,
                                        PrefSyncStatus sync_status) {
   DCHECK(IsProfilePrefService(this));
   RegisterPreference(path,
                      Value::CreateStringValue(default_value.value()),
                      sync_status);
 }
 
 void PrefService::RegisterListPref(const char* path,
@@ skipping 288 matching lines @@
 void PrefService::AddPrefObserver(const char* path,
                                   content::NotificationObserver* obs) {
   pref_notifier_->AddPrefObserver(path, obs);
 }
 
 void PrefService::RemovePrefObserver(const char* path,
                                      content::NotificationObserver* obs) {
   pref_notifier_->RemovePrefObserver(path, obs);
 }
 
-void PrefService::RegisterPreference(const char* path,
-                                     Value* default_value,
-                                     PrefSyncStatus sync_status) {
+void PrefService::RegisterNewPreference(const char* path,
+                                        Value* default_value,
+                                        PrefSyncStatus sync_status) {
+  // Note: The perfomance of this method is critical to startup performance,
+  // at least on Android, so do not introduce extra checks unless they are
+  // compiled out of official builds.
   DCHECK(CalledOnValidThread());
 
   // The main code path takes ownership, but most don't. We'll be safe.
   scoped_ptr<Value> scoped_value(default_value);
 
-  if (FindPreference(path)) {
-    NOTREACHED() << "Tried to register duplicate pref " << path;

[Bernhard Bauer, 2012/10/30 14:34:16]

Seeing as this is just a NOTREACHED (which would imply an internal error if it
happens), could we just change it to a DCHECK? That would improve the
performance at least for a Release build.

-    return;
-  }
-
   base::Value::Type orig_type = default_value->GetType();
   DCHECK(orig_type != Value::TYPE_NULL && orig_type != Value::TYPE_BINARY) <<
          "invalid preference type: " << orig_type;
 
   // For ListValue and DictionaryValue with non empty default, empty value
   // for |path| needs to be persisted in |user_pref_store_|. So that
   // non empty default is not used when user sets an empty ListValue or
   // DictionaryValue.
   bool needs_empty_value = false;
   if (orig_type == base::Value::TYPE_LIST) {
     const base::ListValue* list = NULL;
     if (default_value->GetAsList(&list) && !list->empty())
       needs_empty_value = true;
   } else if (orig_type == base::Value::TYPE_DICTIONARY) {
     const base::DictionaryValue* dict = NULL;
     if (default_value->GetAsDictionary(&dict) && !dict->empty())
       needs_empty_value = true;
   }
   if (needs_empty_value)
     user_pref_store_->MarkNeedsEmptyValue(path);
 
   // Hand off ownership.
   default_store_->SetDefaultValue(path, scoped_value.release());
 
   // Register with sync if necessary.
   if (sync_status == SYNCABLE_PREF && pref_sync_associator_.get())
     pref_sync_associator_->RegisterPref(path);
 }
 
+void PrefService::RegisterPreference(const char* path,
+                                     Value* default_value,
+                                     PrefSyncStatus sync_status) {
+  if (default_store_->GetType(path) != Value::TYPE_NULL) {
+    // Preference already exists
+    NOTREACHED() << "Tried to register duplicate pref " << path;
+    return;
+  }
+  RegisterNewPreference(path, default_value, sync_status);
+}
+
+void PrefService::RegisterPreferenceIfNew(const char* path,
+                                          Value* default_value,
+                                          PrefSyncStatus sync_status) {
+  if (default_store_->GetType(path) != Value::TYPE_NULL) {
+    // Preference already exists
+    return;
+  }
+  RegisterNewPreference(path, default_value, sync_status);
+}
+
 void PrefService::UnregisterPreference(const char* path) {
   DCHECK(CalledOnValidThread());
 
   PreferenceMap::iterator it = prefs_map_.find(path);
   if (it == prefs_map_.end()) {
     NOTREACHED() << "Trying to unregister an unregistered pref: " << path;
     return;
   }
 
   prefs_map_.erase(it);
@@ skipping 226 matching lines @@
   return pref_value_store()->PrefValueFromDefaultStore(name_.c_str());
 }
 
 bool PrefService::Preference::IsUserModifiable() const {
   return pref_value_store()->PrefValueUserModifiable(name_.c_str());
 }
 
 bool PrefService::Preference::IsExtensionModifiable() const {
   return pref_value_store()->PrefValueExtensionModifiable(name_.c_str());
 }