Revert recent changes to base::Value

chrome/browser/chromeos/cros/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/network_parser.h"
 
 #include "base/json/json_writer.h" // for debug output only.
 #include "base/stringprintf.h"
 // Needed only for debug output (ConnectionTypeToString).
 #include "chrome/browser/chromeos/cros/native_network_constants.h"
@@ skipping 52 matching lines @@
 
 bool NetworkDeviceParser::UpdateDeviceFromInfo(const DictionaryValue& info,
                                                NetworkDevice* device) {
   for (DictionaryValue::key_iterator iter = info.begin_keys();
        iter != info.end_keys(); ++iter) {
     const std::string& key = *iter;
     Value* value;
     bool result = info.GetWithoutPathExpansion(key, &value);
     DCHECK(result);
     if (result)
-      UpdateStatus(key, value, device, NULL);
+      UpdateStatus(key, *value, device, NULL);
   }
   if (VLOG_IS_ON(2)) {
     std::string json;
     base::JSONWriter::Write(&info, true, &json);
     VLOG(2) << "Updated device for path "
             << device->device_path() << ": " << json;
   }
   return true;
 }
 
 bool NetworkDeviceParser::UpdateStatus(const std::string& key,
-                                       Value* value,
+                                       const Value& value,
                                        NetworkDevice* device,
                                        PropertyIndex* index) {
   PropertyIndex found_index = mapper().Get(key);
   if (index)
     *index = found_index;
   if (!ParseValue(found_index, value, device)) {
     VLOG(1) << "NetworkDeviceParser: Unhandled key: " << key;
     return false;
   }
   if (VLOG_IS_ON(2)) {
     std::string value_json;
-    base::JSONWriter::Write(value, true, &value_json);
+    base::JSONWriter::Write(&value, true, &value_json);
     VLOG(2) << "Updated value on device: "
             << device->device_path() << "[" << key << "] = " << value_json;
   }
   return true;
 }
 
 //----------- Network Parser -----------------
 
 NetworkParser::NetworkParser(const EnumMapper<PropertyIndex>* mapper)
     : mapper_(mapper) {
@@ skipping 19 matching lines @@
 bool NetworkParser::UpdateNetworkFromInfo(const DictionaryValue& info,
                                           Network* network) {
   network->set_unique_id("");
   for (DictionaryValue::key_iterator iter = info.begin_keys();
        iter != info.end_keys(); ++iter) {
     const std::string& key = *iter;
     Value* value;
     bool res = info.GetWithoutPathExpansion(key, &value);
     DCHECK(res);
     if (res)
-      network->UpdateStatus(key, value, NULL);
+      network->UpdateStatus(key, *value, NULL);
   }
   if (network->unique_id().empty())
     network->CalculateUniqueId();
   VLOG(2) << "Updated network '" << network->name()
           << "' Path:" << network->service_path() << " Type:"
           << ConnectionTypeToString(network->type());
   return true;
 }
 
 bool NetworkParser::UpdateStatus(const std::string& key,
-                                 Value* value,
+                                 const Value& value,
                                  Network* network,
                                  PropertyIndex* index) {
   PropertyIndex found_index = mapper().Get(key);
   if (index)
     *index = found_index;
   if (!ParseValue(found_index, value, network)) {
     VLOG(1) << "Unhandled key '" << key << "' in Network: " << network->name()
             << " ID: " << network->unique_id()
             << " Type: " << ConnectionTypeToString(network->type());
     return false;
   }
   if (VLOG_IS_ON(2)) {
     std::string value_json;
-    base::JSONWriter::Write(value, true, &value_json);
+    base::JSONWriter::Write(&value, true, &value_json);
     VLOG(2) << "Updated value on network: "
             << network->unique_id() << "[" << key << "] = " << value_json;
   }
   return true;
 }
 
 bool NetworkParser::ParseValue(PropertyIndex index,
-                               Value* value,
+                               const Value& value,
                                Network* network) {
   switch (index) {
     case PROPERTY_INDEX_TYPE: {
       std::string type_string;
-      if (value->GetAsString(&type_string)) {
+      if (value.GetAsString(&type_string)) {
         ConnectionType type = ParseType(type_string);
         LOG_IF(ERROR, type != network->type())
             << "Network with mismatched type: " << network->service_path()
             << " " << type << " != " << network->type();
         return true;
       }
       break;
     }
     case PROPERTY_INDEX_DEVICE: {
       std::string device_path;
-      if (!value->GetAsString(&device_path))
+      if (!value.GetAsString(&device_path))
         break;
       network->set_device_path(device_path);
       return true;
     }
     case PROPERTY_INDEX_NAME: {
       std::string name;
-      if (value->GetAsString(&name)) {
+      if (value.GetAsString(&name)) {
         network->SetName(name);
         return true;
       }
       break;
     }
     case PROPERTY_INDEX_GUID: {
       std::string unique_id;
-      if (!value->GetAsString(&unique_id))
+      if (!value.GetAsString(&unique_id))
         break;
       network->set_unique_id(unique_id);
       return true;
     }
     case PROPERTY_INDEX_PROFILE: {
       // Note: currently this is only provided for non remembered networks.
       std::string profile_path;
-      if (!value->GetAsString(&profile_path))
+      if (!value.GetAsString(&profile_path))
         break;
       network->set_profile_path(profile_path);
       return true;
     }
     case PROPERTY_INDEX_STATE: {
       std::string state_string;
-      if (value->GetAsString(&state_string)) {
+      if (value.GetAsString(&state_string)) {
         network->SetState(ParseState(state_string));
         return true;
       }
       break;
     }
     case PROPERTY_INDEX_MODE: {
       std::string mode_string;
-      if (value->GetAsString(&mode_string)) {
+      if (value.GetAsString(&mode_string)) {
         network->mode_ = ParseMode(mode_string);
         return true;
       }
       break;
     }
     case PROPERTY_INDEX_ERROR: {
       std::string error_string;
-      if (value->GetAsString(&error_string)) {
+      if (value.GetAsString(&error_string)) {
         network->error_ = ParseError(error_string);
         return true;
       }
       break;
     }
     case PROPERTY_INDEX_CONNECTABLE: {
       bool connectable;
-      if (!value->GetAsBoolean(&connectable))
+      if (!value.GetAsBoolean(&connectable))
         break;
       network->set_connectable(connectable);
       return true;
     }
     case PROPERTY_INDEX_IS_ACTIVE: {
       bool is_active;
-      if (!value->GetAsBoolean(&is_active))
+      if (!value.GetAsBoolean(&is_active))
         break;
       network->set_is_active(is_active);
       return true;
     }
     case PROPERTY_INDEX_AUTO_CONNECT: {
       bool auto_connect;
-      if (!value->GetAsBoolean(&auto_connect))
+      if (!value.GetAsBoolean(&auto_connect))
         break;
       network->set_auto_connect(auto_connect);
       return true;
     }
     case PROPERTY_INDEX_SAVE_CREDENTIALS: {
       bool save_credentials;
-      if (!value->GetAsBoolean(&save_credentials))
+      if (!value.GetAsBoolean(&save_credentials))
         break;
       network->set_save_credentials(save_credentials);
       return true;
     }
     default:
       break;
   }
   return false;
 }
 
 }  // namespace chromeos