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

media/midi/midi_manager_mac.cc

 // Copyright (c) 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_mac.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/sys_string_conversions.h"
 
 #include <CoreAudio/HostTime.h>
 #include <stddef.h>
 
 using base::IntToString;
 using base::SysCFStringRefToUTF8;
 using std::string;
+using midi::mojom::PortState;
 using midi::mojom::Result;
 
 // NB: System MIDI types are pointer types in 32-bit and integer types in
 // 64-bit. Therefore, the initialization is the simplest one that satisfies both
 // (if possible).
 
 namespace midi {
 
 namespace {
 
@@ skipping 49 matching lines @@
   } else {
     // On connecting some devices, e.g., nano KONTROL2, unknown endpoints
     // appear and disappear quickly and they fail on queries.
     // Let's ignore such ghost devices.
     // Same problems will happen if the device is disconnected before finishing
     // all queries.
     DLOG(WARNING) << "Failed to get kMIDIPropertyUniqueID with status "
                   << result;
   }
 
-  const MidiPortState state = MIDI_PORT_OPENED;
+  const PortState state = PortState::OPENED;
   return MidiPortInfo(id, manufacturer, name, version, state);
 }
 
 double MIDITimeStampToSeconds(MIDITimeStamp timestamp) {
   UInt64 nanoseconds = AudioConvertHostTimeToNanos(timestamp);
   return static_cast<double>(nanoseconds) / 1.0e9;
 }
 
 MIDITimeStamp SecondsToMIDITimeStamp(double seconds) {
   UInt64 nanos = UInt64(seconds * 1.0e9);
@@ skipping 157 matching lines @@
         // On kMIDIMsgObjectRemoved, the entry will be ignored because it
         // will not be found in the pool.
         if (!info.id.empty()) {
           uint32_t index = source_map_.size();
           source_map_[endpoint] = index;
           AddInputPort(info);
           MIDIPortConnectSource(
               coremidi_input_, endpoint, reinterpret_cast<void*>(endpoint));
         }
       } else {
-        SetInputPortState(it->second, MIDI_PORT_OPENED);
+        SetInputPortState(it->second, PortState::OPENED);
       }
     } else if (notification->childType == kMIDIObjectType_Destination) {
       // Attaching device is an output device.
       auto it = std::find(destinations_.begin(), destinations_.end(), endpoint);
       if (it == destinations_.end()) {
         MidiPortInfo info = GetPortInfoFromEndpoint(endpoint);
         // Skip cases that queries are not finished correctly.
         if (!info.id.empty()) {
           destinations_.push_back(endpoint);
           AddOutputPort(info);
         }
       } else {
-        SetOutputPortState(it - destinations_.begin(), MIDI_PORT_OPENED);
+        SetOutputPortState(it - destinations_.begin(), PortState::OPENED);
       }
     }
   } else if (kMIDIMsgObjectRemoved == message->messageID) {
     // Existing device is going to be detached.
     const MIDIObjectAddRemoveNotification* notification =
         reinterpret_cast<const MIDIObjectAddRemoveNotification*>(message);
     MIDIEndpointRef endpoint =
         static_cast<MIDIEndpointRef>(notification->child);
     if (notification->childType == kMIDIObjectType_Source) {
       // Detaching device is an input device.
       auto it = source_map_.find(endpoint);
       if (it != source_map_.end())
-        SetInputPortState(it->second, MIDI_PORT_DISCONNECTED);
+        SetInputPortState(it->second, PortState::DISCONNECTED);
     } else if (notification->childType == kMIDIObjectType_Destination) {
       // Detaching device is an output device.
       auto it = std::find(destinations_.begin(), destinations_.end(), endpoint);
       if (it != destinations_.end())
-        SetOutputPortState(it - destinations_.begin(), MIDI_PORT_DISCONNECTED);
+        SetOutputPortState(it - destinations_.begin(), PortState::DISCONNECTED);
     }
   }
 }
 
 // static
 void MidiManagerMac::ReadMidiDispatch(const MIDIPacketList* packet_list,
                                       void* read_proc_refcon,
                                       void* src_conn_refcon) {
   // This method is called on a separate high-priority thread owned by CoreMIDI.
 
@@ skipping 70 matching lines @@
         &data[sent_size]);
     DCHECK(midi_packet);
 
     MIDISend(coremidi_output_, destination, packet_list);
   }
 
   AccumulateMidiBytesSent(client, data.size());
 }
 
 }  // namespace midi