Replace deprecated ScopedVector<T> in chromeos::NetworkSmsHandler

chromeos/network/network_sms_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/network_sms_handler.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <deque>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/gsm_sms_client.h"
 #include "chromeos/dbus/modem_messaging_client.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/sms_client.h"
 #include "dbus/object_path.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
@@ skipping 320 matching lines @@
       this);
   // Request network manager properties so that we can get the list of devices.
   DBusThreadManager::Get()->GetShillManagerClient()->GetProperties(
       base::Bind(&NetworkSmsHandler::ManagerPropertiesCallback,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void NetworkSmsHandler::RequestUpdate(bool request_existing) {
   // If we already received messages and |request_existing| is true, send
   // updates for existing messages.
-  for (ScopedVector<base::DictionaryValue>::iterator iter =
-           received_messages_.begin();
-       iter != received_messages_.end(); ++iter) {
-    base::DictionaryValue* message = *iter;
+  for (const auto& message : received_messages_) {
     NotifyMessageReceived(*message);
   }
   // Request updates from each device.
-  for (ScopedVector<NetworkSmsDeviceHandler>::iterator iter =
-           device_handlers_.begin(); iter != device_handlers_.end(); ++iter) {
-    (*iter)->RequestUpdate();
+  for (auto& handler : device_handlers_) {
+    handler->RequestUpdate();
   }
 }
 
 void NetworkSmsHandler::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void NetworkSmsHandler::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void NetworkSmsHandler::OnPropertyChanged(const std::string& name,
                                           const base::Value& value) {
   if (name != shill::kDevicesProperty)
     return;
   const base::ListValue* devices = NULL;
   if (!value.GetAsList(&devices) || !devices)
     return;
   UpdateDevices(devices);
 }
 
 // Private methods
 
 void NetworkSmsHandler::AddReceivedMessage(
     const base::DictionaryValue& message) {
-  base::DictionaryValue* new_message = message.DeepCopy();
   if (received_messages_.size() >= kMaxReceivedMessages)
     received_messages_.erase(received_messages_.begin());
-  received_messages_.push_back(new_message);
+  received_messages_.push_back(message.CreateDeepCopy());
 }
 
 void NetworkSmsHandler::NotifyMessageReceived(
     const base::DictionaryValue& message) {
   FOR_EACH_OBSERVER(Observer, observers_, MessageReceived(message));
 }
 
 void NetworkSmsHandler::MessageReceived(const base::DictionaryValue& message) {
   AddReceivedMessage(message);
   NotifyMessageReceived(message);
@@ skipping 62 matching lines @@
 
   std::string object_path_string;
   if (!properties.GetStringWithoutPathExpansion(
           shill::kDBusObjectProperty, &object_path_string)) {
     LOG(ERROR) << "Device has no DBusObject Property: " << device_path;
     return;
   }
   dbus::ObjectPath object_path(object_path_string);
   if (service_name == modemmanager::kModemManager1ServiceName) {
     device_handlers_.push_back(
-        new ModemManager1NetworkSmsDeviceHandler(
+        base::MakeUnique<ModemManager1NetworkSmsDeviceHandler>(
             this, service_name, object_path));
   } else {
     device_handlers_.push_back(
-        new ModemManagerNetworkSmsDeviceHandler(
+        base::MakeUnique<ModemManagerNetworkSmsDeviceHandler>(
             this, service_name, object_path));
   }
 }
 
 }  // namespace chromeos