Web MIDI: make naming convention be consistent

media/midi/midi_manager_win.cc

 // Copyright 2013 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_win.h"
 
 #include <windows.h>
 
 // Prevent unnecessary functions from being included from <mmsystem.h>
 #define MMNODRV
@@ skipping 58 matching lines @@
 typedef scoped_ptr<MIDIHDR, MIDIHDRDeleter> ScopedMIDIHDR;
 
 ScopedMIDIHDR CreateMIDIHDR(size_t size) {
   ScopedMIDIHDR header(new MIDIHDR);
   ZeroMemory(header.get(), sizeof(*header));
   header->lpData = new char[size];
   header->dwBufferLength = 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;
 
   DWORD packed_message = 0;
   for (size_t i = 0; i < message.size(); ++i)
     packed_message |= (static_cast<uint32>(message[i]) << (i * 8));
   MMRESULT result = midiOutShortMsg(midi_out_handle, packed_message);
   DLOG_IF(ERROR, result != MMSYSERR_NOERROR)
       << "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
   // depending on the driver. There are 2 options to support both cases:
   // 1) Call midiOutLongMsg() API and wait for its completion within this
   //   function. In this approach, we can avoid memory copy by directly pointing
   //   |message| as the data buffer to be sent.
   // 2) Allocate a buffer and copy |message| to it, then call midiOutLongMsg()
   //   API. The buffer will be freed in the MOM_DONE event hander, which tells
   //   us that the task of midiOutLongMsg() API is completed.
@@ skipping 37 matching lines @@
         << GetOutErrorMessage(result);
     return;
   }
 
   // The ownership of |midi_header| is moved to MOM_DONE event handler.
   midi_header.release();
 }
 
 }  // namespace
 
-class MIDIManagerWin::InDeviceInfo {
+class MidiManagerWin::InDeviceInfo {
  public:
   ~InDeviceInfo() {
     Uninitialize();
   }
   void set_port_index(int index) {
     port_index_ = index;
   }
   int port_index() const {
     return port_index_;
   }
   bool device_to_be_closed() const {
     return device_to_be_closed_;
   }
   HMIDIIN midi_handle() const {
     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))
       obj.reset();
     return obj.Pass();
   }
 
  private:
   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),
         started_(false),
         device_to_be_closed_(false) {
   }
 
   bool Initialize(DWORD device_id) {
     Uninitialize();
     midi_header_ = CreateMIDIHDR(kBufferLength);
@@ skipping 99 matching lines @@
         return;
     }
   }
 
   void OnShortMessageReceived(uint8 status_byte,
                               uint8 first_data_byte,
                               uint8 second_data_byte,
                               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 };
     DCHECK_LE(len, arraysize(kData));
     OnMessageReceived(kData, len, elapsed_ms);
   }
 
   void OnLongMessageReceived(MIDIHDR* header, DWORD elapsed_ms) {
     if (header != midi_header_.get())
       return;
@@ skipping 19 matching lines @@
         << "Failed to attach input port: " << GetInErrorMessage(result);
   }
 
   void OnMessageReceived(const uint8* data, size_t length, DWORD elapsed_ms) {
     // MIM_DATA/MIM_LONGDATA message treats the time when midiInStart() is
     // called as the origin of |elapsed_ms|.
     // http://msdn.microsoft.com/en-us/library/windows/desktop/dd757284.aspx
     // 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();
   }
 
   static scoped_ptr<OutDeviceInfo> Create(UINT device_id) {
     scoped_ptr<OutDeviceInfo> obj(new OutDeviceInfo);
     if (!obj->Initialize(device_id))
       obj.reset();
     return obj.Pass();
@@ skipping 12 matching lines @@
     if (!midi_handle_)
       return;
 
     // Give up sending MIDI messages here if the device is already closed.
     // Note that this check is optional. Regardless of that we check |closed_|
     // or not, nothing harmful happens as long as |midi_handle_| is still valid.
     if (closed_)
       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);
     }
   }
 
  private:
   OutDeviceInfo()
       : midi_handle_(NULL),
         closed_(false),
         quitting_(false) {}
 
   bool Initialize(DWORD device_id) {
     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
     //     is disconnected. As for the former case, HMIDIOUT will be invalidated
     //     soon after the callback is finished. As for the later case, however,
     //     HMIDIOUT continues to be valid until midiOutClose() is called.
     MMRESULT result = midiOutOpen(&midi_handle_,
                                   device_id,
                                   reinterpret_cast<DWORD_PTR>(&HandleMessage),
                                   reinterpret_cast<DWORD_PTR>(this),
@@ skipping 55 matching lines @@
         // TODO(yukawa): Implement crbug.com/279097.
         return;
     }
   }
 
   HMIDIOUT midi_handle_;
 
   // 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) {
     MIDIINCAPS caps = {};
     MMRESULT result = midiInGetDevCaps(device_id, &caps, sizeof(caps));
     if (result != MMSYSERR_NOERROR) {
       DLOG(ERROR) << "Failed to obtain input device info: "
                   << GetInErrorMessage(result);
       continue;
     }
     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),
         base::IntToString(static_cast<int>(caps.vDriverVersion)));
     AddInputPort(info);
     in_device->set_port_index(input_ports_.size() - 1);
     in_devices_.push_back(in_device.Pass());
   }
 
   const UINT num_out_devices = midiOutGetNumDevs();
   out_devices_.reserve(num_out_devices);
   for (UINT device_id = 0; device_id < num_out_devices; ++device_id) {
     MIDIOUTCAPS caps = {};
     MMRESULT result = midiOutGetDevCaps(device_id, &caps, sizeof(caps));
     if (result != MMSYSERR_NOERROR) {
       DLOG(ERROR) << "Failed to obtain output device info: "
                   << GetOutErrorMessage(result);
       continue;
     }
     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),
         base::IntToString(static_cast<int>(caps.vDriverVersion)));
     AddOutputPort(info);
     out_devices_.push_back(out_port.Pass());
   }
 
   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)
     out_devices_[i]->Quit();
   send_thread_.Stop();
 
   out_devices_.clear();
   output_ports_.clear();
   in_devices_.clear();
   input_ports_.clear();
 }
 
-void MIDIManagerWin::DispatchSendMIDIData(MIDIManagerClient* client,
+void MidiManagerWin::DispatchSendMidiData(MidiManagerClient* client,
                                           uint32 port_index,
                                           const std::vector<uint8>& data,
                                           double timestamp) {
   if (out_devices_.size() <= port_index)
     return;
 
   base::TimeDelta delay;
   if (timestamp != 0.0) {
     base::TimeTicks time_to_send =
         base::TimeTicks() + base::TimeDelta::FromMicroseconds(
             timestamp * base::Time::kMicrosecondsPerSecond);
     delay = std::max(time_to_send - base::TimeTicks::Now(), base::TimeDelta());
   }
 
   if (!send_thread_.IsRunning())
     send_thread_.Start();
 
   OutDeviceInfo* out_port = out_devices_[port_index].get();
   send_thread_.message_loop()->PostDelayedTask(
       FROM_HERE,
       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