Replace scoped_ptr with std::unique_ptr in //media.

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 <stdint.h>
+
 #include <map>
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.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 base {
 class ThreadChecker;
 }
@@ skipping 13 matching lines @@
                             uint32_t port_index,
                             const std::vector<uint8_t>& data,
                             double timestamp) override;
 
  private:
   friend class MidiManagerAlsaTest;
   FRIEND_TEST_ALL_PREFIXES(MidiManagerAlsaTest, ExtractManufacturer);
   FRIEND_TEST_ALL_PREFIXES(MidiManagerAlsaTest, ToMidiPortState);
 
   class AlsaCard;
-  using AlsaCardMap = std::map<int, scoped_ptr<AlsaCard>>;
+  using AlsaCardMap = std::map<int, std::unique_ptr<AlsaCard>>;
 
   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 30 matching lines @@
              int port_id,
              int midi_device,
              const std::string& client_name,
              const std::string& port_name,
              const std::string& manufacturer,
              const std::string& version,
              Type type);
     ~MidiPort();
 
     // Gets a Value representation of this object, suitable for serialization.
-    scoped_ptr<base::Value> Value() const;
+    std::unique_ptr<base::Value> Value() const;
 
     // Gets a string version of Value in JSON format.
     std::string JSONValue() const;
 
     // Gets an opaque identifier for this object, suitable for using as the id
     // field in MidiPort.id on the web. Note that this string does not store
     // the full state.
     std::string OpaqueKey() const;
 
     // Checks for equality for connected ports.
@@ skipping 63 matching lines @@
     uint32_t web_port_index_ = 0;
 
     // Port is present in the ALSA system.
     bool connected_ = true;
 
     DISALLOW_COPY_AND_ASSIGN(MidiPort);
   };
 
   class MidiPortStateBase {
    public:
-    typedef std::vector<scoped_ptr<MidiPort>>::iterator iterator;
+    typedef std::vector<std::unique_ptr<MidiPort>>::iterator iterator;
 
     virtual ~MidiPortStateBase();
 
     // Given a port, finds a port in the internal store.
     iterator Find(const MidiPort& port);
 
     // Given a port, finds a connected port, using exact matching.
     iterator FindConnected(const MidiPort& port);
 
     // Given a port, finds a disconnected port, using heuristic matching.
     iterator FindDisconnected(const MidiPort& port);
 
     iterator begin() { return ports_.begin(); }
     iterator end() { return ports_.end(); }
 
    protected:
     MidiPortStateBase();
     iterator erase(iterator position) { return ports_.erase(position); }
-    void push_back(scoped_ptr<MidiPort> port) {
+    void push_back(std::unique_ptr<MidiPort> port) {
       ports_.push_back(std::move(port));
     }
 
    private:
-    std::vector<scoped_ptr<MidiPort>> ports_;
+    std::vector<std::unique_ptr<MidiPort>> ports_;
 
     DISALLOW_COPY_AND_ASSIGN(MidiPortStateBase);
   };
 
   class TemporaryMidiPortState final : public MidiPortStateBase {
    public:
     iterator erase(iterator position) {
       return MidiPortStateBase::erase(position);
     };
-    void push_back(scoped_ptr<MidiPort> port) {
+    void push_back(std::unique_ptr<MidiPort> port) {
       MidiPortStateBase::push_back(std::move(port));
     }
   };
 
   class MidiPortState final : public MidiPortStateBase {
    public:
     MidiPortState();
 
     // Inserts a port at the end. Returns web_port_index.
-    uint32_t push_back(scoped_ptr<MidiPort> port);
+    uint32_t push_back(std::unique_ptr<MidiPort> port);
 
    private:
     uint32_t num_input_ports_ = 0;
     uint32_t num_output_ports_ = 0;
   };
 
   class AlsaSeqState {
    public:
     enum class PortDirection { kInput, kOutput, kDuplex };
 
     AlsaSeqState();
     ~AlsaSeqState();
 
     void ClientStart(int client_id,
                      const std::string& client_name,
                      snd_seq_client_type_t type);
     bool ClientStarted(int client_id);
     void ClientExit(int client_id);
     void PortStart(int client_id,
                    int port_id,
                    const std::string& port_name,
                    PortDirection direction,
                    bool midi);
     void PortExit(int client_id, int port_id);
     snd_seq_client_type_t ClientType(int client_id) const;
-    scoped_ptr<TemporaryMidiPortState> ToMidiPortState(
+    std::unique_ptr<TemporaryMidiPortState> ToMidiPortState(
         const AlsaCardMap& alsa_cards);
 
     int card_client_count() { return card_client_count_; }
 
    private:
     class Port {
      public:
       Port(const std::string& name, PortDirection direction, bool midi);
       ~Port();
 
       std::string name() const { return name_; }
       PortDirection direction() const { return direction_; }
       // True if this port is a MIDI port, instead of another kind of ALSA port.
       bool midi() const { return midi_; }
 
      private:
       const std::string name_;
       const PortDirection direction_;
       const bool midi_;
 
       DISALLOW_COPY_AND_ASSIGN(Port);
     };
 
     class Client {
      public:
-      using PortMap = std::map<int, scoped_ptr<Port>>;
+      using PortMap = std::map<int, std::unique_ptr<Port>>;
 
       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 AddPort(int addr, std::unique_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_;
 
       DISALLOW_COPY_AND_ASSIGN(Client);
     };
 
-    std::map<int, scoped_ptr<Client>> clients_;
+    std::map<int, std::unique_ptr<Client>> clients_;
 
     // 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_ = 0;
 
     DISALLOW_COPY_AND_ASSIGN(AlsaSeqState);
   };
 
@@ skipping 48 matching lines @@
   };
 
   struct SndMidiEventDeleter {
     void operator()(snd_midi_event_t* coder) const {
       snd_midi_event_free(coder);
     };
   };
 
   using SourceMap = base::hash_map<int, uint32_t>;
   using OutPortMap = base::hash_map<uint32_t, int>;
-  using ScopedSndSeqPtr = scoped_ptr<snd_seq_t, SndSeqDeleter>;
+  using ScopedSndSeqPtr = std::unique_ptr<snd_seq_t, SndSeqDeleter>;
   using ScopedSndMidiEventPtr =
-      scoped_ptr<snd_midi_event_t, SndMidiEventDeleter>;
+      std::unique_ptr<snd_midi_event_t, SndMidiEventDeleter>;
 
   // An internal callback that runs on MidiSendThread.
   void SendMidiData(uint32_t port_index, const std::vector<uint8_t>& data);
 
   void ScheduleEventLoop();
   void EventLoop();
   void ProcessSingleEvent(snd_seq_event_t* event, double timestamp);
   void ProcessClientStartEvent(int client_id);
   void ProcessPortStartEvent(const snd_seq_addr_t& addr);
   void ProcessClientExitEvent(const snd_seq_addr_t& addr);
@@ skipping 40 matching lines @@
   bool event_thread_shutdown_ = false;  // guarded by shutdown_lock_
 
   // This lock is needed to ensure that members destroyed in Finalize
   // will be visibly destroyed before the destructor is run in the
   // other thread. Otherwise, the same objects may have their destructors
   // run multiple times in different threads.
   base::Lock lazy_init_member_lock_;  // guards members below
 
   // Members initialized in StartInitialization() are below.
   // Make sure to destroy these in Finalize()!
-  scoped_ptr<base::ThreadChecker> initialization_thread_checker_;
+  std::unique_ptr<base::ThreadChecker> initialization_thread_checker_;
 
   // ALSA seq handles and ids.
   ScopedSndSeqPtr in_client_;
   int in_client_id_;
   ScopedSndSeqPtr out_client_;
   int out_client_id_;
   int in_port_id_;
 
   // ALSA event -> MIDI coder.
   ScopedSndMidiEventPtr decoder_;
 
   // udev, for querying hardware devices.
   device::ScopedUdevPtr udev_;
   device::ScopedUdevMonitorPtr udev_monitor_;
 
   // Threads for sending and receiving. These are initialized in the
   // constructor, but are started at the end of StartInitialization.
   base::Thread event_thread_;
   base::Thread send_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(MidiManagerAlsa);
 };
 
 }  // namespace midi
 }  // namespace media
 
 #endif  // MEDIA_MIDI_MIDI_MANAGER_ALSA_H_