Convert Pass()→std::move() for Mac build.

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>
 
 #include <algorithm>
+#include <utility>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/mac/scoped_ioobject.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string_util.h"
@@ skipping 77 matching lines @@
 // 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(0);
 
   // Make a service query to find all serial devices.
   CFMutableDictionaryRef matchingDict =
       IOServiceMatching(kIOSerialBSDServiceValue);
   if (!matchingDict)
-    return devices.Pass();
+    return devices;
 
   io_iterator_t it;
   kern_return_t kr =
       IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, &it);
   if (kr != KERN_SUCCESS)
-    return devices.Pass();
+    return devices;
 
   base::mac::ScopedIOObject<io_iterator_t> scoped_it(it);
   base::mac::ScopedIOObject<io_service_t> scoped_device;
   while (scoped_device.reset(IOIteratorNext(scoped_it.get())), scoped_device) {
     serial::DeviceInfoPtr callout_info(serial::DeviceInfo::New());
 
     uint16_t vendorId;
     if (GetUInt16Property(scoped_device.get(), CFSTR(kUSBVendorID),
                           &vendorId)) {
       callout_info->has_vendor_id = true;
@@ skipping 15 matching lines @@
 
     // Each serial device has two "paths" in /dev/ associated with it: a
     // "dialin" path starting with "tty" and a "callout" path starting with
     // "cu". Each of these is considered a different device from Chrome's
     // standpoint, but both should share the device's USB properties.
     mojo::String dialinDevice;
     if (GetStringProperty(scoped_device.get(), CFSTR(kIODialinDeviceKey),
                           &dialinDevice)) {
       serial::DeviceInfoPtr dialin_info = callout_info.Clone();
       dialin_info->path = dialinDevice;
-      devices.push_back(dialin_info.Pass());
+      devices.push_back(std::move(dialin_info));
     }
 
     mojo::String calloutDevice;
     if (GetStringProperty(scoped_device.get(), CFSTR(kIOCalloutDeviceKey),
                           &calloutDevice)) {
       callout_info->path = calloutDevice;
-      devices.push_back(callout_info.Pass());
+      devices.push_back(std::move(callout_info));
     }
   }
 
-  return devices.Pass();
+  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() {
   const base::FilePath kDevRoot("/dev");
   const int kFilesAndSymLinks =
       base::FileEnumerator::FILES | base::FileEnumerator::SHOW_SYM_LINKS;
 
@@ skipping 12 matching lines @@
     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)) {
         serial::DeviceInfoPtr info(serial::DeviceInfo::New());
         info->path = next_device;
-        devices.push_back(info.Pass());
+        devices.push_back(std::move(info));
         break;
       }
     }
   } while (true);
-  return devices.Pass();
+  return devices;
 }
 
 }  // namespace
 
 // static
 scoped_ptr<SerialDeviceEnumerator> SerialDeviceEnumerator::Create() {
   return scoped_ptr<SerialDeviceEnumerator>(new SerialDeviceEnumeratorMac());
 }
 
 SerialDeviceEnumeratorMac::SerialDeviceEnumeratorMac() {}
@@ skipping 18 matching lines @@
     deviceMap.insert(newDevices[i]->path, newDevices[i].Clone());
   }
   for (unsigned long i = 0; i < oldDevices.size(); i++) {
     deviceMap.insert(oldDevices[i]->path, oldDevices[i].Clone());
   }
 
   mojo::Array<mojo::String> paths;
   mojo::Array<serial::DeviceInfoPtr> devices;
   deviceMap.DecomposeMapTo(&paths, &devices);
 
-  return devices.Pass();
+  return devices;
 }
 
 }  // namespace device