Eliminate some trivial accessors and use "= default" for some required destructors

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 304 matching lines @@
       client_id_(client_id),
       port_id_(port_id),
       client_name_(client_name),
       port_name_(port_name),
       manufacturer_(manufacturer),
       version_(version),
       web_port_index_(0),
       connected_(true) {
 }
 
-MidiManagerAlsa::MidiPort::~MidiPort() {
-}
+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::string type;
   switch (type_) {
     case Type::kInput:
       type = "input";
       break;
@@ skipping 96 matching lines @@
   // port_name
   // midi_device == -1, for both this and query
   return !connected() && (type() == query.type()) && path().empty() &&
          query.path().empty() && id().empty() && query.id().empty() &&
          (port_id() == query.port_id()) &&
          (client_name() == query.client_name()) &&
          (port_name() == query.port_name()) && (midi_device() == -1) &&
          (query.midi_device() == -1);
 }
 
-MidiManagerAlsa::MidiPortStateBase::~MidiPortStateBase() {
-}
-
-ScopedVector<MidiManagerAlsa::MidiPort>*
-MidiManagerAlsa::MidiPortStateBase::ports() {
-  return &ports_;
-}
+MidiManagerAlsa::MidiPortStateBase::~MidiPortStateBase() = default;
 
 MidiManagerAlsa::MidiPortStateBase::iterator
 MidiManagerAlsa::MidiPortStateBase::Find(
     const MidiManagerAlsa::MidiPort& port) {
   auto result = FindConnected(port);
   if (result == end())
     result = FindDisconnected(port);
   return result;
 }
 
@@ skipping 61 matching lines @@
       return p->MatchNoCardPass2(port);
     });
     if (it != ports_.end())
       return it;
   }
 
   // No match.
   return ports_.end();
 }
 
-MidiManagerAlsa::MidiPortStateBase::MidiPortStateBase() {
-}
+MidiManagerAlsa::MidiPortStateBase::MidiPortStateBase() = default;
 
 void MidiManagerAlsa::TemporaryMidiPortState::Insert(
     scoped_ptr<MidiPort> port) {
   ports()->push_back(port.Pass());
 }
 
 MidiManagerAlsa::MidiPortState::MidiPortState()
     : num_input_ports_(0), num_output_ports_(0) {
 }
 
@@ skipping 10 matching lines @@
   }
   port->set_web_port_index(web_port_index);
   ports()->push_back(port.Pass());
   return web_port_index;
 }
 
 MidiManagerAlsa::AlsaSeqState::AlsaSeqState()
     : clients_deleter_(&clients_), card_client_count_(0) {
 }
 
-MidiManagerAlsa::AlsaSeqState::~AlsaSeqState() {
-}
+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);
   if (IsCardClient(type, client_id))
     ++card_client_count_;
 }
 
@@ skipping 108 matching lines @@
   return midi_ports.Pass();
 }
 
 MidiManagerAlsa::AlsaSeqState::Port::Port(
     const std::string& name,
     MidiManagerAlsa::AlsaSeqState::PortDirection direction,
     bool midi)
     : name_(name), direction_(direction), midi_(midi) {
 }
 
-MidiManagerAlsa::AlsaSeqState::Port::~Port() {
-}
-
-std::string MidiManagerAlsa::AlsaSeqState::Port::name() const {
-  return name_;
-}
-
-MidiManagerAlsa::AlsaSeqState::PortDirection
-MidiManagerAlsa::AlsaSeqState::Port::direction() const {
-  return direction_;
-}
-
-bool MidiManagerAlsa::AlsaSeqState::Port::midi() const {
-  return 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_) {
 }
 
-MidiManagerAlsa::AlsaSeqState::Client::~Client() {
-}
-
-std::string MidiManagerAlsa::AlsaSeqState::Client::name() const {
-  return name_;
-}
-
-snd_seq_client_type_t MidiManagerAlsa::AlsaSeqState::Client::type() const {
-  return type_;
-}
+MidiManagerAlsa::AlsaSeqState::Client::~Client() = default;
 
 void MidiManagerAlsa::AlsaSeqState::Client::AddPort(int addr,
                                                     scoped_ptr<Port> port) {
   RemovePort(addr);
   ports_[addr] = port.release();
 }
 
 void MidiManagerAlsa::AlsaSeqState::Client::RemovePort(int addr) {
   auto it = ports_.find(addr);
   if (it != ports_.end()) {
@@ skipping 47 matching lines @@
   // Get the model id, by either property or sysattr.
   model_id_ =
       UdevDeviceGetPropertyOrSysattr(dev, kUdevIdModelId, kSysattrModel);
   // Get the usb interface number.
   usb_interface_num_ =
       device::UdevDeviceGetPropertyValue(dev, kUdevIdUsbInterfaceNum);
   manufacturer_ = ExtractManufacturerString(
       vendor, vendor_id_, vendor_from_database, alsa_name, alsa_longname);
 }
 
-MidiManagerAlsa::AlsaCard::~AlsaCard() {
-}
+MidiManagerAlsa::AlsaCard::~AlsaCard() = default;
 
 // static
 std::string MidiManagerAlsa::AlsaCard::ExtractManufacturerString(
     const std::string& udev_id_vendor,
     const std::string& udev_id_vendor_id,
     const std::string& udev_id_vendor_from_database,
     const std::string& alsa_name,
     const std::string& alsa_longname) {
   // Let's try to determine the manufacturer. Here is the ordered preference
   // in extraction:
@@ skipping 551 matching lines @@
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace midi
 }  // namespace media