Remove mojo::Array.

device/serial/serial_device_enumerator_mac.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_mac.h"
 
 #include <IOKit/serial/IOSerialKeys.h>
 #include <IOKit/usb/IOUSBLib.h>
 #include <stdint.h>
 
@@ skipping 83 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 (IOKit).  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 service query to find all serial devices.
   CFMutableDictionaryRef matchingDict =
       IOServiceMatching(kIOSerialBSDServiceValue);
   if (!matchingDict)
     return devices;
 
   io_iterator_t it;
   kern_return_t kr =
       IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, &it);
@@ skipping 44 matching lines @@
       devices.push_back(std::move(callout_info));
     }
   }
 
   return devices;
 }
 
 // Returns an array of devices as retrieved through the old method of
 // enumerating serial devices (pattern matching in /dev/). This old method gives
 // less information about the devices than the new method.
-mojo::Array<serial::DeviceInfoPtr> GetDevicesOld() {
+std::vector<serial::DeviceInfoPtr> GetDevicesOld() {
   const base::FilePath kDevRoot("/dev");
   const int kFilesAndSymLinks =
       base::FileEnumerator::FILES | base::FileEnumerator::SHOW_SYM_LINKS;
 
   std::set<std::string> valid_patterns;
   valid_patterns.insert("/dev/*Bluetooth*");
   valid_patterns.insert("/dev/*Modem*");
   valid_patterns.insert("/dev/*bluetooth*");
   valid_patterns.insert("/dev/*modem*");
   valid_patterns.insert("/dev/*serial*");
   valid_patterns.insert("/dev/tty.*");
   valid_patterns.insert("/dev/cu.*");
 
-  mojo::Array<serial::DeviceInfoPtr> devices;
+  std::vector<serial::DeviceInfoPtr> devices;
   base::FileEnumerator enumerator(kDevRoot, false, kFilesAndSymLinks);
   do {
     const base::FilePath next_device_path(enumerator.Next());
     const std::string next_device = next_device_path.value();
     if (next_device.empty())
       break;
 
     std::set<std::string>::const_iterator i = valid_patterns.begin();
     for (; i != valid_patterns.end(); ++i) {
       if (base::MatchPattern(next_device, *i)) {
@@ skipping 12 matching lines @@
 // static
 std::unique_ptr<SerialDeviceEnumerator> SerialDeviceEnumerator::Create() {
   return std::unique_ptr<SerialDeviceEnumerator>(
       new SerialDeviceEnumeratorMac());
 }
 
 SerialDeviceEnumeratorMac::SerialDeviceEnumeratorMac() {}
 
 SerialDeviceEnumeratorMac::~SerialDeviceEnumeratorMac() {}
 
-mojo::Array<serial::DeviceInfoPtr> SerialDeviceEnumeratorMac::GetDevices() {
-  mojo::Array<serial::DeviceInfoPtr> devices = GetDevicesNew();
-  mojo::Array<serial::DeviceInfoPtr> old_devices = GetDevicesOld();
+std::vector<serial::DeviceInfoPtr> SerialDeviceEnumeratorMac::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