Remove mojo::Array.

device/serial/serial_device_enumerator_win.cc

 // Copyright 2014 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 "device/serial/serial_device_enumerator_win.h"
 
 #include <devguid.h>
 #include <setupapi.h>
 #include <stdint.h>
 #include <windows.h>
@@ skipping 70 matching lines @@
 }
 
 // Returns value clamped to the range of [min, max].
 int Clamp(int value, int min, int max) {
   return std::min(std::max(value, min), max);
 }
 
 // Returns an array of devices as retrieved through the new method of
 // enumerating serial devices (SetupDi).  This new method gives more information
 // about the devices than the old method.
-mojo::Array<serial::DeviceInfoPtr> GetDevicesNew() {
-  mojo::Array<serial::DeviceInfoPtr> devices;
+std::vector<serial::DeviceInfoPtr> GetDevicesNew() {
+  std::vector<serial::DeviceInfoPtr> devices;
 
   // Make a device interface query to find all serial devices.
   HDEVINFO dev_info =
       SetupDiGetClassDevs(&GUID_DEVCLASS_PORTS, 0, 0, DIGCF_PRESENT);
   if (dev_info == INVALID_HANDLE_VALUE)
     return devices;
 
   SP_DEVINFO_DATA dev_info_data;
   dev_info_data.cbSize = sizeof(SP_DEVINFO_DATA);
   for (DWORD i = 0; SetupDiEnumDeviceInfo(dev_info, i, &dev_info_data); i++) {
@@ skipping 30 matching lines @@
     devices.push_back(std::move(info));
   }
 
   SetupDiDestroyDeviceInfoList(dev_info);
   return devices;
 }
 
 // Returns an array of devices as retrieved through the old method of
 // enumerating serial devices (searching the registry). This old method gives
 // less information about the devices than the new method.
-mojo::Array<serial::DeviceInfoPtr> GetDevicesOld() {
+std::vector<serial::DeviceInfoPtr> GetDevicesOld() {
   base::win::RegistryValueIterator iter_key(
       HKEY_LOCAL_MACHINE, L"HARDWARE\\DEVICEMAP\\SERIALCOMM\\");
-  mojo::Array<serial::DeviceInfoPtr> devices;
+  std::vector<serial::DeviceInfoPtr> devices;
   for (; iter_key.Valid(); ++iter_key) {
     serial::DeviceInfoPtr info(serial::DeviceInfo::New());
     info->path = base::UTF16ToASCII(iter_key.Value());
     devices.push_back(std::move(info));
   }
   return devices;
 }
 
 }  // namespace
 
 // static
 std::unique_ptr<SerialDeviceEnumerator> SerialDeviceEnumerator::Create() {
   return std::unique_ptr<SerialDeviceEnumerator>(
       new SerialDeviceEnumeratorWin());
 }
 
 SerialDeviceEnumeratorWin::SerialDeviceEnumeratorWin() {}
 
 SerialDeviceEnumeratorWin::~SerialDeviceEnumeratorWin() {}
 
-mojo::Array<serial::DeviceInfoPtr> SerialDeviceEnumeratorWin::GetDevices() {
-  mojo::Array<serial::DeviceInfoPtr> devices = GetDevicesNew();
-  mojo::Array<serial::DeviceInfoPtr> old_devices = GetDevicesOld();
+std::vector<serial::DeviceInfoPtr> SerialDeviceEnumeratorWin::GetDevices() {
+  std::vector<serial::DeviceInfoPtr> devices = GetDevicesNew();
+  std::vector<serial::DeviceInfoPtr> old_devices = GetDevicesOld();
 
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       "Hardware.Serial.NewMinusOldDeviceListSize",
       Clamp(devices.size() - old_devices.size(), -10, 10));
 
   // Add devices found from both the new and old methods of enumeration. If a
   // device is found using both the new and the old enumeration method, then we
   // take the device from the new enumeration method because it's able to
   // collect more information. We do this by inserting the new devices first,
   // because insertions are ignored if the key already exists.
   std::unordered_set<std::string> devices_seen;
   for (const auto& device : devices) {
     bool inserted = devices_seen.insert(device->path).second;
     DCHECK(inserted);
   }
   for (auto& device : old_devices) {
     if (devices_seen.insert(device->path).second)
       devices.push_back(std::move(device));
   }
   return devices;
 }
 
 }  // namespace device