dom-ui settings: Add setting for setting the minimum font size....

chrome/browser/dom_ui/options/core_options_handler.cc

 // Copyright (c) 2010 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/dom_ui/options/core_options_handler.h"
 
 #include "app/l10n_util.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
@@ skipping 99 matching lines @@
   dom_ui_->RegisterMessageCallback("observePrefs",
       NewCallback(this, &CoreOptionsHandler::HandleObservePrefs));
   dom_ui_->RegisterMessageCallback("setBooleanPref",
       NewCallback(this, &CoreOptionsHandler::HandleSetBooleanPref));
   dom_ui_->RegisterMessageCallback("setIntegerPref",
       NewCallback(this, &CoreOptionsHandler::HandleSetIntegerPref));
   dom_ui_->RegisterMessageCallback("setStringPref",
       NewCallback(this, &CoreOptionsHandler::HandleSetStringPref));
   dom_ui_->RegisterMessageCallback("setObjectPref",
       NewCallback(this, &CoreOptionsHandler::HandleSetObjectPref));
+  dom_ui_->RegisterMessageCallback("clearPref",
+      NewCallback(this, &CoreOptionsHandler::HandleClearPref));
   dom_ui_->RegisterMessageCallback("coreOptionsUserMetricsAction",
       NewCallback(this, &CoreOptionsHandler::HandleUserMetricsAction));
 }
 
 void CoreOptionsHandler::HandleInitialize(const ListValue* args) {
   static_cast<OptionsUI*>(dom_ui_)->InitializeHandlers();
 }
 
 Value* CoreOptionsHandler::FetchPref(const std::string& pref_name) {
-  DCHECK(dom_ui_);
   PrefService* pref_service = dom_ui_->GetProfile()->GetPrefs();
 
   const PrefService::Preference* pref =
       pref_service->FindPreference(pref_name.c_str());
 
   Value* return_value;
   if (pref) {
     DictionaryValue* dict = new DictionaryValue;
     dict->Set("value", pref->GetValue()->DeepCopy());
     dict->SetBoolean("managed", pref->IsManaged());
     return_value = dict;
   } else {
     return_value = Value::CreateNullValue();
   }
   return return_value;
 }
 
 void CoreOptionsHandler::ObservePref(const std::string& pref_name) {
   registrar_.Add(pref_name.c_str(), this);
 }
 
 void CoreOptionsHandler::SetPref(const std::string& pref_name,
                                  Value::ValueType pref_type,
                                  const std::string& value_string,
                                  const std::string& metric) {
-  DCHECK(dom_ui_);
   PrefService* pref_service = dom_ui_->GetProfile()->GetPrefs();
 
   switch (pref_type) {
     case Value::TYPE_BOOLEAN:
       pref_service->SetBoolean(pref_name.c_str(), value_string == "true");
       break;
     case Value::TYPE_INTEGER:
       int int_value;
       if (base::StringToInt(value_string, &int_value))
         pref_service->SetInteger(pref_name.c_str(), int_value);
       break;
     case Value::TYPE_STRING:
       pref_service->SetString(pref_name.c_str(), value_string);
       break;
     default:
       NOTREACHED();
       return;
   }
 
   pref_service->ScheduleSavePersistentPrefs();
   ProcessUserMetric(pref_type, value_string, metric);
 }
 
+void CoreOptionsHandler::ClearPref(const std::string& pref_name,
+                                   const std::string& metric) {
+  PrefService* pref_service = dom_ui_->GetProfile()->GetPrefs();
+  pref_service->ClearPref(pref_name.c_str());
+  pref_service->ScheduleSavePersistentPrefs();
+
+  if (!metric.empty())
+    UserMetricsRecordAction(UserMetricsAction(metric.c_str()));
+}
+
 void CoreOptionsHandler::ProcessUserMetric(Value::ValueType pref_type,
                                            const std::string& value_string,
                                            const std::string& metric) {
   if (metric.empty())
     return;
 
   std::string metric_string = metric;
   if (pref_type == Value::TYPE_BOOLEAN)
     metric_string += (value_string == "true" ? "_Enable" : "_Disable");
 
   UserMetricsRecordAction(UserMetricsAction(metric_string.c_str()));
 }
 
 void CoreOptionsHandler::StopObservingPref(const std::string& path) {
   registrar_.Remove(path.c_str(), this);
 }
 
 void CoreOptionsHandler::HandleFetchPrefs(const ListValue* args) {
   // First param is name of callback function, so, there needs to be at least
   // one more element for the actual preference identifier.
-  const size_t kMinFetchPrefsParamCount = 2;
-  if (args->GetSize() < kMinFetchPrefsParamCount)
-    return;
+  DCHECK_GE(static_cast<int>(args->GetSize()), 2);
 
   // Get callback JS function name.
   Value* callback;
   if (!args->Get(0, &callback) || !callback->IsType(Value::TYPE_STRING))
     return;
 
   string16 callback_function;
   if (!callback->GetAsString(&callback_function))
     return;
 
@@ skipping 14 matching lines @@
 
     result_value.Set(pref_name.c_str(), FetchPref(pref_name));
   }
   dom_ui_->CallJavascriptFunction(UTF16ToWideHack(callback_function).c_str(),
                                   result_value);
 }
 
 void CoreOptionsHandler::HandleObservePrefs(const ListValue* args) {
   // First param is name is JS callback function name, the rest are pref
   // identifiers that we are observing.
-  const size_t kMinObservePrefsParamCount = 2;
-  if (args->GetSize() < kMinObservePrefsParamCount)
-    return;
+  DCHECK_GE(static_cast<int>(args->GetSize()), 2);
 
   // Get preference change callback function name.
   string16 callback_func_name;
   if (!args->GetString(0, &callback_func_name))
     return;
 
   // Get all other parameters - pref identifiers.
   for (size_t i = 1; i < args->GetSize(); i++) {
     Value* list_member;
     if (!args->Get(i, &list_member))
@@ skipping 25 matching lines @@
 void CoreOptionsHandler::HandleSetStringPref(const ListValue* args) {
   HandleSetPref(args, Value::TYPE_STRING);
 }
 
 void CoreOptionsHandler::HandleSetObjectPref(const ListValue* args) {
   HandleSetPref(args, Value::TYPE_NULL);
 }
 
 void CoreOptionsHandler::HandleSetPref(const ListValue* args,
                                        Value::ValueType type) {
-  if (args->GetSize() < 2)
-    return;
+  DCHECK_GT(static_cast<int>(args->GetSize()), 1);
 
   std::string pref_name;
   if (!args->GetString(0, &pref_name))
     return;
 
   std::string value_string;
   if (!args->GetString(1, &value_string))
     return;
 
   std::string metric;
   if (args->GetSize() > 2)
     args->GetString(2, &metric);
 
   SetPref(pref_name, type, value_string, metric);
 }
 
+void CoreOptionsHandler::HandleClearPref(const ListValue* args) {
+  DCHECK_GT(static_cast<int>(args->GetSize()), 0);
+
+  std::string pref_name;
+  if (!args->GetString(0, &pref_name))
+    return;
+
+  std::string metric;
+  if (args->GetSize() > 1)
+    args->GetString(1, &metric);
+
+  ClearPref(pref_name, metric);
+}
+
 void CoreOptionsHandler::HandleUserMetricsAction(const ListValue* args) {
   std::string metric = WideToUTF8(ExtractStringValue(args));
   if (!metric.empty())
     UserMetricsRecordAction(UserMetricsAction(metric.c_str()));
 }
 
 void CoreOptionsHandler::NotifyPrefChanged(const std::string* pref_name) {
-  DCHECK(pref_name);
-  DCHECK(dom_ui_);
   PrefService* pref_service = dom_ui_->GetProfile()->GetPrefs();
   const PrefService::Preference* pref =
       pref_service->FindPreference(pref_name->c_str());
   if (pref) {
     for (PreferenceCallbackMap::const_iterator iter =
         pref_callback_map_.find(*pref_name);
         iter != pref_callback_map_.end(); ++iter) {
       const std::wstring& callback_function = iter->second;
       ListValue result_value;
       result_value.Append(Value::CreateStringValue(pref_name->c_str()));
 
       DictionaryValue* dict = new DictionaryValue;
       dict->Set("value", pref->GetValue()->DeepCopy());
       dict->SetBoolean("managed", pref->IsManaged());
       result_value.Append(dict);
 
       dom_ui_->CallJavascriptFunction(callback_function, result_value);
     }
   }
 }