Make base::Value::TYPE a scoped enum.

chrome/browser/ui/webui/options/core_options_handler.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/ui/webui/options/core_options_handler.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 284 matching lines @@
     const PrefService::Preference* pref =
         pref_service->FindPreference(pref_name);
     if ((pref && !pref->IsUserModifiable()) || !iter->second.Run(value)) {
       // Reject the change; remind the page of the true value.
       NotifyPrefChanged(pref_name, std::string());
       return;
     }
   }
 
   switch (value->GetType()) {
-    case base::Value::TYPE_BOOLEAN:
-    case base::Value::TYPE_INTEGER:
-    case base::Value::TYPE_DOUBLE:
-    case base::Value::TYPE_STRING:
-    case base::Value::TYPE_LIST:
+    case base::Value::Type::BOOLEAN:
+    case base::Value::Type::INTEGER:
+    case base::Value::Type::DOUBLE:
+    case base::Value::Type::STRING:
+    case base::Value::Type::LIST:
       pref_service->Set(pref_name, *value);
       break;
 
     default:
       NOTREACHED();
       return;
   }
 
   ProcessUserMetric(value, metric);
 }
 
 void CoreOptionsHandler::ClearPref(const std::string& pref_name,
                                    const std::string& metric) {
   PrefService* pref_service = FindServiceForPref(pref_name);
   pref_service->ClearPref(pref_name);
 
   if (!metric.empty())
     content::RecordComputedAction(metric);
 }
 
 void CoreOptionsHandler::ProcessUserMetric(const base::Value* value,
                                            const std::string& metric) {
   if (metric.empty())
     return;
 
   std::string metric_string = metric;
-  if (value->IsType(base::Value::TYPE_BOOLEAN)) {
+  if (value->IsType(base::Value::Type::BOOLEAN)) {
     bool bool_value;
     CHECK(value->GetAsBoolean(&bool_value));
     metric_string += bool_value ? "_Enable" : "_Disable";
   }
 
   content::RecordComputedAction(metric_string);
 }
 
 void CoreOptionsHandler::NotifyPrefChanged(
     const std::string& pref_name,
@@ skipping 93 matching lines @@
   return user_prefs;
 }
 
 void CoreOptionsHandler::HandleFetchPrefs(const base::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.
   const base::Value* callback;
-  if (!args->Get(0, &callback) || !callback->IsType(base::Value::TYPE_STRING))
+  if (!args->Get(0, &callback) || !callback->IsType(base::Value::Type::STRING))
     return;
 
   base::string16 callback_function;
   if (!callback->GetAsString(&callback_function))
     return;
 
   // Get the list of name for prefs to build the response dictionary.
   base::DictionaryValue result_value;
   const base::Value* list_member;
 
   for (size_t i = 1; i < args->GetSize(); i++) {
     if (!args->Get(i, &list_member))
       break;
 
-    if (!list_member->IsType(base::Value::TYPE_STRING))
+    if (!list_member->IsType(base::Value::Type::STRING))
       continue;
 
     std::string pref_name;
     if (!list_member->GetAsString(&pref_name))
       continue;
 
     result_value.Set(pref_name, FetchPref(pref_name));
   }
   web_ui()->CallJavascriptFunctionUnsafe(base::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++) {
     const base::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(base::Value::TYPE_STRING) ||
+    if (!list_member->IsType(base::Value::Type::STRING) ||
         !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, callback_func_name));
   }
 }
@@ skipping 31 matching lines @@
     return;
 
   const base::Value* value;
   if (!args->Get(1, &value))
     return;
 
   std::unique_ptr<base::Value> temp_value;
 
   switch (type) {
     case TYPE_BOOLEAN:
-      if (!value->IsType(base::Value::TYPE_BOOLEAN)) {
+      if (!value->IsType(base::Value::Type::BOOLEAN)) {
         NOTREACHED();
         return;
       }
       break;
     case TYPE_INTEGER: {
       // In JS all numbers are doubles.
       double double_value;
       if (!value->GetAsDouble(&double_value)) {
         NOTREACHED();
         return;
       }
       int int_value = static_cast<int>(double_value);
       temp_value.reset(new base::FundamentalValue(int_value));
       value = temp_value.get();
       break;
     }
     case TYPE_DOUBLE:
-      if (!value->IsType(base::Value::TYPE_DOUBLE)) {
+      if (!value->IsType(base::Value::Type::DOUBLE)) {
         NOTREACHED();
         return;
       }
       break;
     case TYPE_STRING:
-      if (!value->IsType(base::Value::TYPE_STRING)) {
+      if (!value->IsType(base::Value::Type::STRING)) {
         NOTREACHED();
         return;
       }
       break;
     case TYPE_URL: {
       std::string original;
       if (!value->GetAsString(&original)) {
         NOTREACHED();
         return;
       }
       GURL fixed = url_formatter::FixupURL(original, std::string());
       temp_value.reset(new base::StringValue(fixed.spec()));
       value = temp_value.get();
       break;
     }
     case TYPE_LIST: {
       // In case we have a List pref we got a JSON string.
       std::string json_string;
       if (!value->GetAsString(&json_string)) {
         NOTREACHED();
         return;
       }
       temp_value = base::JSONReader::Read(json_string);
       value = temp_value.get();
-      if (!value || !value->IsType(base::Value::TYPE_LIST)) {
+      if (!value || !value->IsType(base::Value::Type::LIST)) {
         NOTREACHED();
         return;
       }
       break;
     }
     default:
       NOTREACHED();
   }
 
   std::string metric;
@@ skipping 49 matching lines @@
           plugin_status_pref_setter_.IsPepperFlashSettingsEnabled());
   web_ui()->CallJavascriptFunctionUnsafe(
       "options.OptionsPage.setPepperFlashSettingsEnabled", enabled);
 }
 
 bool CoreOptionsHandler::IsUserUnsupervised(const base::Value* to_value) {
   return !Profile::FromWebUI(web_ui())->IsSupervised();
 }
 
 }  // namespace options