base: Add Is* functions to Value class.

chrome/browser/chromeos/cros/native_network_parser.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/chromeos/cros/native_network_parser.h"
 
 #include "base/stringprintf.h"
 #include "chrome/browser/chromeos/cros/native_network_constants.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
@@ skipping 176 matching lines @@
       return true;
     }
     case PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING: {
       bool data_roaming_allowed;
       if (!value.GetAsBoolean(&data_roaming_allowed))
         return false;
       device->set_data_roaming_allowed(data_roaming_allowed);
       return true;
     }
     case PROPERTY_INDEX_CELLULAR_APN_LIST:
-      if (value.IsType(Value::TYPE_LIST)) {
+      if (value.IsList()) {
         CellularApnList provider_apn_list;
         if (!ParseApnList(static_cast<const ListValue&>(value),
                           &provider_apn_list))
           return false;
         device->set_provider_apn_list(provider_apn_list);
         return true;
       }
       break;
     case PROPERTY_INDEX_NETWORKS:
-      if (value.IsType(Value::TYPE_LIST)) {
+      if (value.IsList()) {
         // Ignored.
         return true;
       }
       break;
     case PROPERTY_INDEX_FOUND_NETWORKS:
-      if (value.IsType(Value::TYPE_LIST)) {
+      if (value.IsList()) {
         CellularNetworkList found_cellular_networks;
         if (!ParseFoundNetworksFromList(
                 static_cast<const ListValue&>(value),
                 &found_cellular_networks))
           return false;
         device->set_found_cellular_networks(found_cellular_networks);
         return true;
       }
       break;
     case PROPERTY_INDEX_HOME_PROVIDER: {
-      if (value.IsType(Value::TYPE_DICTIONARY)) {
+      if (value.IsDictionary()) {
         const DictionaryValue& dict =
             static_cast<const DictionaryValue&>(value);
         std::string home_provider_code;
         std::string home_provider_country;
         std::string home_provider_name;
         dict.GetStringWithoutPathExpansion(kOperatorCodeKey,
                                            &home_provider_code);
         dict.GetStringWithoutPathExpansion(kOperatorCountryKey,
                                            &home_provider_country);
         dict.GetStringWithoutPathExpansion(kOperatorNameKey,
@@ skipping 63 matching lines @@
           break;
         case PROPERTY_INDEX_SELECTED_NETWORK:
           device->set_selected_cellular_network(item);
           break;
         default:
           break;
       }
       return true;
     }
     case PROPERTY_INDEX_SIM_LOCK:
-      if (value.IsType(Value::TYPE_DICTIONARY)) {
+      if (value.IsDictionary()) {
         SimLockState sim_lock_state;
         int sim_retries_left;
         if (!ParseSimLockStateFromDictionary(
                 static_cast<const DictionaryValue&>(value),
                 &sim_lock_state,
                 &sim_retries_left))
           return false;
         device->set_sim_lock_state(sim_lock_state);
         device->set_sim_retries_left(sim_retries_left);
         // Initialize PinRequired value only once.
@@ skipping 43 matching lines @@
 
 ConnectionType NativeNetworkDeviceParser::ParseType(const std::string& type) {
   return ParseNetworkType(type);
 }
 
 bool NativeNetworkDeviceParser::ParseApnList(const ListValue& list,
                                              CellularApnList* apn_list) {
   apn_list->clear();
   apn_list->reserve(list.GetSize());
   for (ListValue::const_iterator it = list.begin(); it != list.end(); ++it) {
-    if ((*it)->IsType(Value::TYPE_DICTIONARY)) {
+    if ((*it)->IsDictionary()) {
       apn_list->resize(apn_list->size() + 1);
       const DictionaryValue* dict = static_cast<const DictionaryValue*>(*it);
       dict->GetStringWithoutPathExpansion(
           kApnProperty, &apn_list->back().apn);
       dict->GetStringWithoutPathExpansion(
           kApnNetworkIdProperty, &apn_list->back().network_id);
       dict->GetStringWithoutPathExpansion(
           kApnUsernameProperty, &apn_list->back().username);
       dict->GetStringWithoutPathExpansion(
           kApnPasswordProperty, &apn_list->back().password);
       dict->GetStringWithoutPathExpansion(
           kApnNameProperty, &apn_list->back().name);
       dict->GetStringWithoutPathExpansion(
           kApnLocalizedNameProperty, &apn_list->back().localized_name);
       dict->GetStringWithoutPathExpansion(
           kApnLanguageProperty, &apn_list->back().language);
     } else {
       return false;
     }
   }
   return true;
 }
 
 bool NativeNetworkDeviceParser::ParseFoundNetworksFromList(
     const ListValue& list,
     CellularNetworkList* found_networks) {
   found_networks->clear();
   found_networks->reserve(list.GetSize());
   for (ListValue::const_iterator it = list.begin(); it != list.end(); ++it) {
-    if ((*it)->IsType(Value::TYPE_DICTIONARY)) {
+    if ((*it)->IsDictionary()) {
       found_networks->resize(found_networks->size() + 1);
       const DictionaryValue* dict = static_cast<const DictionaryValue*>(*it);
       dict->GetStringWithoutPathExpansion(
           kStatusProperty, &found_networks->back().status);
       dict->GetStringWithoutPathExpansion(
           kNetworkIdProperty, &found_networks->back().network_id);
       dict->GetStringWithoutPathExpansion(
           kShortNameProperty, &found_networks->back().short_name);
       dict->GetStringWithoutPathExpansion(
           kLongNameProperty, &found_networks->back().long_name);
@@ skipping 277 matching lines @@
         ActivationState prev_state = cellular_network->activation_state();
         cellular_network->set_activation_state(
             ParseActivationState(activation_state_string));
         if (cellular_network->activation_state() != prev_state)
           cellular_network->RefreshDataPlansIfNeeded();
         return true;
       }
       break;
     }
     case PROPERTY_INDEX_CELLULAR_APN: {
-      if (value.IsType(Value::TYPE_DICTIONARY)) {
+      if (value.IsDictionary()) {
         cellular_network->set_apn(static_cast<const DictionaryValue&>(value));
         return true;
       }
       break;
     }
     case PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN: {
-      if (value.IsType(Value::TYPE_DICTIONARY)) {
+      if (value.IsDictionary()) {
         cellular_network->set_last_good_apn(
             static_cast<const DictionaryValue&>(value));
         return true;
       }
       break;
     }
     case PROPERTY_INDEX_NETWORK_TECHNOLOGY: {
       std::string network_technology_string;
       if (value.GetAsString(&network_technology_string)) {
         cellular_network->set_network_technology(
@@ skipping 19 matching lines @@
       return true;
     }
     case PROPERTY_INDEX_OPERATOR_CODE: {
       std::string value_str;
       if (!value.GetAsString(&value_str))
         break;
       cellular_network->set_operator_code(value_str);
       return true;
     }
     case PROPERTY_INDEX_SERVING_OPERATOR: {
-      if (value.IsType(Value::TYPE_DICTIONARY)) {
+      if (value.IsDictionary()) {
         const DictionaryValue& dict =
             static_cast<const DictionaryValue&>(value);
         std::string value_str;
         dict.GetStringWithoutPathExpansion(kOperatorNameKey, &value_str);
         cellular_network->set_operator_name(value_str);
         value_str.clear();
         dict.GetStringWithoutPathExpansion(kOperatorCodeKey, &value_str);
         cellular_network->set_operator_code(value_str);
         value_str.clear();
         dict.GetStringWithoutPathExpansion(kOperatorCountryKey, &value_str);
@@ skipping 391 matching lines @@
   static EnumMapper<ProviderType>::Pair table[] = {
     { kProviderL2tpIpsec, PROVIDER_TYPE_L2TP_IPSEC_PSK },
     { kProviderOpenVpn, PROVIDER_TYPE_OPEN_VPN },
   };
   static EnumMapper<ProviderType> parser(
       table, arraysize(table), PROVIDER_TYPE_MAX);
   return parser.Get(type);
 }
 
 }  // namespace chromeos