Convert Pass()→std::move() in //media

media/midi/midi_manager_alsa.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 "media/midi/midi_manager_alsa.h"
 
 #include <errno.h>
 #include <poll.h>
 #include <stddef.h>
 #include <stdlib.h>
@@ skipping 369 matching lines @@
   value->SetInteger("portId", port_id_);
   value->SetInteger("midiDevice", midi_device_);
 
   // Flatten id fields.
   SetStringIfNonEmpty(value.get(), "bus", id_.bus());
   SetStringIfNonEmpty(value.get(), "vendorId", id_.vendor_id());
   SetStringIfNonEmpty(value.get(), "modelId", id_.model_id());
   SetStringIfNonEmpty(value.get(), "usbInterfaceNum", id_.usb_interface_num());
   SetStringIfNonEmpty(value.get(), "serial", id_.serial());
 
-  return value.Pass();
+  return std::move(value);
 }
 
 std::string MidiManagerAlsa::MidiPort::JSONValue() const {
   std::string json;
   JSONStringValueSerializer serializer(&json);
   serializer.Serialize(*Value().get());
   return json;
 }
 
 // TODO(agoode): Do not use SHA256 here. Instead store a persistent
@@ skipping 170 matching lines @@
   uint32_t web_port_index = 0;
   switch (port->type()) {
     case MidiPort::Type::kInput:
       web_port_index = num_input_ports_++;
       break;
     case MidiPort::Type::kOutput:
       web_port_index = num_output_ports_++;
       break;
   }
   port->set_web_port_index(web_port_index);
-  MidiPortStateBase::push_back(port.Pass());
+  MidiPortStateBase::push_back(std::move(port));
   return web_port_index;
 }
 
 MidiManagerAlsa::AlsaSeqState::AlsaSeqState() = default;
 
 MidiManagerAlsa::AlsaSeqState::~AlsaSeqState() = default;
 
 void MidiManagerAlsa::AlsaSeqState::ClientStart(int client_id,
                                                 const std::string& client_name,
                                                 snd_seq_client_type_t type) {
@@ skipping 106 matching lines @@
         if (direction == PortDirection::kOutput ||
             direction == PortDirection::kDuplex) {
           midi_ports->push_back(make_scoped_ptr(new MidiPort(
               path, id, client_id, port_id, midi_device, client->name(),
               port->name(), manufacturer, version, MidiPort::Type::kOutput)));
         }
       }
     }
   }
 
-  return midi_ports.Pass();
+  return midi_ports;
 }
 
 MidiManagerAlsa::AlsaSeqState::Port::Port(
     const std::string& name,
     MidiManagerAlsa::AlsaSeqState::PortDirection direction,
     bool midi)
     : name_(name), direction_(direction), midi_(midi) {
 }
 
 MidiManagerAlsa::AlsaSeqState::Port::~Port() = default;
@@ skipping 450 matching lines @@
     if (old_port == port_state_.end()) {
       // Add new port.
       const auto& opaque_key = new_port->OpaqueKey();
       const auto& manufacturer = new_port->manufacturer();
       const auto& port_name = new_port->port_name();
       const auto& version = new_port->version();
       const auto& type = new_port->type();
       const auto& client_id = new_port->client_id();
       const auto& port_id = new_port->port_id();
 
-      uint32_t web_port_index = port_state_.push_back(new_port.Pass());
+      uint32_t web_port_index = port_state_.push_back(std::move(new_port));
       it = new_port_state->erase(it);
 
       MidiPortInfo info(opaque_key, manufacturer, port_name, version,
                         MIDI_PORT_OPENED);
       switch (type) {
         case MidiPort::Type::kInput:
           if (Subscribe(web_port_index, client_id, port_id))
             AddInputPort(info);
           break;
         case MidiPort::Type::kOutput:
@@ skipping 158 matching lines @@
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace midi
 }  // namespace media