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

media/midi/midi_manager_android.cc

 // Copyright 2014 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_android.h"
 
 #include "base/android/build_info.h"
 #include "base/android/context_utils.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "jni/MidiManagerAndroid_jni.h"
 #include "media/midi/midi_device_android.h"
 #include "media/midi/midi_manager_usb.h"
 #include "media/midi/midi_output_port_android.h"
 #include "media/midi/midi_switches.h"
 #include "media/midi/usb_midi_device_factory_android.h"
 
 using base::android::JavaParamRef;
+using midi::mojom::PortState;
 using midi::mojom::Result;
 
 namespace midi {
 
 MidiManager* MidiManager::Create() {
   auto sdk_version = base::android::BuildInfo::GetInstance()->sdk_int();
   if (sdk_version <= base::android::SDK_VERSION_LOLLIPOP_MR1 ||
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUseAndroidMidiApi)) {
     return new MidiManagerUsb(std::unique_ptr<UsbMidiDevice::Factory>(
@@ skipping 34 matching lines @@
 void MidiManagerAndroid::DispatchSendMidiData(MidiManagerClient* client,
                                               uint32_t port_index,
                                               const std::vector<uint8_t>& data,
                                               double timestamp) {
   if (port_index >= all_output_ports_.size()) {
     // |port_index| is provided by a renderer so we can't believe that it is
     // in the valid range.
     return;
   }
   DCHECK_EQ(output_ports().size(), all_output_ports_.size());
-  if (output_ports()[port_index].state == MIDI_PORT_CONNECTED) {
+  if (output_ports()[port_index].state == PortState::CONNECTED) {
     // We treat send call as implicit open.
     // TODO(yhirano): Implement explicit open operation from the renderer.
     if (all_output_ports_[port_index]->Open()) {
-      SetOutputPortState(port_index, MIDI_PORT_OPENED);
+      SetOutputPortState(port_index, PortState::OPENED);
     } else {
       // We cannot open the port. It's useless to send data to such a port.
       return;
     }
   }
 
   // output_streams_[port_index] is alive unless MidiManagerUsb is deleted.
   // The task posted to the MidiScheduler will be disposed safely on deleting
   // the scheduler.
   scheduler_->PostSendDataTask(
@@ skipping 37 matching lines @@
 }
 
 void MidiManagerAndroid::OnDetached(JNIEnv* env,
                                     const JavaParamRef<jobject>& caller,
                                     const JavaParamRef<jobject>& raw_device) {
   for (auto* device : devices_) {
     if (device->HasRawDevice(env, raw_device)) {
       for (auto* port : device->input_ports()) {
         DCHECK(input_port_to_index_.end() != input_port_to_index_.find(port));
         size_t index = input_port_to_index_[port];
-        SetInputPortState(index, MIDI_PORT_DISCONNECTED);
+        SetInputPortState(index, PortState::DISCONNECTED);
       }
       for (auto* port : device->output_ports()) {
         DCHECK(output_port_to_index_.end() != output_port_to_index_.find(port));
         size_t index = output_port_to_index_[port];
-        SetOutputPortState(index, MIDI_PORT_DISCONNECTED);
+        SetOutputPortState(index, PortState::DISCONNECTED);
       }
     }
   }
 }
 
 void MidiManagerAndroid::AddDevice(std::unique_ptr<MidiDeviceAndroid> device) {
   for (auto* port : device->input_ports()) {
     // We implicitly open input ports here, because there are no signal
     // from the renderer when to open.
     // TODO(yhirano): Implement open operation in Blink.
-    MidiPortState state = port->Open() ? MIDI_PORT_OPENED : MIDI_PORT_CONNECTED;
+    PortState state = port->Open() ? PortState::OPENED : PortState::CONNECTED;
 
     const size_t index = all_input_ports_.size();
     all_input_ports_.push_back(port);
     // Port ID must be unique in a MIDI manager. This ID setting is
     // sufficiently unique although there is no user-friendly meaning.
     // TODO(yhirano): Use a hashed string as ID.
     const std::string id(
         base::StringPrintf("native:port-in-%ld", static_cast<long>(index)));
 
     input_port_to_index_.insert(std::make_pair(port, index));
     AddInputPort(MidiPortInfo(id, device->GetManufacturer(),
                               device->GetProductName(),
                               device->GetDeviceVersion(), state));
   }
   for (auto* port : device->output_ports()) {
     const size_t index = all_output_ports_.size();
     all_output_ports_.push_back(port);
 
     // Port ID must be unique in a MIDI manager. This ID setting is
     // sufficiently unique although there is no user-friendly meaning.
     // TODO(yhirano): Use a hashed string as ID.
     const std::string id(
         base::StringPrintf("native:port-out-%ld", static_cast<long>(index)));
 
     output_port_to_index_.insert(std::make_pair(port, index));
     AddOutputPort(
         MidiPortInfo(id, device->GetManufacturer(), device->GetProductName(),
-                     device->GetDeviceVersion(), MIDI_PORT_CONNECTED));
+                     device->GetDeviceVersion(), PortState::CONNECTED));
   }
   devices_.push_back(device.release());
 }
 
 bool MidiManagerAndroid::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace midi