Update usages of std::map to use ScopedPtrMap.

media/midi/midi_manager_alsa.h

 // 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.
 
 #ifndef MEDIA_MIDI_MIDI_MANAGER_ALSA_H_
 #define MEDIA_MIDI_MIDI_MANAGER_ALSA_H_
 
 #include <alsa/asoundlib.h>
-#include <map>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/containers/scoped_ptr_map.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
-#include "base/stl_util.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
 #include "device/udev_linux/scoped_udev.h"
 #include "media/midi/midi_export.h"
 #include "media/midi/midi_manager.h"
 
 namespace media {
 namespace midi {
 
 class MIDI_EXPORT MidiManagerAlsa final : public MidiManager {
  public:
   MidiManagerAlsa();
   ~MidiManagerAlsa() override;
 
   // MidiManager implementation.
   void StartInitialization() override;
   void DispatchSendMidiData(MidiManagerClient* client,
                             uint32 port_index,
                             const std::vector<uint8>& data,
                             double timestamp) override;
 
  private:
   friend class MidiManagerAlsaTest;
   FRIEND_TEST_ALL_PREFIXES(MidiManagerAlsaTest, ExtractManufacturer);
   FRIEND_TEST_ALL_PREFIXES(MidiManagerAlsaTest, ToMidiPortState);
 
   class AlsaCard;
-  typedef std::map<int, AlsaCard*> AlsaCardMap;
+  typedef ScopedPtrMap<int, scoped_ptr<AlsaCard>> AlsaCardMap;
 
   class MidiPort {
    public:
     enum class Type { kInput, kOutput };
 
     // The Id class is used to keep the multiple strings separate
     // but compare them all together for equality purposes.
     // The individual strings that make up the Id can theoretically contain
     // arbitrary characters, so unfortunately there is no simple way to
     // concatenate them into a single string.
@@ skipping 208 matching lines @@
      private:
       const std::string name_;
       const PortDirection direction_;
       const bool midi_;
 
       DISALLOW_COPY_AND_ASSIGN(Port);
     };
 
     class Client {
      public:
-      typedef std::map<int, Port*> PortMap;
+      typedef ScopedPtrMap<int, scoped_ptr<Port>> PortMap;
 
       Client(const std::string& name, snd_seq_client_type_t type);
       ~Client();
 
       std::string name() const { return name_; }
       snd_seq_client_type_t type() const { return type_; }
       void AddPort(int addr, scoped_ptr<Port> port);
       void RemovePort(int addr);
       PortMap::const_iterator begin() const;
       PortMap::const_iterator end() const;
 
      private:
       const std::string name_;
       const snd_seq_client_type_t type_;
       PortMap ports_;
-      STLValueDeleter<PortMap> ports_deleter_;
 
       DISALLOW_COPY_AND_ASSIGN(Client);
     };
 
-    typedef std::map<int, Client*> ClientMap;
+    typedef ScopedPtrMap<int, scoped_ptr<Client>> ClientMap;
 
     ClientMap clients_;
-    STLValueDeleter<ClientMap> clients_deleter_;
 
     // This is the current number of clients we know about that have
     // cards. When this number matches alsa_card_midi_count_, we know
     // we are in sync between ALSA and udev. Until then, we cannot generate
     // MIDIConnectionEvents to web clients.
     int card_client_count_;
 
     DISALLOW_COPY_AND_ASSIGN(AlsaSeqState);
   };
 
@@ skipping 85 matching lines @@
   // One input port, many output ports.
   int in_port_id_;
   OutPortMap out_ports_;       // guarded by out_ports_lock_
   base::Lock out_ports_lock_;  // guards out_ports_
 
   // Mapping from ALSA client:port to our index.
   SourceMap source_map_;
 
   // Mapping from card to devices.
   AlsaCardMap alsa_cards_;
-  STLValueDeleter<AlsaCardMap> alsa_cards_deleter_;
 
   // This is the current count of midi devices across all cards we know
   // about. When this number matches card_client_count_ in AlsaSeqState,
   // we are safe to generate MIDIConnectionEvents. Otherwise we need to
   // wait for our information from ALSA and udev to get back in sync.
   int alsa_card_midi_count_;
 
   // ALSA event -> MIDI coder.
   snd_midi_event_t* decoder_;
 
   // udev, for querying hardware devices.
   device::ScopedUdevPtr udev_;
   device::ScopedUdevMonitorPtr udev_monitor_;
 
   base::Thread send_thread_;
   base::Thread event_thread_;
 
   bool event_thread_shutdown_;  // guarded by shutdown_lock_
   base::Lock shutdown_lock_;    // guards event_thread_shutdown_
 
   DISALLOW_COPY_AND_ASSIGN(MidiManagerAlsa);
 };
 
 }  // namespace midi
 }  // namespace media
 
 #endif  // MEDIA_MIDI_MIDI_MANAGER_ALSA_H_