Web MIDI: use midi_service.mojom for media::midi::PortState

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>
 #include <ks.h>
 #include <ksmedia.h>
 #include <mmreg.h>
@@ skipping 34 matching lines @@
 #include "device/usb/usb_ids.h"
 #include "media/midi/message_util.h"
 #include "media/midi/midi_manager_winrt.h"
 #include "media/midi/midi_message_queue.h"
 #include "media/midi/midi_port_info.h"
 #include "media/midi/midi_switches.h"
 
 namespace midi {
 namespace {
 
+using mojom::PortState;
 using mojom::Result;
 
 static const size_t kBufferLength = 32 * 1024;
 
 // We assume that nullpter represents an invalid MIDI handle.
 const HMIDIIN kInvalidMidiInHandle = nullptr;
 const HMIDIOUT kInvalidMidiOutHandle = nullptr;
 
 std::string GetInErrorMessage(MMRESULT result) {
   wchar_t text[MAXERRORLENGTH];
@@ skipping 609 matching lines @@
     task_thread_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&MidiServiceWinImpl::StartInputDeviceOnTaskThread,
                               base::Unretained(this), midi_in_handle));
     if (add_new_port) {
       const MidiPortInfo port_info(
           // TODO(toyoshim): Use a hash ID insted crbug.com/467448
           base::IntToString(static_cast<int>(port_number)),
           GetManufacturerName(state_device_info),
           base::WideToUTF8(state_device_info.product_name),
           MmversionToString(state_device_info.driver_version),
-          MIDI_PORT_OPENED);
+          PortState::OPENED);
       task_thread_.task_runner()->PostTask(
           FROM_HERE, base::Bind(&MidiServiceWinImpl::AddInputPortOnTaskThread,
                                 base::Unretained(this), port_info));
     } else {
       task_thread_.task_runner()->PostTask(
           FROM_HERE,
           base::Bind(&MidiServiceWinImpl::SetInputPortStateOnTaskThread,
                      base::Unretained(this), port_number,
-                     MidiPortState::MIDI_PORT_CONNECTED));
+                     PortState::CONNECTED));
     }
   }
 
   void OnMidiInDataOnMultimediaThread(HMIDIIN midi_in_handle,
                                       DWORD_PTR param1,
                                       DWORD_PTR param2) {
     auto state = GetInputDeviceFromHandle(midi_in_handle);
     if (!state)
       return;
     const uint8_t status_byte = static_cast<uint8_t>(param1 & 0xff);
@@ skipping 71 matching lines @@
       base::AutoLock auto_lock(input_ports_lock_);
       input_device_map_.erase(state->midi_handle);
       input_ports_[port_number] = nullptr;
       input_ports_ages_[port_number] += 1;
       unused_input_ports_[device_info].push(port_number);
     }
     task_thread_.task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&MidiServiceWinImpl::SetInputPortStateOnTaskThread,
                    base::Unretained(this), port_number,
-                   MIDI_PORT_DISCONNECTED));
+                   PortState::DISCONNECTED));
   }
 
   static void CALLBACK
   OnMidiOutEventOnMainlyMultimediaThread(HMIDIOUT midi_out_handle,
                                          UINT message,
                                          DWORD_PTR instance,
                                          DWORD_PTR param1,
                                          DWORD_PTR param2) {
     MidiServiceWinImpl* self = reinterpret_cast<MidiServiceWinImpl*>(instance);
     if (!self)
@@ skipping 56 matching lines @@
       output_ports_[port_number]->port_index = port_number;
       output_ports_[port_number]->port_age = output_ports_ages_[port_number];
     }
     if (add_new_port) {
       const MidiPortInfo port_info(
           // TODO(toyoshim): Use a hash ID insted. crbug.com/467448
           base::IntToString(static_cast<int>(port_number)),
           GetManufacturerName(state_device_info),
           base::WideToUTF8(state_device_info.product_name),
           MmversionToString(state_device_info.driver_version),
-          MIDI_PORT_OPENED);
+          PortState::OPENED);
       task_thread_.task_runner()->PostTask(
           FROM_HERE, base::Bind(&MidiServiceWinImpl::AddOutputPortOnTaskThread,
                                 base::Unretained(this), port_info));
     } else {
       task_thread_.task_runner()->PostTask(
           FROM_HERE,
           base::Bind(&MidiServiceWinImpl::SetOutputPortStateOnTaskThread,
-                     base::Unretained(this), port_number, MIDI_PORT_CONNECTED));
+                     base::Unretained(this), port_number,
+                     PortState::CONNECTED));
     }
   }
 
   void OnMidiOutDoneOnMultimediaThread(HMIDIOUT midi_out_handle,
                                        DWORD_PTR param1) {
     auto state = GetOutputDeviceFromHandle(midi_out_handle);
     if (!state)
       return;
     // Take ownership of the MIDIHDR object.
     ScopedMIDIHDR header(reinterpret_cast<MIDIHDR*>(param1));
@@ skipping 17 matching lines @@
       output_device_map_.erase(state->midi_handle);
       output_ports_[port_number] = nullptr;
       output_ports_ages_[port_number] += 1;
       unused_output_ports_[device_info].push(port_number);
       state->closed = true;
     }
     task_thread_.task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&MidiServiceWinImpl::SetOutputPortStateOnTaskThread,
                    base::Unretained(this), port_number,
-                   MIDI_PORT_DISCONNECTED));
+                   PortState::DISCONNECTED));
   }
 
   /////////////////////////////////////////////////////////////////////////////
   // Callbacks on the sender thread.
   /////////////////////////////////////////////////////////////////////////////
 
   void AssertOnSenderThread() {
     DCHECK_EQ(sender_thread_.GetThreadId(), base::PlatformThread::CurrentId());
   }
 
@@ skipping 151 matching lines @@
   void AddInputPortOnTaskThread(MidiPortInfo info) {
     AssertOnTaskThread();
     delegate_->OnAddInputPort(info);
   }
 
   void AddOutputPortOnTaskThread(MidiPortInfo info) {
     AssertOnTaskThread();
     delegate_->OnAddOutputPort(info);
   }
 
-  void SetInputPortStateOnTaskThread(uint32_t port_index, MidiPortState state) {
+  void SetInputPortStateOnTaskThread(uint32_t port_index, PortState state) {
     AssertOnTaskThread();
     delegate_->OnSetInputPortState(port_index, state);
   }
 
-  void SetOutputPortStateOnTaskThread(uint32_t port_index,
-                                      MidiPortState state) {
+  void SetOutputPortStateOnTaskThread(uint32_t port_index, PortState state) {
     AssertOnTaskThread();
     delegate_->OnSetOutputPortState(port_index, state);
   }
 
   /////////////////////////////////////////////////////////////////////////////
   // Fields:
   /////////////////////////////////////////////////////////////////////////////
 
   // Does not take ownership.
   MidiServiceWinDelegate* delegate_;
@@ skipping 73 matching lines @@
 }
 
 void MidiManagerWin::OnAddInputPort(MidiPortInfo info) {
   AddInputPort(info);
 }
 
 void MidiManagerWin::OnAddOutputPort(MidiPortInfo info) {
   AddOutputPort(info);
 }
 
-void MidiManagerWin::OnSetInputPortState(uint32_t port_index,
-                                         MidiPortState state) {
+void MidiManagerWin::OnSetInputPortState(uint32_t port_index, PortState state) {
   SetInputPortState(port_index, state);
 }
 
 void MidiManagerWin::OnSetOutputPortState(uint32_t port_index,
-                                          MidiPortState state) {
+                                          PortState state) {
   SetOutputPortState(port_index, state);
 }
 
 void MidiManagerWin::OnReceiveMidiData(uint32_t port_index,
                                        const std::vector<uint8_t>& data,
                                        base::TimeTicks time) {
   ReceiveMidiData(port_index, &data[0], data.size(), time);
 }
 
 MidiManager* MidiManager::Create() {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableWinrtMidiApi) &&
       base::win::GetVersion() >= base::win::VERSION_WIN10)
     return new MidiManagerWinrt();
   return new MidiManagerWin();
 }
 
 }  // namespace midi