base: Add Is* functions to Value class.

chrome/browser/ui/webui/options/core_options_handler.cc

 // Copyright (c) 2011 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/ui/webui/options/core_options_handler.h"
 
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
@@ skipping 186 matching lines @@
   if (!metric.empty())
     UserMetrics::RecordComputedAction(metric);
 }
 
 void CoreOptionsHandler::ProcessUserMetric(const Value* value,
                                            const std::string& metric) {
   if (metric.empty())
     return;
 
   std::string metric_string = metric;
-  if (value->IsType(Value::TYPE_BOOLEAN)) {
+  if (value->IsBoolean()) {
     bool bool_value;
     CHECK(value->GetAsBoolean(&bool_value));
     metric_string += bool_value ? "_Enable" : "_Disable";
   }
 
   UserMetrics::RecordComputedAction(metric_string);
 }
 
 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.
   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))
+  if (!args->Get(0, &callback) || !callback->IsString())
     return;
 
   string16 callback_function;
   if (!callback->GetAsString(&callback_function))
     return;
 
   // Get the list of name for prefs to build the response dictionary.
   DictionaryValue result_value;
   Value* list_member;
 
   for (size_t i = 1; i < args->GetSize(); i++) {
     if (!args->Get(i, &list_member))
       break;
 
-    if (!list_member->IsType(Value::TYPE_STRING))
+    if (!list_member->IsString())
       continue;
 
     std::string pref_name;
     if (!list_member->GetAsString(&pref_name))
       continue;
 
     result_value.Set(pref_name.c_str(), FetchPref(pref_name));
   }
   web_ui_->CallJavascriptFunction(UTF16ToASCII(callback_function),
                                   result_value);
@@ skipping 10 matching lines @@
     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))
       break;
 
     // Just ignore bad pref identifiers for now.
     std::string pref_name;
-    if (!list_member->IsType(Value::TYPE_STRING) ||
-        !list_member->GetAsString(&pref_name))
+    if (!list_member->IsString() || !list_member->GetAsString(&pref_name))
       continue;
 
     if (pref_callback_map_.find(pref_name) == pref_callback_map_.end())
       ObservePref(pref_name);
 
     pref_callback_map_.insert(
         PreferenceCallbackMap::value_type(pref_name,
                                           UTF16ToWideHack(callback_func_name)));
   }
 }
@@ skipping 106 matching lines @@
     const std::wstring& callback_function = iter->second;
     ListValue result_value;
     result_value.Append(Value::CreateStringValue(pref_name->c_str()));
 
     result_value.Append(CreateValueForPref(pref));
 
     web_ui_->CallJavascriptFunction(WideToASCII(callback_function),
                                     result_value);
   }
 }