Web MIDI: make naming convention be consistent

Naming cleanup based on following rules:
 - MidiFooBar ... use this style to be consistent with chromium
 - WebMIDIFooBar ... Web API name related things, or names in blink
 - MIDIFooBar ... APIs and structures defined by each operating systems

Other cleanup:
 - Modify some TODO(crogers) to TODO(toyoshim)
 - Add some crbug links.
 - Remove some obsolete UI TODOs related to infobars

BUG=none
TEST=build for all platforms

Review URL: https://codereview.chromium.org/151343002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@248686 0039d316-1c4b-4281-b951-d872f2087c98

20 files changed, 207 insertions, 206 deletions

diff --git a/media/midi/midi_manager.cc b/media/midi/midi_manager.cc
index 1d5838b..49a51b3 100644
--- a/media/midi/midi_manager.cc
+++ b/media/midi/midi_manager.cc
@@ -10,20 +10,20 @@
 namespace media {
 
 #if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(USE_ALSA)
-// TODO(toyoshim): implement MIDIManager for other platforms.
-MIDIManager* MIDIManager::Create() {
-  return new MIDIManager;
+// TODO(toyoshim): implement MidiManager for other platforms.
+MidiManager* MidiManager::Create() {
+  return new MidiManager;
 }
 #endif
 
-MIDIManager::MIDIManager()
+MidiManager::MidiManager()
     : initialized_(false) {
 }
 
-MIDIManager::~MIDIManager() {
+MidiManager::~MidiManager() {
 }
 
-bool MIDIManager::StartSession(MIDIManagerClient* client) {
+bool MidiManager::StartSession(MidiManagerClient* client) {
   // Lazily initialize the MIDI back-end.
   if (!initialized_)
     initialized_ = Initialize();
@@ -36,33 +36,33 @@ bool MIDIManager::StartSession(MIDIManagerClient* client) {
   return initialized_;
 }
 
-void MIDIManager::EndSession(MIDIManagerClient* client) {
+void MidiManager::EndSession(MidiManagerClient* client) {
   base::AutoLock auto_lock(clients_lock_);
   ClientList::iterator i = clients_.find(client);
   if (i != clients_.end())
     clients_.erase(i);
 }
 
-void MIDIManager::DispatchSendMIDIData(MIDIManagerClient* client,
+void MidiManager::DispatchSendMidiData(MidiManagerClient* client,
                                        uint32 port_index,
                                        const std::vector<uint8>& data,
                                        double timestamp) {
   NOTREACHED();
 }
 
-bool MIDIManager::Initialize() {
+bool MidiManager::Initialize() {
   return false;
 }
 
-void MIDIManager::AddInputPort(const MIDIPortInfo& info) {
+void MidiManager::AddInputPort(const MidiPortInfo& info) {
   input_ports_.push_back(info);
 }
 
-void MIDIManager::AddOutputPort(const MIDIPortInfo& info) {
+void MidiManager::AddOutputPort(const MidiPortInfo& info) {
   output_ports_.push_back(info);
 }
 
-void MIDIManager::ReceiveMIDIData(
+void MidiManager::ReceiveMidiData(
     uint32 port_index,
     const uint8* data,
     size_t length,
@@ -70,7 +70,7 @@ void MIDIManager::ReceiveMIDIData(
   base::AutoLock auto_lock(clients_lock_);
 
   for (ClientList::iterator i = clients_.begin(); i != clients_.end(); ++i)
-    (*i)->ReceiveMIDIData(port_index, data, length, timestamp);
+    (*i)->ReceiveMidiData(port_index, data, length, timestamp);
 }
 
 }  // namespace media
diff --git a/media/midi/midi_manager.h b/media/midi/midi_manager.h
index 3b102ec..dd7828b 100644
--- a/media/midi/midi_manager.h
+++ b/media/midi/midi_manager.h
@@ -15,49 +15,49 @@
 
 namespace media {
 
-// A MIDIManagerClient registers with the MIDIManager to receive MIDI data.
-// See MIDIManager::RequestAccess() and MIDIManager::ReleaseAccess()
+// A MidiManagerClient registers with the MidiManager to receive MIDI data.
+// See MidiManager::RequestAccess() and MidiManager::ReleaseAccess()
 // for details.
-class MEDIA_EXPORT MIDIManagerClient {
+class MEDIA_EXPORT MidiManagerClient {
  public:
-   virtual ~MIDIManagerClient() {}
+   virtual ~MidiManagerClient() {}
 
-  // ReceiveMIDIData() is called when MIDI data has been received from the
+  // ReceiveMidiData() is called when MIDI data has been received from the
   // MIDI system.
   // |port_index| represents the specific input port from input_ports().
   // |data| represents a series of bytes encoding one or more MIDI messages.
   // |length| is the number of bytes in |data|.
   // |timestamp| is the time the data was received, in seconds.
-  virtual void ReceiveMIDIData(uint32 port_index,
+  virtual void ReceiveMidiData(uint32 port_index,
                                const uint8* data,
                                size_t length,
                                double timestamp) = 0;
 
-  // AccumulateMIDIBytesSent() is called to acknowledge when bytes have
+  // AccumulateMidiBytesSent() is called to acknowledge when bytes have
   // successfully been sent to the hardware.
   // This happens as a result of the client having previously called
-  // MIDIManager::DispatchSendMIDIData().
-  virtual void AccumulateMIDIBytesSent(size_t n) = 0;
+  // MidiManager::DispatchSendMidiData().
+  virtual void AccumulateMidiBytesSent(size_t n) = 0;
 };
 
 // Manages access to all MIDI hardware.
-class MEDIA_EXPORT MIDIManager {
+class MEDIA_EXPORT MidiManager {
  public:
-  static MIDIManager* Create();
+  static MidiManager* Create();
 
-  MIDIManager();
-  virtual ~MIDIManager();
+  MidiManager();
+  virtual ~MidiManager();
 
   // A client calls StartSession() to receive and send MIDI data.
   // If the session is ready to start, the MIDI system is lazily initialized
   // and the client is registered to receive MIDI data.
   // Returns |true| if the session succeeds to start.
-  bool StartSession(MIDIManagerClient* client);
+  bool StartSession(MidiManagerClient* client);
 
   // A client calls ReleaseSession() to stop receiving MIDI data.
-  void EndSession(MIDIManagerClient* client);
+  void EndSession(MidiManagerClient* client);
 
-  // DispatchSendMIDIData() is called when MIDI data should be sent to the MIDI
+  // DispatchSendMidiData() is called when MIDI data should be sent to the MIDI
   // system.
   // This method is supposed to return immediately and should not block.
   // |port_index| represents the specific output port from output_ports().
@@ -66,7 +66,7 @@ class MEDIA_EXPORT MIDIManager {
   // |timestamp| is the time to send the data, in seconds. A value of 0
   // means send "now" or as soon as possible.
   // The default implementation is for unsupported platforms.
-  virtual void DispatchSendMIDIData(MIDIManagerClient* client,
+  virtual void DispatchSendMidiData(MidiManagerClient* client,
                                     uint32 port_index,
                                     const std::vector<uint8>& data,
                                     double timestamp);
@@ -74,23 +74,23 @@ class MEDIA_EXPORT MIDIManager {
   // input_ports() is a list of MIDI ports for receiving MIDI data.
   // Each individual port in this list can be identified by its
   // integer index into this list.
-  const MIDIPortInfoList& input_ports() { return input_ports_; }
+  const MidiPortInfoList& input_ports() { return input_ports_; }
 
   // output_ports() is a list of MIDI ports for sending MIDI data.
   // Each individual port in this list can be identified by its
   // integer index into this list.
-  const MIDIPortInfoList& output_ports() { return output_ports_; }
+  const MidiPortInfoList& output_ports() { return output_ports_; }
 
  protected:
   // Initializes the MIDI system, returning |true| on success.
   // The default implementation is for unsupported platforms.
   virtual bool Initialize();
 
-  void AddInputPort(const MIDIPortInfo& info);
-  void AddOutputPort(const MIDIPortInfo& info);
+  void AddInputPort(const MidiPortInfo& info);
+  void AddOutputPort(const MidiPortInfo& info);
 
   // Dispatches to all clients.
-  void ReceiveMIDIData(uint32 port_index,
+  void ReceiveMidiData(uint32 port_index,
                        const uint8* data,
                        size_t length,
                        double timestamp);
@@ -98,16 +98,16 @@ class MEDIA_EXPORT MIDIManager {
   bool initialized_;
 
   // Keeps track of all clients who wish to receive MIDI data.
-  typedef std::set<MIDIManagerClient*> ClientList;
+  typedef std::set<MidiManagerClient*> ClientList;
   ClientList clients_;
 
   // Protects access to our clients.
   base::Lock clients_lock_;
 
-  MIDIPortInfoList input_ports_;
-  MIDIPortInfoList output_ports_;
+  MidiPortInfoList input_ports_;
+  MidiPortInfoList output_ports_;
 
-  DISALLOW_COPY_AND_ASSIGN(MIDIManager);
+  DISALLOW_COPY_AND_ASSIGN(MidiManager);
 };
 
 }  // namespace media
diff --git a/media/midi/midi_manager_alsa.cc b/media/midi/midi_manager_alsa.cc
index c350c61..6f389ca 100644
--- a/media/midi/midi_manager_alsa.cc
+++ b/media/midi/midi_manager_alsa.cc
@@ -17,10 +17,10 @@
 
 namespace media {
 
-class MIDIManagerAlsa::MIDIDeviceInfo
-    : public base::RefCounted<MIDIDeviceInfo> {
+class MidiManagerAlsa::MidiDeviceInfo
+    : public base::RefCounted<MidiDeviceInfo> {
  public:
-  MIDIDeviceInfo(MIDIManagerAlsa* manager,
+  MidiDeviceInfo(MidiManagerAlsa* manager,
                  const std::string& bus_id,
                  snd_ctl_card_info_t* card,
                  const snd_rawmidi_info_t* midi,
@@ -43,10 +43,10 @@ class MIDIManagerAlsa::MIDIDeviceInfo
         base::StringPrintf("%s / ALSA library version %d.%d.%d",
                            snd_ctl_card_info_get_driver(card),
                            SND_LIB_MAJOR, SND_LIB_MINOR, SND_LIB_SUBMINOR);
-    port_info_ = MIDIPortInfo(id, manufacturer, name, version);
+    port_info_ = MidiPortInfo(id, manufacturer, name, version);
   }
 
-  void Send(MIDIManagerClient* client, const std::vector<uint8>& data) {
+  void Send(MidiManagerClient* client, const std::vector<uint8>& data) {
     ssize_t result = snd_rawmidi_write(
         midi_out_, reinterpret_cast<const void*>(&data[0]), data.size());
     if (static_cast<size_t>(result) != data.size()) {
@@ -55,16 +55,16 @@ class MIDIManagerAlsa::MIDIDeviceInfo
     }
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(&MIDIManagerClient::AccumulateMIDIBytesSent,
+        base::Bind(&MidiManagerClient::AccumulateMidiBytesSent,
                    base::Unretained(client), data.size()));
   }
 
-  const MIDIPortInfo& GetMIDIPortInfo() const { return port_info_; }
+  const MidiPortInfo& GetMidiPortInfo() const { return port_info_; }
   bool IsOpened() const { return opened_; }
 
  private:
-  friend class base::RefCounted<MIDIDeviceInfo>;
-  virtual ~MIDIDeviceInfo() {
+  friend class base::RefCounted<MidiDeviceInfo>;
+  virtual ~MidiDeviceInfo() {
     if (opened_) {
       snd_rawmidi_close(midi_in_);
       snd_rawmidi_close(midi_out_);
@@ -72,20 +72,21 @@ class MIDIManagerAlsa::MIDIDeviceInfo
   }
 
   bool opened_;
-  MIDIPortInfo port_info_;
+  MidiPortInfo port_info_;
   snd_rawmidi_t* midi_in_;
   snd_rawmidi_t* midi_out_;
 
-  DISALLOW_COPY_AND_ASSIGN(MIDIDeviceInfo);
+  DISALLOW_COPY_AND_ASSIGN(MidiDeviceInfo);
 };
 
-MIDIManagerAlsa::MIDIManagerAlsa()
-    : send_thread_("MIDISendThread") {
+MidiManagerAlsa::MidiManagerAlsa()
+    : send_thread_("MidiSendThread") {
 }
 
-bool MIDIManagerAlsa::Initialize() {
+bool MidiManagerAlsa::Initialize() {
   // TODO(toyoshim): Make Initialize() asynchronous.
-  TRACE_EVENT0("midi", "MIDIManagerMac::Initialize");
+  // See http://crbug.com/339746.
+  TRACE_EVENT0("midi", "MidiManagerMac::Initialize");
 
   // Enumerate only hardware MIDI devices because software MIDIs running in
   // the browser process is not secure.
@@ -123,19 +124,19 @@ bool MIDIManagerAlsa::Initialize() {
       input = snd_ctl_rawmidi_info(handle, midi_in) == 0;
       if (!output && !input)
         continue;
-      scoped_refptr<MIDIDeviceInfo> port = new MIDIDeviceInfo(
+      scoped_refptr<MidiDeviceInfo> port = new MidiDeviceInfo(
           this, id, card, output ? midi_out : midi_in, device);
       if (!port->IsOpened()) {
-        DLOG(ERROR) << "MIDIDeviceInfo open fails";
+        DLOG(ERROR) << "MidiDeviceInfo open fails";
         continue;
       }
       if (input) {
         in_devices_.push_back(port);
-        AddInputPort(port->GetMIDIPortInfo());
+        AddInputPort(port->GetMidiPortInfo());
       }
       if (output) {
         out_devices_.push_back(port);
-        AddOutputPort(port->GetMIDIPortInfo());
+        AddOutputPort(port->GetMidiPortInfo());
       }
     }
     snd_ctl_close(handle);
@@ -143,11 +144,11 @@ bool MIDIManagerAlsa::Initialize() {
   return true;
 }
 
-MIDIManagerAlsa::~MIDIManagerAlsa() {
+MidiManagerAlsa::~MidiManagerAlsa() {
   send_thread_.Stop();
 }
 
-void MIDIManagerAlsa::DispatchSendMIDIData(MIDIManagerClient* client,
+void MidiManagerAlsa::DispatchSendMidiData(MidiManagerClient* client,
                                            uint32 port_index,
                                            const std::vector<uint8>& data,
                                            double timestamp) {
@@ -165,15 +166,15 @@ void MIDIManagerAlsa::DispatchSendMIDIData(MIDIManagerClient* client,
   if (!send_thread_.IsRunning())
     send_thread_.Start();
 
-  scoped_refptr<MIDIDeviceInfo> device = out_devices_[port_index];
+  scoped_refptr<MidiDeviceInfo> device = out_devices_[port_index];
   send_thread_.message_loop()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&MIDIDeviceInfo::Send, device, client, data),
+      base::Bind(&MidiDeviceInfo::Send, device, client, data),
       delay);
 }
 
-MIDIManager* MIDIManager::Create() {
-  return new MIDIManagerAlsa();
+MidiManager* MidiManager::Create() {
+  return new MidiManagerAlsa();
 }
 
 }  // namespace media
diff --git a/media/midi/midi_manager_alsa.h b/media/midi/midi_manager_alsa.h
index d70141c..d14107a 100644
--- a/media/midi/midi_manager_alsa.h
+++ b/media/midi/midi_manager_alsa.h
@@ -14,24 +14,24 @@
 
 namespace media {
 
-class MIDIManagerAlsa : public MIDIManager {
+class MidiManagerAlsa : public MidiManager {
  public:
-  MIDIManagerAlsa();
-  virtual ~MIDIManagerAlsa();
+  MidiManagerAlsa();
+  virtual ~MidiManagerAlsa();
 
-  // MIDIManager implementation.
+  // MidiManager implementation.
   virtual bool Initialize() OVERRIDE;
-  virtual void DispatchSendMIDIData(MIDIManagerClient* client,
+  virtual void DispatchSendMidiData(MidiManagerClient* client,
                                     uint32 port_index,
                                     const std::vector<uint8>& data,
                                     double timestamp) OVERRIDE;
 
  private:
-  class MIDIDeviceInfo;
-  std::vector<scoped_refptr<MIDIDeviceInfo> > in_devices_;
-  std::vector<scoped_refptr<MIDIDeviceInfo> > out_devices_;
+  class MidiDeviceInfo;
+  std::vector<scoped_refptr<MidiDeviceInfo> > in_devices_;
+  std::vector<scoped_refptr<MidiDeviceInfo> > out_devices_;
   base::Thread send_thread_;
-  DISALLOW_COPY_AND_ASSIGN(MIDIManagerAlsa);
+  DISALLOW_COPY_AND_ASSIGN(MidiManagerAlsa);
 };
 
 }  // namespace media
diff --git a/media/midi/midi_manager_mac.cc b/media/midi/midi_manager_mac.cc
index a36d1de..b172f86 100644
--- a/media/midi/midi_manager_mac.cc
+++ b/media/midi/midi_manager_mac.cc
@@ -23,21 +23,21 @@ using std::string;
 
 namespace media {
 
-MIDIManager* MIDIManager::Create() {
-  return new MIDIManagerMac();
+MidiManager* MidiManager::Create() {
+  return new MidiManagerMac();
 }
 
-MIDIManagerMac::MIDIManagerMac()
+MidiManagerMac::MidiManagerMac()
     : midi_client_(0),
       coremidi_input_(0),
       coremidi_output_(0),
       packet_list_(NULL),
       midi_packet_(NULL),
-      send_thread_("MIDISendThread") {
+      send_thread_("MidiSendThread") {
 }
 
-bool MIDIManagerMac::Initialize() {
-  TRACE_EVENT0("midi", "MIDIManagerMac::Initialize");
+bool MidiManagerMac::Initialize() {
+  TRACE_EVENT0("midi", "MidiManagerMac::Initialize");
 
   // CoreMIDI registration.
   midi_client_ = 0;
@@ -56,7 +56,7 @@ bool MIDIManagerMac::Initialize() {
   result = MIDIInputPortCreate(
       midi_client_,
       CFSTR("MIDI Input"),
-      ReadMIDIDispatch,
+      ReadMidiDispatch,
       this,
       &coremidi_input_);
   if (result != noErr)
@@ -79,7 +79,7 @@ bool MIDIManagerMac::Initialize() {
     // Cache to avoid any possible overhead in calling MIDIGetDestination().
     destinations_[i] = destination;
 
-    MIDIPortInfo info = GetPortInfoFromEndpoint(destination);
+    MidiPortInfo info = GetPortInfoFromEndpoint(destination);
     AddOutputPort(info);
   }
 
@@ -94,18 +94,18 @@ bool MIDIManagerMac::Initialize() {
     // Keep track of all sources (known as inputs in Web MIDI API terminology).
     source_map_[src] = i;
 
-    MIDIPortInfo info = GetPortInfoFromEndpoint(src);
+    MidiPortInfo info = GetPortInfoFromEndpoint(src);
     AddInputPort(info);
   }
 
-  // TODO(crogers): Fix the memory management here!
+  // TODO(toyoshim): Fix the memory management here!
   packet_list_ = reinterpret_cast<MIDIPacketList*>(midi_buffer_);
   midi_packet_ = MIDIPacketListInit(packet_list_);
 
   return true;
 }
 
-void MIDIManagerMac::DispatchSendMIDIData(MIDIManagerClient* client,
+void MidiManagerMac::DispatchSendMidiData(MidiManagerClient* client,
                                           uint32 port_index,
                                           const std::vector<uint8>& data,
                                           double timestamp) {
@@ -115,11 +115,11 @@ void MIDIManagerMac::DispatchSendMIDIData(MIDIManagerClient* client,
   // OK to use base::Unretained(this) since we join to thread in dtor().
   send_thread_.message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&MIDIManagerMac::SendMIDIData, base::Unretained(this),
+      base::Bind(&MidiManagerMac::SendMidiData, base::Unretained(this),
                  client, port_index, data, timestamp));
 }
 
-MIDIManagerMac::~MIDIManagerMac() {
+MidiManagerMac::~MidiManagerMac() {
   // Wait for the termination of |send_thread_| before disposing MIDI ports.
   send_thread_.Stop();
 
@@ -130,10 +130,10 @@ MIDIManagerMac::~MIDIManagerMac() {
 }
 
 // static
-void MIDIManagerMac::ReadMIDIDispatch(const MIDIPacketList* packet_list,
+void MidiManagerMac::ReadMidiDispatch(const MIDIPacketList* packet_list,
                                       void* read_proc_refcon,
                                       void* src_conn_refcon) {
-  MIDIManagerMac* manager = static_cast<MIDIManagerMac*>(read_proc_refcon);
+  MidiManagerMac* manager = static_cast<MidiManagerMac*>(read_proc_refcon);
 #if __LP64__
   MIDIEndpointRef source = reinterpret_cast<uintptr_t>(src_conn_refcon);
 #else
@@ -141,10 +141,10 @@ void MIDIManagerMac::ReadMIDIDispatch(const MIDIPacketList* packet_list,
 #endif
 
   // Dispatch to class method.
-  manager->ReadMIDI(source, packet_list);
+  manager->ReadMidi(source, packet_list);
 }
 
-void MIDIManagerMac::ReadMIDI(MIDIEndpointRef source,
+void MidiManagerMac::ReadMidi(MIDIEndpointRef source,
                               const MIDIPacketList* packet_list) {
   // Lookup the port index based on the source.
   SourceMap::iterator j = source_map_.find(source);
@@ -158,7 +158,7 @@ void MIDIManagerMac::ReadMIDI(MIDIEndpointRef source,
     const MIDIPacket &packet = packet_list->packet[i];
     double timestamp_seconds = MIDITimeStampToSeconds(packet.timeStamp);
 
-    ReceiveMIDIData(
+    ReceiveMidiData(
         port_index,
         packet.data,
         packet.length,
@@ -166,7 +166,7 @@ void MIDIManagerMac::ReadMIDI(MIDIEndpointRef source,
   }
 }
 
-void MIDIManagerMac::SendMIDIData(MIDIManagerClient* client,
+void MidiManagerMac::SendMidiData(MidiManagerClient* client,
                                   uint32 port_index,
                                   const std::vector<uint8>& data,
                                   double timestamp) {
@@ -194,11 +194,11 @@ void MIDIManagerMac::SendMIDIData(MIDIManagerClient* client,
   // Re-initialize for next time.
   midi_packet_ = MIDIPacketListInit(packet_list_);
 
-  client->AccumulateMIDIBytesSent(data.size());
+  client->AccumulateMidiBytesSent(data.size());
 }
 
 // static
-MIDIPortInfo MIDIManagerMac::GetPortInfoFromEndpoint(
+MidiPortInfo MidiManagerMac::GetPortInfoFromEndpoint(
     MIDIEndpointRef endpoint) {
   SInt32 id_number = 0;
   MIDIObjectGetIntegerProperty(endpoint, kMIDIPropertyUniqueID, &id_number);
@@ -238,17 +238,17 @@ MIDIPortInfo MIDIManagerMac::GetPortInfoFromEndpoint(
                   << result;
   }
 
-  return MIDIPortInfo(id, manufacturer, name, version);
+  return MidiPortInfo(id, manufacturer, name, version);
 }
 
 // static
-double MIDIManagerMac::MIDITimeStampToSeconds(MIDITimeStamp timestamp) {
+double MidiManagerMac::MIDITimeStampToSeconds(MIDITimeStamp timestamp) {
   UInt64 nanoseconds = AudioConvertHostTimeToNanos(timestamp);
   return static_cast<double>(nanoseconds) / 1.0e9;
 }
 
 // static
-MIDITimeStamp MIDIManagerMac::SecondsToMIDITimeStamp(double seconds) {
+MIDITimeStamp MidiManagerMac::SecondsToMIDITimeStamp(double seconds) {
   UInt64 nanos = UInt64(seconds * 1.0e9);
   return AudioConvertNanosToHostTime(nanos);
 }
diff --git a/media/midi/midi_manager_mac.h b/media/midi/midi_manager_mac.h
index cc8bf74..5b27837 100644
--- a/media/midi/midi_manager_mac.h
+++ b/media/midi/midi_manager_mac.h
@@ -18,14 +18,14 @@
 
 namespace media {
 
-class MEDIA_EXPORT MIDIManagerMac : public MIDIManager {
+class MEDIA_EXPORT MidiManagerMac : public MidiManager {
  public:
-  MIDIManagerMac();
-  virtual ~MIDIManagerMac();
+  MidiManagerMac();
+  virtual ~MidiManagerMac();
 
-  // MIDIManager implementation.
+  // MidiManager implementation.
   virtual bool Initialize() OVERRIDE;
-  virtual void DispatchSendMIDIData(MIDIManagerClient* client,
+  virtual void DispatchSendMidiData(MidiManagerClient* client,
                                     uint32 port_index,
                                     const std::vector<uint8>& data,
                                     double timestamp) OVERRIDE;
@@ -34,20 +34,20 @@ class MEDIA_EXPORT MIDIManagerMac : public MIDIManager {
   // CoreMIDI callback for MIDI data.
   // Each callback can contain multiple packets, each of which can contain
   // multiple MIDI messages.
-  static void ReadMIDIDispatch(
+  static void ReadMidiDispatch(
       const MIDIPacketList *pktlist,
       void *read_proc_refcon,
       void *src_conn_refcon);
-  virtual void ReadMIDI(MIDIEndpointRef source, const MIDIPacketList *pktlist);
+  virtual void ReadMidi(MIDIEndpointRef source, const MIDIPacketList *pktlist);
 
-  // An internal callback that runs on MIDISendThread.
-  void SendMIDIData(MIDIManagerClient* client,
+  // An internal callback that runs on MidiSendThread.
+  void SendMidiData(MidiManagerClient* client,
                     uint32 port_index,
                     const std::vector<uint8>& data,
                     double timestamp);
 
   // Helper
-  static media::MIDIPortInfo GetPortInfoFromEndpoint(MIDIEndpointRef endpoint);
+  static media::MidiPortInfo GetPortInfoFromEndpoint(MIDIEndpointRef endpoint);
   static double MIDITimeStampToSeconds(MIDITimeStamp timestamp);
   static MIDITimeStamp SecondsToMIDITimeStamp(double seconds);
 
@@ -72,7 +72,7 @@ class MEDIA_EXPORT MIDIManagerMac : public MIDIManager {
   // |send_thread_| is used to send MIDI data.
   base::Thread send_thread_;
 
-  DISALLOW_COPY_AND_ASSIGN(MIDIManagerMac);
+  DISALLOW_COPY_AND_ASSIGN(MidiManagerMac);
 };
 
 }  // namespace media
diff --git a/media/midi/midi_manager_usb.cc b/media/midi/midi_manager_usb.cc
index c240c4a..db6e1f1 100644
--- a/media/midi/midi_manager_usb.cc
+++ b/media/midi/midi_manager_usb.cc
@@ -20,7 +20,7 @@ namespace {
 
 // Noop callback for (sync) Initialize.
 // TODO(yhirano): This function should go away when
-// MIDIManager::Initialize() becomes asynchronous.
+// MidiManager::Initialize() becomes asynchronous. See http://crbug.com/339746.
 void Noop(bool result) {
 }
 
@@ -47,13 +47,13 @@ void MidiManagerUsb::Initialize(base::Callback<void(bool result)> callback) {
                  base::Unretained(this)));
 }
 
-void MidiManagerUsb::DispatchSendMIDIData(MIDIManagerClient* client,
+void MidiManagerUsb::DispatchSendMidiData(MidiManagerClient* client,
                                           uint32_t port_index,
                                           const std::vector<uint8>& data,
                                           double timestamp) {
   DCHECK_LT(port_index, output_streams_.size());
   output_streams_[port_index]->Send(data);
-  client->AccumulateMIDIBytesSent(data.size());
+  client->AccumulateMidiBytesSent(data.size());
 }
 
 void MidiManagerUsb::ReceiveUsbMidiData(UsbMidiDevice* device,
@@ -74,7 +74,7 @@ void MidiManagerUsb::OnReceivedData(size_t jack_index,
                                     const uint8* data,
                                     size_t size,
                                     double timestamp) {
-  ReceiveMIDIData(jack_index, data, size, timestamp);
+  ReceiveMidiData(jack_index, data, size, timestamp);
 }
 
 
@@ -103,12 +103,12 @@ void MidiManagerUsb::OnEnumerateDevicesDone(bool result,
       if (jacks[j].direction() == UsbMidiJack::DIRECTION_OUT) {
         output_streams_.push_back(new UsbMidiOutputStream(jacks[j]));
         // TODO(yhirano): Set appropriate properties.
-        AddOutputPort(MIDIPortInfo());
+        AddOutputPort(MidiPortInfo());
       } else {
         DCHECK_EQ(jacks[j].direction(), UsbMidiJack::DIRECTION_IN);
         input_jacks.push_back(jacks[j]);
         // TODO(yhirano): Set appropriate properties.
-        AddInputPort(MIDIPortInfo());
+        AddInputPort(MidiPortInfo());
       }
     }
     input_stream_.reset(new UsbMidiInputStream(input_jacks, this));
diff --git a/media/midi/midi_manager_usb.h b/media/midi/midi_manager_usb.h
index 27a9aa7..a08b986 100644
--- a/media/midi/midi_manager_usb.h
+++ b/media/midi/midi_manager_usb.h
@@ -22,17 +22,17 @@
 
 namespace media {
 
-// MIDIManager for USB-MIDI.
-class MEDIA_EXPORT MidiManagerUsb : public MIDIManager,
+// MidiManager for USB-MIDI.
+class MEDIA_EXPORT MidiManagerUsb : public MidiManager,
                                     public UsbMidiDeviceDelegate,
                                     public UsbMidiInputStream::Delegate {
  public:
   explicit MidiManagerUsb(scoped_ptr<UsbMidiDevice::Factory> device_factory);
   virtual ~MidiManagerUsb();
 
-  // MIDIManager implementation.
+  // MidiManager implementation.
   virtual bool Initialize() OVERRIDE;
-  virtual void DispatchSendMIDIData(MIDIManagerClient* client,
+  virtual void DispatchSendMidiData(MidiManagerClient* client,
                                     uint32 port_index,
                                     const std::vector<uint8>& data,
                                     double timestamp) OVERRIDE;
diff --git a/media/midi/midi_manager_usb_unittest.cc b/media/midi/midi_manager_usb_unittest.cc
index 1eb779d..567b60c 100644
--- a/media/midi/midi_manager_usb_unittest.cc
+++ b/media/midi/midi_manager_usb_unittest.cc
@@ -68,24 +68,24 @@ class FakeUsbMidiDevice : public UsbMidiDevice {
   DISALLOW_COPY_AND_ASSIGN(FakeUsbMidiDevice);
 };
 
-class FakeMidiManagerClient : public MIDIManagerClient {
+class FakeMidiManagerClient : public MidiManagerClient {
  public:
   explicit FakeMidiManagerClient(Logger* logger) : logger_(logger) {}
   virtual ~FakeMidiManagerClient() {}
 
-  virtual void ReceiveMIDIData(uint32 port_index,
+  virtual void ReceiveMidiData(uint32 port_index,
                                const uint8* data,
                                size_t size,
                                double timestamp) OVERRIDE {
-    logger_->AddLog("MIDIManagerClient::ReceiveMIDIData ");
+    logger_->AddLog("MidiManagerClient::ReceiveMidiData ");
     logger_->AddLog(base::StringPrintf("port_index = %d data =", port_index));
     for (size_t i = 0; i < size; ++i)
       logger_->AddLog(base::StringPrintf(" 0x%02x", data[i]));
     logger_->AddLog("\n");
   }
 
-  virtual void AccumulateMIDIBytesSent(size_t size) OVERRIDE {
-    logger_->AddLog("MIDIManagerClient::AccumulateMIDIBytesSent ");
+  virtual void AccumulateMidiBytesSent(size_t size) OVERRIDE {
+    logger_->AddLog("MidiManagerClient::AccumulateMidiBytesSent ");
     // Windows has no "%zu".
     logger_->AddLog(base::StringPrintf("size = %u\n",
                                        static_cast<unsigned>(size)));
@@ -253,13 +253,13 @@ TEST_F(MidiManagerUsbTest, Send) {
   ASSERT_TRUE(initialize_result_);
   ASSERT_EQ(2u, manager_->output_streams().size());
 
-  manager_->DispatchSendMIDIData(&client, 1, ToVector(data), 0);
+  manager_->DispatchSendMidiData(&client, 1, ToVector(data), 0);
   EXPECT_EQ("UsbMidiDevice::GetDescriptor\n"
             "UsbMidiDevice::Send endpoint = 2 data = "
             "0x19 0x90 0x45 0x7f "
             "0x14 0xf0 0x00 0x01 "
             "0x15 0xf7 0x00 0x00\n"
-            "MIDIManagerClient::AccumulateMIDIBytesSent size = 7\n",
+            "MidiManagerClient::AccumulateMidiBytesSent size = 7\n",
             logger_.TakeLog());
 }
 
@@ -305,11 +305,11 @@ TEST_F(MidiManagerUsbTest, Receive) {
   manager_->EndSession(&client);
 
   EXPECT_EQ("UsbMidiDevice::GetDescriptor\n"
-            "MIDIManagerClient::ReceiveMIDIData port_index = 0 "
+            "MidiManagerClient::ReceiveMidiData port_index = 0 "
             "data = 0x90 0x45 0x7f\n"
-            "MIDIManagerClient::ReceiveMIDIData port_index = 0 "
+            "MidiManagerClient::ReceiveMidiData port_index = 0 "
             "data = 0xf0 0x00 0x01\n"
-            "MIDIManagerClient::ReceiveMIDIData port_index = 0 data = 0xf7\n",
+            "MidiManagerClient::ReceiveMidiData port_index = 0 data = 0xf7\n",
             logger_.TakeLog());
 }
 
diff --git a/media/midi/midi_manager_win.cc b/media/midi/midi_manager_win.cc
index 460dcfe..6643ffd 100644
--- a/media/midi/midi_manager_win.cc
+++ b/media/midi/midi_manager_win.cc
@@ -76,7 +76,7 @@ ScopedMIDIHDR CreateMIDIHDR(size_t size) {
   return header.Pass();
 }
 
-void SendShortMIDIMessageInternal(HMIDIOUT midi_out_handle,
+void SendShortMidiMessageInternal(HMIDIOUT midi_out_handle,
                                   const std::vector<uint8>& message) {
   if (message.size() >= 4)
     return;
@@ -89,7 +89,7 @@ void SendShortMIDIMessageInternal(HMIDIOUT midi_out_handle,
       << "Failed to output short message: " << GetOutErrorMessage(result);
 }
 
-void SendLongMIDIMessageInternal(HMIDIOUT midi_out_handle,
+void SendLongMidiMessageInternal(HMIDIOUT midi_out_handle,
                                  const std::vector<uint8>& message) {
   // Implementation note:
   // Sending long MIDI message can be performed synchronously or asynchronously
@@ -147,7 +147,7 @@ void SendLongMIDIMessageInternal(HMIDIOUT midi_out_handle,
 
 }  // namespace
 
-class MIDIManagerWin::InDeviceInfo {
+class MidiManagerWin::InDeviceInfo {
  public:
   ~InDeviceInfo() {
     Uninitialize();
@@ -165,7 +165,7 @@ class MIDIManagerWin::InDeviceInfo {
     return midi_handle_;
   }
 
-  static scoped_ptr<InDeviceInfo> Create(MIDIManagerWin* manager,
+  static scoped_ptr<InDeviceInfo> Create(MidiManagerWin* manager,
                                          UINT device_id) {
     scoped_ptr<InDeviceInfo> obj(new InDeviceInfo(manager));
     if (!obj->Initialize(device_id))
@@ -177,7 +177,7 @@ class MIDIManagerWin::InDeviceInfo {
   static const int kInvalidPortIndex = -1;
   static const size_t kBufferLength = 32 * 1024;
 
-  explicit InDeviceInfo(MIDIManagerWin* manager)
+  explicit InDeviceInfo(MidiManagerWin* manager)
       : manager_(manager),
         port_index_(kInvalidPortIndex),
         midi_handle_(NULL),
@@ -297,7 +297,7 @@ class MIDIManagerWin::InDeviceInfo {
                               DWORD elapsed_ms) {
     if (device_to_be_closed())
       return;
-    const size_t len = GetMIDIMessageLength(status_byte);
+    const size_t len = GetMidiMessageLength(status_byte);
     if (len == 0 || port_index() == kInvalidPortIndex)
       return;
     const uint8 kData[] = { status_byte, first_data_byte, second_data_byte };
@@ -337,26 +337,26 @@ class MIDIManagerWin::InDeviceInfo {
     // http://msdn.microsoft.com/en-us/library/windows/desktop/dd757286.aspx
     const base::TimeTicks event_time =
         start_time_ + base::TimeDelta::FromMilliseconds(elapsed_ms);
-    // MIDIManager::ReceiveMIDIData() expects |timestamp| as the elapsed seconds
+    // MidiManager::ReceiveMidiData() expects |timestamp| as the elapsed seconds
     // from base::TimeTicks::Now().
-    // TODO(yukawa): Update MIDIManager::ReceiveMIDIData() so that it can
+    // TODO(yukawa): Update MidiManager::ReceiveMidiData() so that it can
     // receive |event_time| directly if the precision of base::TimeTicks is
     // sufficient.
     const double timestamp = (event_time - base::TimeTicks()).InSecondsF();
-    manager_->ReceiveMIDIData(port_index_, data, length, timestamp);
+    manager_->ReceiveMidiData(port_index_, data, length, timestamp);
   }
 
-  MIDIManagerWin* manager_;
+  MidiManagerWin* manager_;
   int port_index_;
   HMIDIIN midi_handle_;
   ScopedMIDIHDR midi_header_;
   base::TimeTicks start_time_;
   bool started_;
   bool device_to_be_closed_;
-  DISALLOW_COPY_AND_ASSIGN(MIDIManagerWin::InDeviceInfo);
+  DISALLOW_COPY_AND_ASSIGN(MidiManagerWin::InDeviceInfo);
 };
 
-class MIDIManagerWin::OutDeviceInfo {
+class MidiManagerWin::OutDeviceInfo {
  public:
   ~OutDeviceInfo() {
     Uninitialize();
@@ -389,18 +389,18 @@ class MIDIManagerWin::OutDeviceInfo {
       return;
 
     // MIDI Running status must be filtered out.
-    MIDIMessageQueue message_queue(false);
+    MidiMessageQueue message_queue(false);
     message_queue.Add(data);
     std::vector<uint8> message;
     while (!quitting_) {
       message_queue.Get(&message);
       if (message.empty())
         break;
-      // SendShortMIDIMessageInternal can send a MIDI message up to 3 bytes.
+      // SendShortMidiMessageInternal can send a MIDI message up to 3 bytes.
       if (message.size() <= 3)
-        SendShortMIDIMessageInternal(midi_handle_, message);
+        SendShortMidiMessageInternal(midi_handle_, message);
       else
-        SendLongMIDIMessageInternal(midi_handle_, message);
+        SendLongMidiMessageInternal(midi_handle_, message);
     }
   }
 
@@ -414,7 +414,7 @@ class MIDIManagerWin::OutDeviceInfo {
     Uninitialize();
     // Here we use |CALLBACK_FUNCTION| to subscribe MOM_DONE and MOM_CLOSE
     // events.
-    // - MOM_DONE: SendLongMIDIMessageInternal() relies on this event to clean
+    // - MOM_DONE: SendLongMidiMessageInternal() relies on this event to clean
     //     up the backing store where a long MIDI message is stored.
     // - MOM_CLOSE: This event is sent when 1) midiOutClose() is called, or 2)
     //     the MIDI device becomes unavailable for some reasons, e.g., the cable
@@ -490,17 +490,17 @@ class MIDIManagerWin::OutDeviceInfo {
   // True if the device is already closed.
   volatile bool closed_;
 
-  // True if the MIDIManagerWin is trying to stop the sender thread.
+  // True if the MidiManagerWin is trying to stop the sender thread.
   volatile bool quitting_;
 
-  DISALLOW_COPY_AND_ASSIGN(MIDIManagerWin::OutDeviceInfo);
+  DISALLOW_COPY_AND_ASSIGN(MidiManagerWin::OutDeviceInfo);
 };
 
-MIDIManagerWin::MIDIManagerWin()
-    : send_thread_("MIDISendThread") {
+MidiManagerWin::MidiManagerWin()
+    : send_thread_("MidiSendThread") {
 }
 
-bool MIDIManagerWin::Initialize() {
+bool MidiManagerWin::Initialize() {
   const UINT num_in_devices = midiInGetNumDevs();
   in_devices_.reserve(num_in_devices);
   for (UINT device_id = 0; device_id < num_in_devices; ++device_id) {
@@ -514,7 +514,7 @@ bool MIDIManagerWin::Initialize() {
     scoped_ptr<InDeviceInfo> in_device(InDeviceInfo::Create(this, device_id));
     if (!in_device)
       continue;
-    MIDIPortInfo info(
+    MidiPortInfo info(
         base::IntToString(static_cast<int>(device_id)),
         "",
         base::WideToUTF8(caps.szPname),
@@ -537,7 +537,7 @@ bool MIDIManagerWin::Initialize() {
     scoped_ptr<OutDeviceInfo> out_port(OutDeviceInfo::Create(device_id));
     if (!out_port)
       continue;
-    MIDIPortInfo info(
+    MidiPortInfo info(
         base::IntToString(static_cast<int>(device_id)),
         "",
         base::WideToUTF8(caps.szPname),
@@ -549,7 +549,7 @@ bool MIDIManagerWin::Initialize() {
   return true;
 }
 
-MIDIManagerWin::~MIDIManagerWin() {
+MidiManagerWin::~MidiManagerWin() {
   // Cleanup order is important. |send_thread_| must be stopped before
   // |out_devices_| is cleared.
   for (size_t i = 0; i < output_ports_.size(); ++i)
@@ -562,7 +562,7 @@ MIDIManagerWin::~MIDIManagerWin() {
   input_ports_.clear();
 }
 
-void MIDIManagerWin::DispatchSendMIDIData(MIDIManagerClient* client,
+void MidiManagerWin::DispatchSendMidiData(MidiManagerClient* client,
                                           uint32 port_index,
                                           const std::vector<uint8>& data,
                                           double timestamp) {
@@ -586,18 +586,18 @@ void MIDIManagerWin::DispatchSendMIDIData(MIDIManagerClient* client,
       base::Bind(&OutDeviceInfo::Send, base::Unretained(out_port), data),
       delay);
 
-  // Call back AccumulateMIDIBytesSent() on |send_thread_| to emulate the
-  // behavior of MIDIManagerMac::SendMIDIData.
+  // Call back AccumulateMidiBytesSent() on |send_thread_| to emulate the
+  // behavior of MidiManagerMac::SendMidiData.
   // TODO(yukawa): Do this task in a platform-independent way if possible.
   // See crbug.com/325810.
   send_thread_.message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&MIDIManagerClient::AccumulateMIDIBytesSent,
+      base::Bind(&MidiManagerClient::AccumulateMidiBytesSent,
                  base::Unretained(client), data.size()));
 }
 
-MIDIManager* MIDIManager::Create() {
-  return new MIDIManagerWin();
+MidiManager* MidiManager::Create() {
+  return new MidiManagerWin();
 }
 
 }  // namespace media
diff --git a/media/midi/midi_manager_win.h b/media/midi/midi_manager_win.h
index eef8b4e..8e1cc36 100644
--- a/media/midi/midi_manager_win.h
+++ b/media/midi/midi_manager_win.h
@@ -14,14 +14,14 @@
 
 namespace media {
 
-class MIDIManagerWin : public MIDIManager {
+class MidiManagerWin : public MidiManager {
  public:
-  MIDIManagerWin();
-  virtual ~MIDIManagerWin();
+  MidiManagerWin();
+  virtual ~MidiManagerWin();
 
-  // MIDIManager implementation.
+  // MidiManager implementation.
   virtual bool Initialize() OVERRIDE;
-  virtual void DispatchSendMIDIData(MIDIManagerClient* client,
+  virtual void DispatchSendMidiData(MidiManagerClient* client,
                                     uint32 port_index,
                                     const std::vector<uint8>& data,
                                     double timestamp) OVERRIDE;
@@ -32,7 +32,7 @@ class MIDIManagerWin : public MIDIManager {
   std::vector<scoped_ptr<InDeviceInfo> > in_devices_;
   std::vector<scoped_ptr<OutDeviceInfo> > out_devices_;
   base::Thread send_thread_;
-  DISALLOW_COPY_AND_ASSIGN(MIDIManagerWin);
+  DISALLOW_COPY_AND_ASSIGN(MidiManagerWin);
 };
 
 }  // namespace media
diff --git a/media/midi/midi_message_queue.cc b/media/midi/midi_message_queue.cc
index 3452e80..af40353 100644
--- a/media/midi/midi_message_queue.cc
+++ b/media/midi/midi_message_queue.cc
@@ -29,20 +29,20 @@ bool IsSystemRealTimeMessage(uint8 data) {
 
 }  // namespace
 
-MIDIMessageQueue::MIDIMessageQueue(bool allow_running_status)
+MidiMessageQueue::MidiMessageQueue(bool allow_running_status)
     : allow_running_status_(allow_running_status) {}
 
-MIDIMessageQueue::~MIDIMessageQueue() {}
+MidiMessageQueue::~MidiMessageQueue() {}
 
-void MIDIMessageQueue::Add(const std::vector<uint8>& data) {
+void MidiMessageQueue::Add(const std::vector<uint8>& data) {
   queue_.insert(queue_.end(), data.begin(), data.end());
 }
 
-void MIDIMessageQueue::Add(const uint8* data, size_t length) {
+void MidiMessageQueue::Add(const uint8* data, size_t length) {
   queue_.insert(queue_.end(), data, data + length);
 }
 
-void MIDIMessageQueue::Get(std::vector<uint8>* message) {
+void MidiMessageQueue::Get(std::vector<uint8>* message) {
   message->clear();
 
   while (true) {
@@ -98,7 +98,7 @@ void MIDIMessageQueue::Get(std::vector<uint8>* message) {
 
     DCHECK(IsDataByte(next));
     DCHECK_NE(kSysEx, status_byte);
-    const size_t target_len = GetMIDIMessageLength(status_byte);
+    const size_t target_len = GetMidiMessageLength(status_byte);
     if (next_message_.size() < target_len)
       continue;
     if (next_message_.size() == target_len) {
diff --git a/media/midi/midi_message_queue.h b/media/midi/midi_message_queue.h
index 06f0f47..f565f18 100644
--- a/media/midi/midi_message_queue.h
+++ b/media/midi/midi_message_queue.h
@@ -24,7 +24,7 @@ namespace media {
 //   MIDI status byte is abbreviated (a.k.a. "running status").
 //
 // Example (pseudo message loop):
-//   MIDIMessageQueue queue(true);  // true to support "running status"
+//   MidiMessageQueue queue(true);  // true to support "running status"
 //   while (true) {
 //     if (is_incoming_midi_data_available()) {
 //       std::vector<uint8> incoming_data;
@@ -38,12 +38,12 @@ namespace media {
 //         dispatch(next_message);
 //     }
 //   }
-class MEDIA_EXPORT MIDIMessageQueue {
+class MEDIA_EXPORT MidiMessageQueue {
  public:
   // Initializes the queue. Set true to |allow_running_status| to enable
   // "MIDI running status" reconstruction.
-  explicit MIDIMessageQueue(bool allow_running_status);
-  ~MIDIMessageQueue();
+  explicit MidiMessageQueue(bool allow_running_status);
+  ~MidiMessageQueue();
 
   // Enqueues |data| to the internal buffer.
   void Add(const std::vector<uint8>& data);
@@ -64,7 +64,7 @@ class MEDIA_EXPORT MIDIMessageQueue {
   std::deque<uint8> queue_;
   std::vector<uint8> next_message_;
   const bool allow_running_status_;
-  DISALLOW_COPY_AND_ASSIGN(MIDIMessageQueue);
+  DISALLOW_COPY_AND_ASSIGN(MidiMessageQueue);
 };
 
 }  // namespace media
diff --git a/media/midi/midi_message_queue_unittest.cc b/media/midi/midi_message_queue_unittest.cc
index a00eea6..3c71226 100644
--- a/media/midi/midi_message_queue_unittest.cc
+++ b/media/midi/midi_message_queue_unittest.cc
@@ -28,7 +28,7 @@ const uint8 kBrokenData3[] = { 0xf2, 0x00 };
 const uint8 kDataByte0[] = { 0x00 };
 
 template <typename T, size_t N>
-void Add(MIDIMessageQueue* queue, const T(&array)[N]) {
+void Add(MidiMessageQueue* queue, const T(&array)[N]) {
   queue->Add(array, N);
 }
 
@@ -54,15 +54,15 @@ template <typename T, size_t N>
 #define EXPECT_MESSAGE(expected, actual)  \
   EXPECT_PRED_FORMAT2(ExpectEqualSequence, expected, actual)
 
-TEST(MIDIMessageQueueTest, EmptyData) {
-  MIDIMessageQueue queue(false);
+TEST(MidiMessageQueueTest, EmptyData) {
+  MidiMessageQueue queue(false);
   std::vector<uint8> message;
   queue.Get(&message);
   EXPECT_TRUE(message.empty());
 }
 
-TEST(MIDIMessageQueueTest, RunningStatusDisabled) {
-  MIDIMessageQueue queue(false);
+TEST(MidiMessageQueueTest, RunningStatusDisabled) {
+  MidiMessageQueue queue(false);
   Add(&queue, kGMOn);
   Add(&queue, kBrokenData1);
   Add(&queue, kNoteOnWithRunningStatus);
@@ -94,8 +94,8 @@ TEST(MIDIMessageQueueTest, RunningStatusDisabled) {
   EXPECT_TRUE(message.empty());
 }
 
-TEST(MIDIMessageQueueTest, RunningStatusEnabled) {
-  MIDIMessageQueue queue(true);
+TEST(MidiMessageQueueTest, RunningStatusEnabled) {
+  MidiMessageQueue queue(true);
   Add(&queue, kGMOn);
   Add(&queue, kBrokenData1);
   Add(&queue, kNoteOnWithRunningStatus);
@@ -139,8 +139,8 @@ TEST(MIDIMessageQueueTest, RunningStatusEnabled) {
       << "Running status must not be applied to real time messages";
 }
 
-TEST(MIDIMessageQueueTest, RunningStatusEnabledWithRealTimeEvent) {
-  MIDIMessageQueue queue(true);
+TEST(MidiMessageQueueTest, RunningStatusEnabledWithRealTimeEvent) {
+  MidiMessageQueue queue(true);
   const uint8 kNoteOnWithRunningStatusWithkTimingClock[] = {
     0x90, 0xf8, 0x3c, 0xf8, 0x7f, 0xf8, 0x3c, 0xf8, 0x7f, 0xf8, 0x3c, 0xf8,
     0x7f,
diff --git a/media/midi/midi_message_util.cc b/media/midi/midi_message_util.cc
index 83d3cc0..9e913d7 100644
--- a/media/midi/midi_message_util.cc
+++ b/media/midi/midi_message_util.cc
@@ -6,7 +6,7 @@
 
 namespace media {
 
-size_t GetMIDIMessageLength(uint8 status_byte) {
+size_t GetMidiMessageLength(uint8 status_byte) {
   if (status_byte < 0x80)
     return 0;
   if (0x80 <= status_byte && status_byte <= 0xbf)
diff --git a/media/midi/midi_message_util.h b/media/midi/midi_message_util.h
index b40d814..faaff17 100644
--- a/media/midi/midi_message_util.h
+++ b/media/midi/midi_message_util.h
@@ -18,7 +18,7 @@ namespace media {
 // - not a valid status byte, namely data byte.
 // - the MIDI System Exclusive message.
 // - the End of System Exclusive message.
-MEDIA_EXPORT size_t GetMIDIMessageLength(uint8 status_byte);
+MEDIA_EXPORT size_t GetMidiMessageLength(uint8 status_byte);
 
 const uint8 kSysExByte = 0xf0;
 const uint8 kEndOfSysExByte = 0xf7;
diff --git a/media/midi/midi_message_util_unittest.cc b/media/midi/midi_message_util_unittest.cc
index af3679c..529efbf 100644
--- a/media/midi/midi_message_util_unittest.cc
+++ b/media/midi/midi_message_util_unittest.cc
@@ -14,20 +14,20 @@ const uint8 kNoteOn[] = { 0x90, 0x3c, 0x7f };
 const uint8 kChannelPressure[] = { 0xd0, 0x01 };
 const uint8 kTimingClock[] = { 0xf8 };
 
-TEST(GetMIDIMessageLengthTest, BasicTest) {
+TEST(GetMidiMessageLengthTest, BasicTest) {
   // Check basic functionarity
-  EXPECT_EQ(arraysize(kNoteOn), GetMIDIMessageLength(kNoteOn[0]));
+  EXPECT_EQ(arraysize(kNoteOn), GetMidiMessageLength(kNoteOn[0]));
   EXPECT_EQ(arraysize(kChannelPressure),
-            GetMIDIMessageLength(kChannelPressure[0]));
-  EXPECT_EQ(arraysize(kTimingClock), GetMIDIMessageLength(kTimingClock[0]));
+            GetMidiMessageLength(kChannelPressure[0]));
+  EXPECT_EQ(arraysize(kTimingClock), GetMidiMessageLength(kTimingClock[0]));
 
   // SysEx message should be mapped to 0-length
-  EXPECT_EQ(0u, GetMIDIMessageLength(kGMOn[0]));
+  EXPECT_EQ(0u, GetMidiMessageLength(kGMOn[0]));
 
   // Any data byte should be mapped to 0-length
-  EXPECT_EQ(0u, GetMIDIMessageLength(kGMOn[1]));
-  EXPECT_EQ(0u, GetMIDIMessageLength(kNoteOn[1]));
-  EXPECT_EQ(0u, GetMIDIMessageLength(kChannelPressure[1]));
+  EXPECT_EQ(0u, GetMidiMessageLength(kGMOn[1]));
+  EXPECT_EQ(0u, GetMidiMessageLength(kNoteOn[1]));
+  EXPECT_EQ(0u, GetMidiMessageLength(kChannelPressure[1]));
 }
 
 }  // namespace
diff --git a/media/midi/midi_port_info.cc b/media/midi/midi_port_info.cc
index 3be7007..02b4aa9 100644
--- a/media/midi/midi_port_info.cc
+++ b/media/midi/midi_port_info.cc
@@ -6,9 +6,9 @@
 
 namespace media {
 
-MIDIPortInfo::MIDIPortInfo() {}
+MidiPortInfo::MidiPortInfo() {}
 
-MIDIPortInfo::MIDIPortInfo(const std::string& in_id,
+MidiPortInfo::MidiPortInfo(const std::string& in_id,
                            const std::string& in_manufacturer,
                            const std::string& in_name,
                            const std::string& in_version)
@@ -17,9 +17,9 @@ MIDIPortInfo::MIDIPortInfo(const std::string& in_id,
       name(in_name),
       version(in_version) {}
 
-MIDIPortInfo::~MIDIPortInfo() {}
+MidiPortInfo::~MidiPortInfo() {}
 
-MIDIPortInfo::MIDIPortInfo(const MIDIPortInfo& info)
+MidiPortInfo::MidiPortInfo(const MidiPortInfo& info)
     : id(info.id),
       manufacturer(info.manufacturer),
       name(info.name),
diff --git a/media/midi/midi_port_info.h b/media/midi/midi_port_info.h
index f4afb49..1fe3bca 100644
--- a/media/midi/midi_port_info.h
+++ b/media/midi/midi_port_info.h
@@ -13,15 +13,15 @@
 
 namespace media {
 
-struct MEDIA_EXPORT MIDIPortInfo {
-  MIDIPortInfo();
-  MIDIPortInfo(const std::string& in_id,
+struct MEDIA_EXPORT MidiPortInfo {
+  MidiPortInfo();
+  MidiPortInfo(const std::string& in_id,
                const std::string& in_manufacturer,
                const std::string& in_name,
                const std::string& in_version);
 
-  MIDIPortInfo(const MIDIPortInfo& info);
-  ~MIDIPortInfo();
+  MidiPortInfo(const MidiPortInfo& info);
+  ~MidiPortInfo();
 
   std::string id;
   std::string manufacturer;
@@ -29,7 +29,7 @@ struct MEDIA_EXPORT MIDIPortInfo {
   std::string version;
 };
 
-typedef std::vector<MIDIPortInfo> MIDIPortInfoList;
+typedef std::vector<MidiPortInfo> MidiPortInfoList;
 
 }  // namespace media
 
diff --git a/media/midi/usb_midi_descriptor_parser_unittest.cc b/media/midi/usb_midi_descriptor_parser_unittest.cc
index cd6203b..4e243d1 100644
--- a/media/midi/usb_midi_descriptor_parser_unittest.cc
+++ b/media/midi/usb_midi_descriptor_parser_unittest.cc
@@ -40,7 +40,7 @@ TEST(UsbMidiDescriptorParserTest, NonExistingJackIsAssociated) {
 }
 
 TEST(UsbMidiDescriptorParserTest,
-     JacksShouldBeIgnoredWhenParserIsNotParsingMIDIInterface) {
+     JacksShouldBeIgnoredWhenParserIsNotParsingMidiInterface) {
   UsbMidiDescriptorParser parser;
   std::vector<UsbMidiJack> jacks;
   // a NON-MIDI INTERFACE descriptor followed by ENDPOINT and CS_ENDPOINT