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

media/midi/midi_manager_winrt.cc

 // Copyright 2016 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_winrt.h"
 
 #pragma warning(disable : 4467)
 
 #include <initguid.h>  // Required by <devpkey.h>
 
@@ skipping 24 matching lines @@
 namespace {
 
 namespace WRL = Microsoft::WRL;
 
 using namespace ABI::Windows::Devices::Enumeration;
 using namespace ABI::Windows::Devices::Midi;
 using namespace ABI::Windows::Foundation;
 using namespace ABI::Windows::Storage::Streams;
 
 using base::win::ScopedComPtr;
+using mojom::PortState;
 using mojom::Result;
 
 // Helpers for printing HRESULTs.
 struct PrintHr {
   PrintHr(HRESULT hr) : hr(hr) {}
   HRESULT hr;
 };
 
 std::ostream& operator<<(std::ostream& os, const PrintHr& phr) {
   std::ios_base::fmtflags ff = os.flags();
@@ skipping 587 matching lines @@
     CHECK(is_initialized_);
 
     // Note: in case Microsoft GS Wavetable Synth triggers this event for some
     // reason, it will be ignored here with log emitted.
     MidiPort<InterfaceType>* port = GetPortByDeviceId(dev_id);
     if (!port) {
       VLOG(1) << "Removing non-existent port " << dev_id;
       return;
     }
 
-    SetPortState(port->index, MIDI_PORT_DISCONNECTED);
+    SetPortState(port->index, PortState::DISCONNECTED);
 
     RemovePortEventHandlers(port);
     port->handle = nullptr;
   }
 
   void OnCompletedGetPortFromIdAsync(IAsyncOperation<RuntimeType*>* async_op) {
     DCHECK(thread_checker_.CalledOnValidThread());
     CHECK(is_initialized_);
 
     InterfaceType* handle = nullptr;
@@ skipping 21 matching lines @@
 
     std::string dev_id = GetDeviceIdString(handle);
 
     MidiPort<InterfaceType>* port = GetPortByDeviceId(dev_id);
 
     if (port == nullptr) {
       std::string manufacturer = "Unknown", driver_version = "Unknown";
       GetDriverInfoFromDeviceId(dev_id, &manufacturer, &driver_version);
 
       AddPort(MidiPortInfo(dev_id, manufacturer, port_names_[dev_id],
-                           driver_version, MIDI_PORT_OPENED));
+                           driver_version, PortState::OPENED));
 
       port = new MidiPort<InterfaceType>;
       port->index = static_cast<uint32_t>(port_ids_.size());
 
       ports_[dev_id].reset(port);
       port_ids_.push_back(dev_id);
     } else {
-      SetPortState(port->index, MIDI_PORT_CONNECTED);
+      SetPortState(port->index, PortState::CONNECTED);
     }
 
     port->handle = handle;
     port->token_MessageReceived = token;
 
     if (enumeration_completed_not_ready_ && async_ops_.empty()) {
       midi_manager_->OnPortManagerReady();
       enumeration_completed_not_ready_ = false;
     }
   }
 
   // Overrided by MidiInPortManager to listen to input ports.
   virtual bool RegisterOnMessageReceived(InterfaceType* handle,
                                          EventRegistrationToken* p_token) {
     return true;
   }
 
   // Overrided by MidiInPortManager to remove MessageReceived event handler.
   virtual void RemovePortEventHandlers(MidiPort<InterfaceType>* port) {}
 
   // Calls midi_manager_->Add{Input,Output}Port.
   virtual void AddPort(MidiPortInfo info) = 0;
 
   // Calls midi_manager_->Set{Input,Output}PortState.
-  virtual void SetPortState(uint32_t port_index, MidiPortState state) = 0;
+  virtual void SetPortState(uint32_t port_index, PortState state) = 0;
 
   // WeakPtrFactory has to be declared in derived class, use this method to
   // retrieve upcasted WeakPtr for posting tasks.
   virtual base::WeakPtr<MidiPortManager> GetWeakPtrFromFactory() = 0;
 
   // Midi{In,Out}PortStatics instance.
   ScopedComPtr<StaticsInterfaceType> midi_port_statics_;
 
   // DeviceWatcher instance and event registration tokens for unsubscribing
   // events in destructor.
@@ skipping 104 matching lines @@
       return;
 
     HRESULT hr =
         port->handle->remove_MessageReceived(port->token_MessageReceived);
     VLOG_IF(1, FAILED(hr)) << "remove_MessageReceived failed: " << PrintHr(hr);
     port->token_MessageReceived.value = kInvalidTokenValue;
   }
 
   void AddPort(MidiPortInfo info) final { midi_manager_->AddInputPort(info); }
 
-  void SetPortState(uint32_t port_index, MidiPortState state) final {
+  void SetPortState(uint32_t port_index, PortState state) final {
     midi_manager_->SetInputPortState(port_index, state);
   }
 
   base::WeakPtr<MidiPortManager> GetWeakPtrFromFactory() final {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     return weak_factory_.GetWeakPtr();
   }
 
   // Callback on receiving MIDI input message.
@@ skipping 20 matching lines @@
                              IMidiOutPortStatics,
                              RuntimeClass_Windows_Devices_Midi_MidiOutPort> {
  public:
   MidiOutPortManager(MidiManagerWinrt* midi_manager)
       : MidiPortManager(midi_manager), weak_factory_(this) {}
 
  private:
   // MidiPortManager overrides:
   void AddPort(MidiPortInfo info) final { midi_manager_->AddOutputPort(info); }
 
-  void SetPortState(uint32_t port_index, MidiPortState state) final {
+  void SetPortState(uint32_t port_index, PortState state) final {
     midi_manager_->SetOutputPortState(port_index, state);
   }
 
   base::WeakPtr<MidiPortManager> GetWeakPtrFromFactory() final {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     return weak_factory_.GetWeakPtr();
   }
 
   // Last member to ensure destructed first.
@@ skipping 135 matching lines @@
 
 void MidiManagerWinrt::OnPortManagerReady() {
   DCHECK(com_thread_checker_->CalledOnValidThread());
   DCHECK(port_manager_ready_count_ < 2);
 
   if (++port_manager_ready_count_ == 2)
     CompleteInitialization(Result::OK);
 }
 
 }  // namespace midi