Re-write many calls to WrapUnique() with MakeUnique()

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>
@@ skipping 620 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(std::make_pair(
-      client_id, base::WrapUnique(new Client(client_name, type))));
+  clients_.insert(
+      std::make_pair(client_id, base::MakeUnique<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,
-                        base::WrapUnique(new Port(port_name, direction, midi)));
+                        base::MakeUnique<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 {
@@ skipping 52 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(base::WrapUnique(new MidiPort(
+          midi_ports->push_back(base::MakeUnique<MidiPort>(
               path, id, client_id, port_id, midi_device, client->name(),
-              port->name(), manufacturer, version, MidiPort::Type::kInput)));
+              port->name(), manufacturer, version, MidiPort::Type::kInput));
         }
         if (direction == PortDirection::kOutput ||
             direction == PortDirection::kDuplex) {
-          midi_ports->push_back(base::WrapUnique(new MidiPort(
+          midi_ports->push_back(base::MakeUnique<MidiPort>(
               path, id, client_id, port_id, midi_device, client->name(),
-              port->name(), manufacturer, version, MidiPort::Type::kOutput)));
+              port->name(), manufacturer, version, MidiPort::Type::kOutput));
         }
       }
     }
   }
 
   return midi_ports;
 }
 
 MidiManagerAlsa::AlsaSeqState::Port::Port(
     const std::string& name,
@@ skipping 636 matching lines @@
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace midi
 }  // namespace media