Update usages of std::map to use ScopedPtrMap.

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 <poll.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <string>
@@ skipping 127 matching lines @@
 void SetStringIfNonEmpty(base::DictionaryValue* value,
                          const std::string& path,
                          const std::string& in_value) {
   if (!in_value.empty())
     value->SetString(path, in_value);
 }
 
 }  // namespace
 
 MidiManagerAlsa::MidiManagerAlsa()
-    : alsa_cards_deleter_(&alsa_cards_),
-      udev_(device::udev_new()),
+    : udev_(device::udev_new()),
       send_thread_("MidiSendThread"),
       event_thread_("MidiEventThread") {
   // Initialize decoder.
   snd_midi_event_t* decoder;
   snd_midi_event_new(0, &decoder);
   decoder_.reset(decoder);
   snd_midi_event_no_status(decoder_.get(), 1);
 }
 
 MidiManagerAlsa::~MidiManagerAlsa() {
@@ skipping 420 matching lines @@
       break;
     case MidiPort::Type::kOutput:
       web_port_index = num_output_ports_++;
       break;
   }
   port->set_web_port_index(web_port_index);
   ports().push_back(port.release());
   return web_port_index;
 }
 
-MidiManagerAlsa::AlsaSeqState::AlsaSeqState()
-    : clients_deleter_(&clients_), card_client_count_(0) {
+MidiManagerAlsa::AlsaSeqState::AlsaSeqState() : card_client_count_(0) {
 }
 
 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_[client_id] = new Client(client_name, type);
+  clients_.insert(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);
   if (it != clients_.end()) {
     if (IsCardClient(it->second->type(), client_id))
       --card_client_count_;
-    delete it->second;
     clients_.erase(it);
   }
 }
 
 void MidiManagerAlsa::AlsaSeqState::PortStart(
     int client_id,
     int port_id,
     const std::string& port_name,
     MidiManagerAlsa::AlsaSeqState::PortDirection direction,
     bool midi) {
@@ skipping 96 matching lines @@
     const std::string& name,
     MidiManagerAlsa::AlsaSeqState::PortDirection direction,
     bool midi)
     : name_(name), direction_(direction), midi_(midi) {
 }
 
 MidiManagerAlsa::AlsaSeqState::Port::~Port() = default;
 
 MidiManagerAlsa::AlsaSeqState::Client::Client(const std::string& name,
                                               snd_seq_client_type_t type)
-    : name_(name), type_(type), ports_deleter_(&ports_) {
+    : name_(name), type_(type) {
 }
 
 MidiManagerAlsa::AlsaSeqState::Client::~Client() = default;
 
 void MidiManagerAlsa::AlsaSeqState::Client::AddPort(int addr,
                                                     scoped_ptr<Port> port) {
-  RemovePort(addr);
-  ports_[addr] = port.release();
+  ports_.set(addr, port.Pass());
 }
 
 void MidiManagerAlsa::AlsaSeqState::Client::RemovePort(int addr) {
-  auto it = ports_.find(addr);
-  if (it != ports_.end()) {
-    delete it->second;
-    ports_.erase(it);
-  }
+  ports_.erase(addr);
 }
 
 MidiManagerAlsa::AlsaSeqState::Client::PortMap::const_iterator
 MidiManagerAlsa::AlsaSeqState::Client::begin() const {
   return ports_.begin();
 }
 
 MidiManagerAlsa::AlsaSeqState::Client::PortMap::const_iterator
 MidiManagerAlsa::AlsaSeqState::Client::end() const {
   return ports_.end();
@@ skipping 364 matching lines @@
       VLOG(1) << "snd_ctl_hwdep_info fails: " << snd_strerror(err);
       continue;
     }
     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)
-    alsa_cards_[number] = new AlsaCard(dev, name, longname, driver, midi_count);
-  alsa_card_midi_count_ += midi_count;
+  if (midi_count > 0) {
+    scoped_ptr<AlsaCard> card(
+        new AlsaCard(dev, name, longname, driver, midi_count));
+    alsa_cards_.insert(number, card.Pass());
+    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();
-  delete it->second;
   alsa_cards_.erase(it);
 }
 
 void MidiManagerAlsa::UpdatePortStateAndGenerateEvents() {
   // Verify that our information from ALSA and udev are in sync. If
   // not, we cannot generate events right now.
   if (alsa_card_midi_count_ != alsa_seq_state_.card_client_count())
     return;
 
   // Generate new port state.
@@ skipping 198 matching lines @@
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace midi
 }  // namespace media