Replace scoped_ptr with std::unique_ptr 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>
+
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.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"
 #include "crypto/sha2.h"
 #include "media/midi/midi_port_info.h"
 
 namespace media {
@@ skipping 361 matching lines @@
       port_id_(port_id),
       client_name_(client_name),
       port_name_(port_name),
       manufacturer_(manufacturer),
       version_(version) {
 }
 
 MidiManagerAlsa::MidiPort::~MidiPort() = default;
 
 // Note: keep synchronized with the MidiPort::Match* methods.
-scoped_ptr<base::Value> MidiManagerAlsa::MidiPort::Value() const {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+std::unique_ptr<base::Value> MidiManagerAlsa::MidiPort::Value() const {
+  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue);
 
   std::string type;
   switch (type_) {
     case Type::kInput:
       type = "input";
       break;
     case Type::kOutput:
       type = "output";
       break;
   }
@@ skipping 113 matching lines @@
   auto result = FindConnected(port);
   if (result == end())
     result = FindDisconnected(port);
   return result;
 }
 
 MidiManagerAlsa::MidiPortStateBase::iterator
 MidiManagerAlsa::MidiPortStateBase::FindConnected(
     const MidiManagerAlsa::MidiPort& port) {
   // Exact match required for connected ports.
-  auto it = std::find_if(
-      ports_.begin(), ports_.end(),
-      [&port](scoped_ptr<MidiPort>& p) { return p->MatchConnected(port); });
+  auto it = std::find_if(ports_.begin(), ports_.end(),
+                         [&port](std::unique_ptr<MidiPort>& p) {
+                           return p->MatchConnected(port);
+                         });
   return it;
 }
 
 MidiManagerAlsa::MidiPortStateBase::iterator
 MidiManagerAlsa::MidiPortStateBase::FindDisconnected(
     const MidiManagerAlsa::MidiPort& port) {
   // Always match on:
   //  type
   // Possible things to match on:
   //  path
   //  id
   //  client_id
   //  port_id
   //  midi_device
   //  client_name
   //  port_name
 
   if (!port.path().empty()) {
     // If path is present, then we have a card-based client.
 
     // Pass 1. Match on path, id, midi_device, port_id.
     // This is the best possible match for hardware card-based clients.
     // This will also match the empty id correctly for devices without an id.
-    auto it = std::find_if(
-        ports_.begin(), ports_.end(),
-        [&port](scoped_ptr<MidiPort>& p) { return p->MatchCardPass1(port); });
+    auto it = std::find_if(ports_.begin(), ports_.end(),
+                           [&port](std::unique_ptr<MidiPort>& p) {
+                             return p->MatchCardPass1(port);
+                           });
     if (it != ports_.end())
       return it;
 
     if (!port.id().empty()) {
       // Pass 2. Match on id, midi_device, port_id.
       // This will give us a high-confidence match when a user moves a device to
       // another USB/Firewire/Thunderbolt/etc port, but only works if the device
       // has a hardware id.
-      it = std::find_if(
-          ports_.begin(), ports_.end(),
-          [&port](scoped_ptr<MidiPort>& p) { return p->MatchCardPass2(port); });
+      it = std::find_if(ports_.begin(), ports_.end(),
+                        [&port](std::unique_ptr<MidiPort>& p) {
+                          return p->MatchCardPass2(port);
+                        });
       if (it != ports_.end())
         return it;
     }
   } else {
     // Else, we have a non-card-based client.
     // Pass 1. Match on client_id, port_id, client_name, port_name.
     // This will give us a reasonably good match.
-    auto it = std::find_if(
-        ports_.begin(), ports_.end(),
-        [&port](scoped_ptr<MidiPort>& p) { return p->MatchNoCardPass1(port); });
+    auto it = std::find_if(ports_.begin(), ports_.end(),
+                           [&port](std::unique_ptr<MidiPort>& p) {
+                             return p->MatchNoCardPass1(port);
+                           });
     if (it != ports_.end())
       return it;
 
     // Pass 2. Match on port_id, client_name, port_name.
     // This is weaker but similar to pass 2 in the hardware card-based clients
     // match.
-    it = std::find_if(
-        ports_.begin(), ports_.end(),
-        [&port](scoped_ptr<MidiPort>& p) { return p->MatchNoCardPass2(port); });
+    it = std::find_if(ports_.begin(), ports_.end(),
+                      [&port](std::unique_ptr<MidiPort>& p) {
+                        return p->MatchNoCardPass2(port);
+                      });
     if (it != ports_.end())
       return it;
   }
 
   // No match.
   return ports_.end();
 }
 
 MidiManagerAlsa::MidiPortStateBase::MidiPortStateBase() = default;
 
 MidiManagerAlsa::MidiPortState::MidiPortState() = default;
 
-uint32_t MidiManagerAlsa::MidiPortState::push_back(scoped_ptr<MidiPort> port) {
+uint32_t MidiManagerAlsa::MidiPortState::push_back(
+    std::unique_ptr<MidiPort> port) {
   // Add the web midi index.
   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(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) {
   ClientExit(client_id);
   clients_.insert(std::make_pair(
-      client_id, make_scoped_ptr(new Client(client_name, type))));
+      client_id, base::WrapUnique(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_;
     clients_.erase(it);
   }
 }
 
 void MidiManagerAlsa::AlsaSeqState::PortStart(
     int client_id,
     int port_id,
     const std::string& port_name,
     MidiManagerAlsa::AlsaSeqState::PortDirection direction,
     bool midi) {
   auto it = clients_.find(client_id);
   if (it != clients_.end())
     it->second->AddPort(port_id,
-                        make_scoped_ptr(new Port(port_name, direction, midi)));
+                        base::WrapUnique(new Port(port_name, direction, midi)));
 }
 
 void MidiManagerAlsa::AlsaSeqState::PortExit(int client_id, int port_id) {
   auto it = clients_.find(client_id);
   if (it != clients_.end())
     it->second->RemovePort(port_id);
 }
 
 snd_seq_client_type_t MidiManagerAlsa::AlsaSeqState::ClientType(
     int client_id) const {
   auto it = clients_.find(client_id);
   if (it == clients_.end())
     return SND_SEQ_USER_CLIENT;
   return it->second->type();
 }
 
-scoped_ptr<MidiManagerAlsa::TemporaryMidiPortState>
+std::unique_ptr<MidiManagerAlsa::TemporaryMidiPortState>
 MidiManagerAlsa::AlsaSeqState::ToMidiPortState(const AlsaCardMap& alsa_cards) {
-  scoped_ptr<MidiManagerAlsa::TemporaryMidiPortState> midi_ports(
+  std::unique_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.get();
 
     // Get client metadata.
     const std::string client_name = client->name();
@@ skipping 33 matching lines @@
         std::string version;
         if (!driver.empty()) {
           version = driver + " / ";
         }
         version +=
             base::StringPrintf("ALSA library version %d.%d.%d", SND_LIB_MAJOR,
                                SND_LIB_MINOR, SND_LIB_SUBMINOR);
         PortDirection direction = port->direction();
         if (direction == PortDirection::kInput ||
             direction == PortDirection::kDuplex) {
-          midi_ports->push_back(make_scoped_ptr(new MidiPort(
+          midi_ports->push_back(base::WrapUnique(new MidiPort(
               path, id, client_id, port_id, midi_device, client->name(),
               port->name(), manufacturer, version, MidiPort::Type::kInput)));
         }
         if (direction == PortDirection::kOutput ||
             direction == PortDirection::kDuplex) {
-          midi_ports->push_back(make_scoped_ptr(new MidiPort(
+          midi_ports->push_back(base::WrapUnique(new MidiPort(
               path, id, client_id, port_id, midi_device, client->name(),
               port->name(), manufacturer, version, MidiPort::Type::kOutput)));
         }
       }
     }
   }
 
   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;
 
 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) {
+void MidiManagerAlsa::AlsaSeqState::Client::AddPort(
+    int addr,
+    std::unique_ptr<Port> port) {
   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 370 matching lines @@
       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) {
-    scoped_ptr<AlsaCard> card(
+    std::unique_ptr<AlsaCard> card(
         new AlsaCard(dev, name, longname, driver, midi_count));
     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;
@@ skipping 218 matching lines @@
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace midi
 }  // namespace media