Tidy up <select>s in tabbed options.

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 117 matching lines @@
   dom_ui_->RegisterMessageCallback("coreOptionsInitialize",
       NewCallback(this, &CoreOptionsHandler::HandleInitialize));
   dom_ui_->RegisterMessageCallback("fetchPrefs",
       NewCallback(this, &CoreOptionsHandler::HandleFetchPrefs));
   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("setRealPref",
+      NewCallback(this, &CoreOptionsHandler::HandleSetRealPref));
   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));
 }
 
@@ skipping 26 matching lines @@
 void CoreOptionsHandler::SetPref(const std::string& pref_name,
                                  Value::ValueType pref_type,
                                  const std::string& value_string,
                                  const std::string& metric) {
   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);
+      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;
   }
 
   pref_service->ScheduleSavePersistentPrefs();
   ProcessUserMetric(pref_type, value_string, metric);
 }
 
 void CoreOptionsHandler::ClearPref(const std::string& pref_name,
@@ skipping 90 matching lines @@
 }
 
 void CoreOptionsHandler::HandleSetBooleanPref(const ListValue* args) {
   HandleSetPref(args, Value::TYPE_BOOLEAN);
 }
 
 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);
 }
 
 void CoreOptionsHandler::HandleSetObjectPref(const ListValue* args) {
   HandleSetPref(args, Value::TYPE_NULL);
 }
 
 void CoreOptionsHandler::HandleSetPref(const ListValue* args,
                                        Value::ValueType type) {
@@ skipping 48 matching lines @@
 
       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);
     }
   }
 }