ScopedPtrMap -> std::map from apps, ash, media, ui

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 <stdlib.h>
 #include <algorithm>
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/safe_strerror.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
@@ skipping 563 matching lines @@
 }
 
 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) {
   ClientExit(client_id);
-  clients_.insert(client_id, make_scoped_ptr(new Client(client_name, type)));
+  clients_.insert(std::make_pair(
+      client_id, make_scoped_ptr(new Client(client_name, type))));
   if (IsCardClient(type, client_id))
     ++card_client_count_;
 }
 
 bool MidiManagerAlsa::AlsaSeqState::ClientStarted(int client_id) {
   return clients_.find(client_id) != clients_.end();
 }
 
 void MidiManagerAlsa::AlsaSeqState::ClientExit(int client_id) {
   auto it = clients_.find(client_id);
@@ skipping 32 matching lines @@
 
 scoped_ptr<MidiManagerAlsa::TemporaryMidiPortState>
 MidiManagerAlsa::AlsaSeqState::ToMidiPortState(const AlsaCardMap& alsa_cards) {
   scoped_ptr<MidiManagerAlsa::TemporaryMidiPortState> midi_ports(
       new TemporaryMidiPortState);
   auto card_it = alsa_cards.begin();
 
   int card_midi_device = -1;
   for (const auto& client_pair : clients_) {
     int client_id = client_pair.first;
-    const auto& client = client_pair.second;
+    const auto& client = client_pair.second.get();
 
     // Get client metadata.
     const std::string client_name = client->name();
     std::string manufacturer;
     std::string driver;
     std::string path;
     MidiPort::Id id;
     std::string card_name;
     std::string card_longname;
     int midi_device = -1;
@@ skipping 61 matching lines @@
 
 MidiManagerAlsa::AlsaSeqState::Client::Client(const std::string& name,
                                               snd_seq_client_type_t type)
     : name_(name), type_(type) {
 }
 
 MidiManagerAlsa::AlsaSeqState::Client::~Client() = default;
 
 void MidiManagerAlsa::AlsaSeqState::Client::AddPort(int addr,
                                                     scoped_ptr<Port> port) {
-  ports_.set(addr, port.Pass());
+  ports_[addr] = std::move(port);
 }
 
 void MidiManagerAlsa::AlsaSeqState::Client::RemovePort(int addr) {
   ports_.erase(addr);
 }
 
 MidiManagerAlsa::AlsaSeqState::Client::PortMap::const_iterator
 MidiManagerAlsa::AlsaSeqState::Client::begin() const {
   return ports_.begin();
 }
@@ skipping 371 matching lines @@
     snd_hwdep_iface_t iface = snd_hwdep_info_get_iface(hwdep);
     if (iface == SND_HWDEP_IFACE_OPL2 || iface == SND_HWDEP_IFACE_OPL3 ||
         iface == SND_HWDEP_IFACE_OPL4)
       ++midi_count;
   }
   snd_ctl_close(handle);
 
   if (midi_count > 0) {
     scoped_ptr<AlsaCard> card(
         new AlsaCard(dev, name, longname, driver, midi_count));
-    alsa_cards_.insert(number, card.Pass());
+    alsa_cards_.insert(std::make_pair(number, std::move(card)));
     alsa_card_midi_count_ += midi_count;
   }
 }
 
 void MidiManagerAlsa::RemoveCard(int number) {
   auto it = alsa_cards_.find(number);
   if (it == alsa_cards_.end())
     return;
 
   alsa_card_midi_count_ -= it->second->midi_device_count();
@@ skipping 208 matching lines @@
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace midi
 }  // namespace media