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

media/midi/midi_manager_alsa.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_alsa.h"
 
 #include <errno.h>
 #include <poll.h>
 #include <stddef.h>
 #include <stdlib.h>
@@ skipping 14 matching lines @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "crypto/sha2.h"
 #include "media/midi/midi_port_info.h"
 
 namespace midi {
 
 namespace {
 
-using midi::mojom::Result;
+using mojom::PortState;
+using mojom::Result;
 
 // Per-output buffer. This can be smaller, but then large sysex messages
 // will be (harmlessly) split across multiple seq events. This should
 // not have any real practical effect, except perhaps to slightly reorder
 // realtime messages with respect to sysex.
 const size_t kSendBufferSize = 256;
 
 // Minimum client id for which we will have ALSA card devices for. When we
 // are searching for card devices (used to get the path, id, and manufacturer),
 // we don't want to get confused by kernel clients that do not have a card.
@@ skipping 1149 matching lines @@
   // Disconnect any connected old ports that are now missing.
   for (auto& old_port : port_state_) {
     if (old_port->connected() &&
         (new_port_state->FindConnected(*old_port) == new_port_state->end())) {
       old_port->set_connected(false);
       uint32_t web_port_index = old_port->web_port_index();
       switch (old_port->type()) {
         case MidiPort::Type::kInput:
           source_map_.erase(
               AddrToInt(old_port->client_id(), old_port->port_id()));
-          SetInputPortState(web_port_index, MIDI_PORT_DISCONNECTED);
+          SetInputPortState(web_port_index, PortState::DISCONNECTED);
           break;
         case MidiPort::Type::kOutput:
           DeleteAlsaOutputPort(web_port_index);
-          SetOutputPortState(web_port_index, MIDI_PORT_DISCONNECTED);
+          SetOutputPortState(web_port_index, PortState::DISCONNECTED);
           break;
       }
     }
   }
 
   // Reconnect or add new ports.
   auto it = new_port_state->begin();
   while (it != new_port_state->end()) {
     auto& new_port = *it;
     auto old_port = port_state_.Find(*new_port);
     if (old_port == port_state_.end()) {
       // Add new port.
       const auto& opaque_key = new_port->OpaqueKey();
       const auto& manufacturer = new_port->manufacturer();
       const auto& port_name = new_port->port_name();
       const auto& version = new_port->version();
       const auto& type = new_port->type();
       const auto& client_id = new_port->client_id();
       const auto& port_id = new_port->port_id();
 
       uint32_t web_port_index = port_state_.push_back(std::move(new_port));
       it = new_port_state->erase(it);
 
       MidiPortInfo info(opaque_key, manufacturer, port_name, version,
-                        MIDI_PORT_OPENED);
+                        PortState::OPENED);
       switch (type) {
         case MidiPort::Type::kInput:
           if (Subscribe(web_port_index, client_id, port_id))
             AddInputPort(info);
           break;
         case MidiPort::Type::kOutput:
           if (CreateAlsaOutputPort(web_port_index, client_id, port_id))
             AddOutputPort(info);
           break;
       }
     } else if (!(*old_port)->connected()) {
       // Reconnect.
       uint32_t web_port_index = (*old_port)->web_port_index();
       (*old_port)->Update(new_port->path(), new_port->client_id(),
                           new_port->port_id(), new_port->client_name(),
                           new_port->port_name(), new_port->manufacturer(),
                           new_port->version());
       switch ((*old_port)->type()) {
         case MidiPort::Type::kInput:
           if (Subscribe(web_port_index, (*old_port)->client_id(),
                         (*old_port)->port_id()))
-            SetInputPortState(web_port_index, MIDI_PORT_OPENED);
+            SetInputPortState(web_port_index, PortState::OPENED);
           break;
         case MidiPort::Type::kOutput:
           if (CreateAlsaOutputPort(web_port_index, (*old_port)->client_id(),
                                    (*old_port)->port_id()))
-            SetOutputPortState(web_port_index, MIDI_PORT_OPENED);
+            SetOutputPortState(web_port_index, PortState::OPENED);
           break;
       }
       (*old_port)->set_connected(true);
       ++it;
     } else {
       ++it;
     }
   }
 }
 
@@ skipping 126 matching lines @@
   // Update our map.
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace midi