Tidy up <select>s in tabbed options.

chrome/browser/dom_ui/options/core_options_handler.cc

Index: chrome/browser/dom_ui/options/core_options_handler.cc
diff --git a/chrome/browser/dom_ui/options/core_options_handler.cc b/chrome/browser/dom_ui/options/core_options_handler.cc
index ab8a6d4615ae833a7e6e52fc4ed2114e0e4902bb..8fc118d23c78caf854c0cbf4412cdc7a5a580069 100644
--- a/chrome/browser/dom_ui/options/core_options_handler.cc
+++ b/chrome/browser/dom_ui/options/core_options_handler.cc
@@ -135,6 +135,8 @@ void CoreOptionsHandler::RegisterMessages() {
       NewCallback(this, &CoreOptionsHandler::HandleSetBooleanPref));
   dom_ui_->RegisterMessageCallback("setIntegerPref",
       NewCallback(this, &CoreOptionsHandler::HandleSetIntegerPref));
+  dom_ui_->RegisterMessageCallback("setRealPref",
+      NewCallback(this, &CoreOptionsHandler::HandleSetRealPref));
   dom_ui_->RegisterMessageCallback("setStringPref",
       NewCallback(this, &CoreOptionsHandler::HandleSetStringPref));
   dom_ui_->RegisterMessageCallback("setObjectPref",
@@ -181,14 +183,25 @@ void CoreOptionsHandler::SetPref(const std::string& pref_name,
     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);
+      CHECK(base::StringToInt(value_string, &int_value));

[stuartmorgan, 2011/01/12 22:59:41]

We're going to crash the whole browser for end users if a value from JS is ever
not what we expect? That seems like a really bad failure mode.

[Evan Stade, 2011/01/12 23:19:20]

yes. We have complete control over the options page. If this check fails, there
is a bug we need to fix. Making the failure recoverable will cause us to not
find and fix it. From the chrome style guide:

"""
it is preferable to crash instead of handling a DCHECK failure. Attempting to
handle a DCHECK failure in a graceful manner is a statement that the DCHECK can
fail, which contradicts the point of writing the DCHECK [...] In some cases the
consequences of a failed DCHECK may result in a crash. This is not necessarily a
terrible thing. The crash will be logged, and that will result in visibility to
the fact that the DCHECK fails in the wild. It is far better to receive detailed
crash reports than vague anecdotes about unreproducible hangs, dead clicks, or
other misbehaving non-crash conditions.
"""

(In my mind, as long as we are not recovering, failing fast via a CHECK is
preferable to DCHECK)

+      pref_service->SetInteger(pref_name.c_str(), int_value);
+
+      break;
+
+    case Value::TYPE_REAL:
+      double double_value;
+      CHECK(base::StringToDouble(value_string, &double_value));
+      pref_service->SetReal(pref_name.c_str(), double_value);
+
       break;
+
     case Value::TYPE_STRING:
       pref_service->SetString(pref_name.c_str(), value_string);
       break;
+
     default:
       NOTREACHED();
       return;
@@ -299,6 +312,10 @@ void CoreOptionsHandler::HandleSetIntegerPref(const ListValue* args) {
   HandleSetPref(args, Value::TYPE_INTEGER);
 }
 
+void CoreOptionsHandler::HandleSetRealPref(const ListValue* args) {
+  HandleSetPref(args, Value::TYPE_REAL);
+}
+
 void CoreOptionsHandler::HandleSetStringPref(const ListValue* args) {
   HandleSetPref(args, Value::TYPE_STRING);
 }