Revert of Change base::Value::ListStorage to std::vector<base::Value>

chromeos/network/shill_property_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 "chromeos/network/shill_property_handler.h"
 
 #include <stddef.h>
 
 #include <sstream>
 
@@ skipping 347 matching lines @@
 
 void ShillPropertyHandler::UpdateProperties(ManagedState::ManagedType type,
                                             const base::ListValue& entries) {
   std::set<std::string>& requested_updates = requested_updates_[type];
   std::set<std::string> new_requested_updates;
   NET_LOG(DEBUG) << "UpdateProperties: " << ManagedState::TypeToString(type)
                  << ": " << entries.GetSize();
   for (base::ListValue::const_iterator iter = entries.begin();
        iter != entries.end(); ++iter) {
     std::string path;
-    iter->GetAsString(&path);
+    (*iter)->GetAsString(&path);
     if (path.empty())
       continue;
 
     // We add a special case for devices here to work around an issue in shill
     // that prevents it from sending property changed signals for cellular
     // devices (see crbug.com/321854).
     if (type == ManagedState::MANAGED_TYPE_DEVICE ||
         requested_updates.find(path) == requested_updates.end()) {
       RequestProperties(type, path);
     }
     new_requested_updates.insert(path);
   }
   requested_updates.swap(new_requested_updates);
 }
 
 void ShillPropertyHandler::UpdateObserved(ManagedState::ManagedType type,
                                           const base::ListValue& entries) {
   ShillPropertyObserverMap& observer_map =
       (type == ManagedState::MANAGED_TYPE_NETWORK) ? observed_networks_
                                                    : observed_devices_;
   ShillPropertyObserverMap new_observed;
   for (const auto& entry : entries) {
     std::string path;
-    entry.GetAsString(&path);
+    entry->GetAsString(&path);
     if (path.empty())
       continue;
     auto iter = observer_map.find(path);
     std::unique_ptr<ShillPropertyObserver> observer;
     if (iter != observer_map.end()) {
       observer = std::move(iter->second);
     } else {
       // Create an observer for future updates.
       observer = base::MakeUnique<ShillPropertyObserver>(
           type, path, base::Bind(&ShillPropertyHandler::PropertyChangedCallback,
@@ skipping 12 matching lines @@
   observer_map.swap(new_observed);
 }
 
 void ShillPropertyHandler::UpdateAvailableTechnologies(
     const base::ListValue& technologies) {
   NET_LOG(EVENT) << "AvailableTechnologies:" << technologies;
   available_technologies_.clear();
   for (base::ListValue::const_iterator iter = technologies.begin();
        iter != technologies.end(); ++iter) {
     std::string technology;
-    iter->GetAsString(&technology);
+    (*iter)->GetAsString(&technology);
     DCHECK(!technology.empty());
     available_technologies_.insert(technology);
   }
   listener_->TechnologyListChanged();
 }
 
 void ShillPropertyHandler::UpdateEnabledTechnologies(
     const base::ListValue& technologies) {
   NET_LOG(EVENT) << "EnabledTechnologies:" << technologies;
   enabled_technologies_.clear();
   for (base::ListValue::const_iterator iter = technologies.begin();
        iter != technologies.end(); ++iter) {
     std::string technology;
-    iter->GetAsString(&technology);
+    (*iter)->GetAsString(&technology);
     DCHECK(!technology.empty());
     enabled_technologies_.insert(technology);
     enabling_technologies_.erase(technology);
   }
   listener_->TechnologyListChanged();
 }
 
 void ShillPropertyHandler::UpdateUninitializedTechnologies(
     const base::ListValue& technologies) {
   NET_LOG(EVENT) << "UninitializedTechnologies:" << technologies;
   uninitialized_technologies_.clear();
   for (base::ListValue::const_iterator iter = technologies.begin();
        iter != technologies.end(); ++iter) {
     std::string technology;
-    iter->GetAsString(&technology);
+    (*iter)->GetAsString(&technology);
     DCHECK(!technology.empty());
     uninitialized_technologies_.insert(technology);
   }
   listener_->TechnologyListChanged();
 }
 
 void ShillPropertyHandler::EnableTechnologyFailed(
     const std::string& technology,
     const network_handler::ErrorCallback& error_callback,
     const std::string& dbus_error_name,
@@ skipping 77 matching lines @@
 
 void ShillPropertyHandler::RequestIPConfigsList(
     ManagedState::ManagedType type,
     const std::string& path,
     const base::Value& ip_config_list_value) {
   const base::ListValue* ip_configs;
   if (!ip_config_list_value.GetAsList(&ip_configs))
     return;
   for (base::ListValue::const_iterator iter = ip_configs->begin();
        iter != ip_configs->end(); ++iter) {
-    RequestIPConfig(type, path, *iter);
+    RequestIPConfig(type, path, **iter);
   }
 }
 
 void ShillPropertyHandler::GetIPConfigCallback(
     ManagedState::ManagedType type,
     const std::string& path,
     const std::string& ip_config_path,
     DBusMethodCallStatus call_status,
     const base::DictionaryValue& properties) {
   if (call_status != DBUS_METHOD_CALL_SUCCESS) {
     // IP Config properties not availabe. Shill will emit a property change
     // when they are.
     NET_LOG(EVENT) << "Failed to get IP Config properties: " << ip_config_path
                    << ": " << call_status << ", For: " << path;
     return;
   }
   NET_LOG(EVENT) << "IP Config properties received: " << path;
   listener_->UpdateIPConfigProperties(type, path, ip_config_path, properties);
 }
 
 }  // namespace internal
 }  // namespace chromeos