[WebMIDI] Replace midi::MidiPortInfo with midi::mojom::PortInfo

This should make mojofying MidiHost and MidiMessageFilter easier.

Bug: 582328
Change-Id: I4dfcdb990cd938a63ec99f238020bc6ba325350f
Reviewed-on: https://chromium-review.googlesource.com/c/1244601Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Takashi Toyoshima <toyoshim@chromium.org>
Commit-Queue: Adithya Srinivasan <adithyas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#600407}

content/browser/media/midi_host.cc

@@ -36,7 +36,6 @@ const size_t kAcknowledgementThresholdBytes = 1024 * 1024;  // 1 MB.
 using midi::IsDataByte;
 using midi::IsSystemRealTimeMessage;
 using midi::IsValidWebMIDIData;
-using midi::MidiPortInfo;
 using midi::kSysExByte;
 using midi::kEndOfSysExByte;
 using midi::mojom::PortState;
@@ -147,14 +146,14 @@ void MidiHost::CompleteStartSession(Result result) {
   Send(new MidiMsg_SessionStarted(result));
 }
 
-void MidiHost::AddInputPort(const MidiPortInfo& info) {
+void MidiHost::AddInputPort(const midi::mojom::PortInfo& info) {
   base::AutoLock auto_lock(messages_queues_lock_);
   // MidiMessageQueue is created later in ReceiveMidiData().
   received_messages_queues_.push_back(nullptr);
   Send(new MidiMsg_AddInputPort(info));
 }
 
-void MidiHost::AddOutputPort(const MidiPortInfo& info) {
+void MidiHost::AddOutputPort(const midi::mojom::PortInfo& info) {
   base::AutoLock auto_lock(output_port_count_lock_);
   output_port_count_++;
   Send(new MidiMsg_AddOutputPort(info));

content/browser/media/midi_host.h

@@ -19,7 +19,6 @@
 #include "content/public/browser/browser_message_filter.h"
 #include "content/public/browser/browser_thread.h"
 #include "media/midi/midi_manager.h"
-#include "media/midi/midi_port_info.h"
 #include "media/midi/midi_service.mojom.h"
 
 namespace midi {
@@ -42,8 +41,8 @@ class CONTENT_EXPORT MidiHost : public BrowserMessageFilter,
 
   // MidiManagerClient implementation.
   void CompleteStartSession(midi::mojom::Result result) override;
-  void AddInputPort(const midi::MidiPortInfo& info) override;
-  void AddOutputPort(const midi::MidiPortInfo& info) override;
+  void AddInputPort(const midi::mojom::PortInfo& info) override;
+  void AddOutputPort(const midi::mojom::PortInfo& info) override;
   void SetInputPortState(uint32_t port, midi::mojom::PortState state) override;
   void SetOutputPortState(uint32_t port, midi::mojom::PortState state) override;
   void ReceiveMidiData(uint32_t port,

content/browser/media/midi_host_unittest.cc

@@ -142,7 +142,7 @@ class MidiHostTest : public testing::Test {
     const std::string name("doki-doki-pi-pine");
     const std::string version("3.14159265359");
     PortState state = PortState::CONNECTED;
-    midi::MidiPortInfo info(id, manufacturer, name, version, state);
+    midi::mojom::PortInfo info(id, manufacturer, name, version, state);
 
     host_->AddOutputPort(info);
   }

content/common/media/midi_messages.h

@@ -17,7 +17,6 @@
 #include "content/common/content_export.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/param_traits_macros.h"
-#include "media/midi/midi_port_info.h"
 #include "media/midi/midi_service.mojom.h"
 #include "url/gurl.h"
 
@@ -27,7 +26,7 @@
 
 IPC_ENUM_TRAITS_MAX_VALUE(midi::mojom::PortState, midi::mojom::PortState::LAST)
 
-IPC_STRUCT_TRAITS_BEGIN(midi::MidiPortInfo)
+IPC_STRUCT_TRAITS_BEGIN(midi::mojom::PortInfo)
   IPC_STRUCT_TRAITS_MEMBER(id)
   IPC_STRUCT_TRAITS_MEMBER(manufacturer)
   IPC_STRUCT_TRAITS_MEMBER(name)
@@ -52,10 +51,10 @@ IPC_MESSAGE_CONTROL0(MidiHostMsg_EndSession)
 // Messages sent from the browser to the renderer.
 
 IPC_MESSAGE_CONTROL1(MidiMsg_AddInputPort,
-                     midi::MidiPortInfo /* input port */)
+                     midi::mojom::PortInfo /* input port */)
 
 IPC_MESSAGE_CONTROL1(MidiMsg_AddOutputPort,
-                     midi::MidiPortInfo /* output port */)
+                     midi::mojom::PortInfo /* output port */)
 
 IPC_MESSAGE_CONTROL2(MidiMsg_SetInputPortState,
                      uint32_t /* port */,

content/renderer/media/midi/midi_message_filter.cc

@@ -157,14 +157,14 @@ void MidiMessageFilter::OnSessionStarted(midi::mojom::Result result) {
       base::BindOnce(&MidiMessageFilter::HandleClientAdded, this, result));
 }
 
-void MidiMessageFilter::OnAddInputPort(midi::MidiPortInfo info) {
+void MidiMessageFilter::OnAddInputPort(midi::mojom::PortInfo info) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   main_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&MidiMessageFilter::HandleAddInputPort, this, info));
 }
 
-void MidiMessageFilter::OnAddOutputPort(midi::MidiPortInfo info) {
+void MidiMessageFilter::OnAddOutputPort(midi::mojom::PortInfo info) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   main_task_runner_->PostTask(
       FROM_HERE,
@@ -234,7 +234,7 @@ void MidiMessageFilter::HandleClientAdded(midi::mojom::Result result) {
   }
 }
 
-void MidiMessageFilter::HandleAddInputPort(midi::MidiPortInfo info) {
+void MidiMessageFilter::HandleAddInputPort(midi::mojom::PortInfo info) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   inputs_.push_back(info);
   const WebString id = WebString::FromUTF8(info.id);
@@ -245,7 +245,7 @@ void MidiMessageFilter::HandleAddInputPort(midi::MidiPortInfo info) {
     client->DidAddInputPort(id, manufacturer, name, version, info.state);
 }
 
-void MidiMessageFilter::HandleAddOutputPort(midi::MidiPortInfo info) {
+void MidiMessageFilter::HandleAddOutputPort(midi::mojom::PortInfo info) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   outputs_.push_back(info);
   const WebString id = WebString::FromUTF8(info.id);

content/renderer/media/midi/midi_message_filter.h

@@ -15,7 +15,6 @@
 #include "base/macros.h"
 #include "content/common/content_export.h"
 #include "ipc/message_filter.h"
-#include "media/midi/midi_port_info.h"
 #include "media/midi/midi_service.mojom.h"
 #include "third_party/blink/public/platform/modules/webmidi/web_midi_accessor_client.h"
 
@@ -84,8 +83,8 @@ class CONTENT_EXPORT MidiMessageFilter : public IPC::MessageFilter {
   //      existing ports.
   //  (2) To notify the recipient that a new device was connected and that new
   //      ports have been created.
-  void OnAddInputPort(midi::MidiPortInfo info);
-  void OnAddOutputPort(midi::MidiPortInfo info);
+  void OnAddInputPort(midi::mojom::PortInfo info);
+  void OnAddOutputPort(midi::mojom::PortInfo info);
 
   // These functions are called to notify the recipient that a device that is
   // notified via OnAddInputPort() or OnAddOutputPort() gets disconnected, or
@@ -107,8 +106,8 @@ class CONTENT_EXPORT MidiMessageFilter : public IPC::MessageFilter {
   // Following methods, Handle*, run on |main_task_runner_|.
   void HandleClientAdded(midi::mojom::Result result);
 
-  void HandleAddInputPort(midi::MidiPortInfo info);
-  void HandleAddOutputPort(midi::MidiPortInfo info);
+  void HandleAddInputPort(midi::mojom::PortInfo info);
+  void HandleAddOutputPort(midi::mojom::PortInfo info);
   void HandleSetInputPortState(uint32_t port, midi::mojom::PortState state);
   void HandleSetOutputPortState(uint32_t port, midi::mojom::PortState state);
 
@@ -147,8 +146,8 @@ class CONTENT_EXPORT MidiMessageFilter : public IPC::MessageFilter {
   midi::mojom::Result session_result_;
 
   // Holds MidiPortInfoList for input ports and output ports.
-  midi::MidiPortInfoList inputs_;
-  midi::MidiPortInfoList outputs_;
+  std::vector<midi::mojom::PortInfo> inputs_;
+  std::vector<midi::mojom::PortInfo> outputs_;
 
   size_t unacknowledged_bytes_sent_;
 

media/midi/BUILD.gn

@@ -85,8 +85,6 @@ component("midi") {
     "midi_manager_mac.h",
     "midi_message_queue.cc",
     "midi_message_queue.h",
-    "midi_port_info.cc",
-    "midi_port_info.h",
     "midi_service.cc",
     "midi_service.h",
     "midi_switches.cc",
@@ -191,6 +189,7 @@ test("midi_unittests") {
   configs += [ ":midi_config" ]
   deps = [
     ":midi",
+    ":mojo",
     "//base/test/:run_all_unittests",
     "//base/test/:test_support",
     "//testing/gtest",

media/midi/midi_manager.cc

@@ -220,7 +220,7 @@ void MidiManager::CompleteInitialization(Result result) {
   pending_clients_.clear();
 }
 
-void MidiManager::AddInputPort(const MidiPortInfo& info) {
+void MidiManager::AddInputPort(const mojom::PortInfo& info) {
   ReportUsage(Usage::INPUT_PORT_ADDED);
   base::AutoLock auto_lock(lock_);
   input_ports_.push_back(info);
@@ -228,7 +228,7 @@ void MidiManager::AddInputPort(const MidiPortInfo& info) {
     client->AddInputPort(info);
 }
 
-void MidiManager::AddOutputPort(const MidiPortInfo& info) {
+void MidiManager::AddOutputPort(const mojom::PortInfo& info) {
   ReportUsage(Usage::OUTPUT_PORT_ADDED);
   base::AutoLock auto_lock(lock_);
   output_ports_.push_back(info);

media/midi/midi_manager.h

@@ -17,7 +17,6 @@
 #include "base/thread_annotations.h"
 #include "base/time/time.h"
 #include "media/midi/midi_export.h"
-#include "media/midi/midi_port_info.h"
 #include "media/midi/midi_service.mojom.h"
 
 namespace base {
@@ -39,8 +38,8 @@ class MIDI_EXPORT MidiManagerClient {
   // AddInputPort() and AddOutputPort() are called before CompleteStartSession()
   // is called to notify existing MIDI ports, and also called after that to
   // notify new MIDI ports are added.
-  virtual void AddInputPort(const MidiPortInfo& info) = 0;
-  virtual void AddOutputPort(const MidiPortInfo& info) = 0;
+  virtual void AddInputPort(const mojom::PortInfo& info) = 0;
+  virtual void AddOutputPort(const mojom::PortInfo& info) = 0;
 
   // SetInputPortState() and SetOutputPortState() are called to notify a known
   // device gets disconnected, or connected again.
@@ -140,8 +139,8 @@ class MIDI_EXPORT MidiManager {
 
   // The following five methods can be called on any thread to notify clients of
   // status changes on ports, or to obtain port status.
-  void AddInputPort(const MidiPortInfo& info);
-  void AddOutputPort(const MidiPortInfo& info);
+  void AddInputPort(const mojom::PortInfo& info);
+  void AddOutputPort(const mojom::PortInfo& info);
   void SetInputPortState(uint32_t port_index, mojom::PortState state);
   void SetOutputPortState(uint32_t port_index, mojom::PortState state);
   mojom::PortState GetOutputPortState(uint32_t port_index);
@@ -191,9 +190,9 @@ class MIDI_EXPORT MidiManager {
   scoped_refptr<base::SingleThreadTaskRunner> session_thread_runner_
       GUARDED_BY(lock_);
 
-  // Keeps all MidiPortInfo.
-  MidiPortInfoList input_ports_ GUARDED_BY(lock_);
-  MidiPortInfoList output_ports_ GUARDED_BY(lock_);
+  // Keeps all PortInfo.
+  std::vector<mojom::PortInfo> input_ports_ GUARDED_BY(lock_);
+  std::vector<mojom::PortInfo> output_ports_ GUARDED_BY(lock_);
 
   // Tracks if actual data transmission happens.
   bool data_sent_ GUARDED_BY(lock_) = false;

media/midi/midi_manager_alsa.cc

@@ -25,8 +25,8 @@
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "crypto/sha2.h"
-#include "media/midi/midi_port_info.h"
 #include "media/midi/midi_service.h"
+#include "media/midi/midi_service.mojom.h"
 #include "media/midi/task_service.h"
 
 namespace midi {
@@ -1175,8 +1175,8 @@ void MidiManagerAlsa::UpdatePortStateAndGenerateEvents() {
       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,
-                        PortState::OPENED);
+      mojom::PortInfo info(opaque_key, manufacturer, port_name, version,
+                           PortState::OPENED);
       switch (type) {
         case MidiPort::Type::kInput:
           if (Subscribe(web_port_index, client_id, port_id))

media/midi/midi_manager_android.cc

@@ -183,9 +183,9 @@ void MidiManagerAndroid::AddDevice(std::unique_ptr<MidiDeviceAndroid> device) {
         base::StringPrintf("native:port-in-%ld", static_cast<long>(index)));
 
     input_port_to_index_.insert(std::make_pair(port.get(), index));
-    AddInputPort(MidiPortInfo(id, device->GetManufacturer(),
-                              device->GetProductName(),
-                              device->GetDeviceVersion(), state));
+    AddInputPort(mojom::PortInfo(id, device->GetManufacturer(),
+                                 device->GetProductName(),
+                                 device->GetDeviceVersion(), state));
   }
   for (auto& port : device->output_ports()) {
     const size_t index = all_output_ports_.size();
@@ -199,8 +199,8 @@ void MidiManagerAndroid::AddDevice(std::unique_ptr<MidiDeviceAndroid> device) {
 
     output_port_to_index_.insert(std::make_pair(port.get(), index));
     AddOutputPort(
-        MidiPortInfo(id, device->GetManufacturer(), device->GetProductName(),
-                     device->GetDeviceVersion(), PortState::CONNECTED));
+        mojom::PortInfo(id, device->GetManufacturer(), device->GetProductName(),
+                        device->GetDeviceVersion(), PortState::CONNECTED));
   }
   devices_.push_back(std::move(device));
 }

media/midi/midi_manager_mac.cc

@@ -42,7 +42,7 @@ enum {
   kClientTaskRunner,
 };
 
-MidiPortInfo GetPortInfoFromEndpoint(MIDIEndpointRef endpoint) {
+mojom::PortInfo GetPortInfoFromEndpoint(MIDIEndpointRef endpoint) {
   std::string manufacturer;
   CFStringRef manufacturer_ref = NULL;
   OSStatus result = MIDIObjectGetStringProperty(
@@ -97,7 +97,7 @@ MidiPortInfo GetPortInfoFromEndpoint(MIDIEndpointRef endpoint) {
   }
 
   const PortState state = PortState::OPENED;
-  return MidiPortInfo(id, manufacturer, name, version, state);
+  return mojom::PortInfo(id, manufacturer, name, version, state);
 }
 
 base::TimeTicks MIDITimeStampToTimeTicks(MIDITimeStamp timestamp) {
@@ -236,8 +236,8 @@ void MidiManagerMac::ReceiveMidiNotify(const MIDINotification* message) {
       // Attaching device is an input device.
       auto it = std::find(sources_.begin(), sources_.end(), endpoint);
       if (it == sources_.end()) {
-        MidiPortInfo info = GetPortInfoFromEndpoint(endpoint);
-        // If the device disappears before finishing queries, MidiPortInfo
+        mojom::PortInfo info = GetPortInfoFromEndpoint(endpoint);
+        // If the device disappears before finishing queries, mojom::PortInfo
         // becomes incomplete. Skip and do not cache such information here.
         // On kMIDIMsgObjectRemoved, the entry will be ignored because it
         // will not be found in the pool.
@@ -254,7 +254,7 @@ void MidiManagerMac::ReceiveMidiNotify(const MIDINotification* message) {
       // Attaching device is an output device.
       auto it = std::find(destinations_.begin(), destinations_.end(), endpoint);
       if (it == destinations_.end()) {
-        MidiPortInfo info = GetPortInfoFromEndpoint(endpoint);
+        mojom::PortInfo info = GetPortInfoFromEndpoint(endpoint);
         // Skip cases that queries are not finished correctly.
         if (!info.id.empty()) {
           destinations_.push_back(endpoint);

media/midi/midi_manager_mac.h

@@ -17,7 +17,7 @@
 #include "base/threading/thread.h"
 #include "media/midi/midi_export.h"
 #include "media/midi/midi_manager.h"
-#include "media/midi/midi_port_info.h"
+#include "media/midi/midi_service.mojom.h"
 
 namespace midi {
 

media/midi/midi_manager_mac_unittest.cc

@@ -36,8 +36,8 @@ class FakeMidiManagerClient : public MidiManagerClient {
         unexpected_callback_(false) {}
 
   // MidiManagerClient implementation.
-  void AddInputPort(const MidiPortInfo& info) override {}
-  void AddOutputPort(const MidiPortInfo& info) override {
+  void AddInputPort(const mojom::PortInfo& info) override {}
+  void AddOutputPort(const mojom::PortInfo& info) override {
     base::AutoLock lock(lock_);
     // AddOutputPort may be called before CompleteStartSession() is invoked
     // if one or more MIDI devices including virtual ports are connected.
@@ -90,7 +90,7 @@ class FakeMidiManagerClient : public MidiManagerClient {
     EXPECT_FALSE(unexpected_callback_);
     return result_;
   }
-  MidiPortInfo WaitForPort() {
+  mojom::PortInfo WaitForPort() {
     while (GetWaitForPort()) {
       base::RunLoop run_loop;
       run_loop.RunUntilIdle();
@@ -103,7 +103,7 @@ class FakeMidiManagerClient : public MidiManagerClient {
   base::Lock lock_;
   Result result_;
   bool wait_for_result_;
-  MidiPortInfo info_;
+  mojom::PortInfo info_;
   bool wait_for_port_;
   bool unexpected_callback_;
 
@@ -159,7 +159,7 @@ TEST_F(MidiManagerMacTest, MidiNotification) {
   EXPECT_NE(0, id);
 
   // Wait until the created device is notified to MidiManagerMac.
-  MidiPortInfo info = client->WaitForPort();
+  mojom::PortInfo info = client->WaitForPort();
   EXPECT_EQ("DestinationTest", info.name);
 
   EndSession(client.get());

media/midi/midi_manager_unittest.cc

@@ -109,8 +109,8 @@ class FakeMidiManagerClient : public MidiManagerClient {
   ~FakeMidiManagerClient() override = default;
 
   // MidiManagerClient implementation.
-  void AddInputPort(const MidiPortInfo& info) override {}
-  void AddOutputPort(const MidiPortInfo& info) override {}
+  void AddInputPort(const mojom::PortInfo& info) override {}
+  void AddOutputPort(const mojom::PortInfo& info) override {}
   void SetInputPortState(uint32_t port_index, PortState state) override {}
   void SetOutputPortState(uint32_t port_index, PortState state) override {}
   void CompleteStartSession(Result result) override {

media/midi/midi_manager_usb.cc

@@ -159,13 +159,13 @@ bool MidiManagerUsb::AddPorts(UsbMidiDevice* device, int device_id) {
     if (jacks[j].direction() == UsbMidiJack::DIRECTION_OUT) {
       output_streams_.push_back(
           std::make_unique<UsbMidiOutputStream>(jacks[j]));
-      AddOutputPort(MidiPortInfo(id, manufacturer, product_name, version,
-                                 PortState::OPENED));
+      AddOutputPort(mojom::PortInfo(id, manufacturer, product_name, version,
+                                    PortState::OPENED));
     } else {
       DCHECK_EQ(jacks[j].direction(), UsbMidiJack::DIRECTION_IN);
       input_stream_->Add(jacks[j]);
-      AddInputPort(MidiPortInfo(id, manufacturer, product_name, version,
-                                PortState::OPENED));
+      AddInputPort(mojom::PortInfo(id, manufacturer, product_name, version,
+                                   PortState::OPENED));
     }
   }
   return true;

media/midi/midi_manager_usb_unittest.cc

@@ -103,11 +103,11 @@ class FakeMidiManagerClient : public MidiManagerClient {
         logger_(logger) {}
   ~FakeMidiManagerClient() override = default;
 
-  void AddInputPort(const MidiPortInfo& info) override {
+  void AddInputPort(const mojom::PortInfo& info) override {
     input_ports_.push_back(info);
   }
 
-  void AddOutputPort(const MidiPortInfo& info) override {
+  void AddOutputPort(const mojom::PortInfo& info) override {
     output_ports_.push_back(info);
   }
 
@@ -143,8 +143,8 @@ class FakeMidiManagerClient : public MidiManagerClient {
 
   bool complete_start_session_;
   Result result_;
-  MidiPortInfoList input_ports_;
-  MidiPortInfoList output_ports_;
+  std::vector<mojom::PortInfo> input_ports_;
+  std::vector<mojom::PortInfo> output_ports_;
 
  private:
   Logger* logger_;
@@ -260,8 +260,12 @@ class MidiManagerUsbTest : public ::testing::Test {
     }
   }
 
-  const MidiPortInfoList& input_ports() { return client_->input_ports_; }
-  const MidiPortInfoList& output_ports() { return client_->output_ports_; }
+  const std::vector<mojom::PortInfo>& input_ports() {
+    return client_->input_ports_;
+  }
+  const std::vector<mojom::PortInfo>& output_ports() {
+    return client_->output_ports_;
+  }
 
   MidiManagerUsb* manager() { return factory_->manager(); }
 

media/midi/midi_manager_win.cc

@@ -26,8 +26,8 @@
 #include "device/usb/usb_ids.h"
 #include "media/midi/message_util.h"
 #include "media/midi/midi_manager_winrt.h"
-#include "media/midi/midi_port_info.h"
 #include "media/midi/midi_service.h"
+#include "media/midi/midi_service.mojom.h"
 #include "media/midi/midi_switches.h"
 
 namespace midi {
@@ -293,7 +293,7 @@ class Port {
   size_t index() { return index_; }
   void set_device_id(uint32_t device_id) { device_id_ = device_id; }
   uint32_t device_id() { return device_id_; }
-  const MidiPortInfo& info() { return info_; }
+  const mojom::PortInfo& info() { return info_; }
 
   virtual bool Connect() {
     if (info_.state != mojom::PortState::DISCONNECTED)
@@ -323,7 +323,7 @@ class Port {
   const uint16_t product_id_;
   const uint32_t driver_version_;
   const std::string product_name_;
-  MidiPortInfo info_;
+  mojom::PortInfo info_;
 };  // class Port
 
 }  // namespace

media/midi/midi_manager_winrt.cc

@@ -560,8 +560,8 @@ class MidiManagerWinrt::MidiPortManager {
       std::string manufacturer = "Unknown", driver_version = "Unknown";
       GetDriverInfoFromDeviceId(dev_id, &manufacturer, &driver_version);
 
-      AddPort(MidiPortInfo(dev_id, manufacturer, port_names_[dev_id],
-                           driver_version, PortState::OPENED));
+      AddPort(mojom::PortInfo(dev_id, manufacturer, port_names_[dev_id],
+                              driver_version, PortState::OPENED));
 
       port = new MidiPort<InterfaceType>;
       port->index = static_cast<uint32_t>(port_ids_.size());
@@ -591,7 +591,7 @@ class MidiManagerWinrt::MidiPortManager {
   virtual void RemovePortEventHandlers(MidiPort<InterfaceType>* port) {}
 
   // Calls midi_manager_->Add{Input,Output}Port.
-  virtual void AddPort(MidiPortInfo info) = 0;
+  virtual void AddPort(mojom::PortInfo info) = 0;
 
   // Calls midi_manager_->Set{Input,Output}PortState.
   virtual void SetPortState(uint32_t port_index, PortState state) = 0;
@@ -710,7 +710,9 @@ class MidiManagerWinrt::MidiInPortManager final
     port->token_MessageReceived.value = kInvalidTokenValue;
   }
 
-  void AddPort(MidiPortInfo info) final { midi_manager_->AddInputPort(info); }
+  void AddPort(mojom::PortInfo info) final {
+    midi_manager_->AddInputPort(info);
+  }
 
   void SetPortState(uint32_t port_index, PortState state) final {
     midi_manager_->SetInputPortState(port_index, state);
@@ -742,7 +744,9 @@ class MidiManagerWinrt::MidiOutPortManager final
 
  private:
   // MidiPortManager overrides:
-  void AddPort(MidiPortInfo info) final { midi_manager_->AddOutputPort(info); }
+  void AddPort(mojom::PortInfo info) final {
+    midi_manager_->AddOutputPort(info);
+  }
 
   void SetPortState(uint32_t port_index, PortState state) final {
     midi_manager_->SetOutputPortState(port_index, state);

media/midi/midi_port_info.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_port_info.h"
-
-namespace midi {
-
-using mojom::PortState;
-
-MidiPortInfo::MidiPortInfo() = default;
-
-MidiPortInfo::MidiPortInfo(const std::string& in_id,
-                           const std::string& in_manufacturer,
-                           const std::string& in_name,
-                           const std::string& in_version,
-                           PortState in_state)
-    : id(in_id),
-      manufacturer(in_manufacturer),
-      name(in_name),
-      version(in_version),
-      state(in_state) {}
-
-MidiPortInfo::~MidiPortInfo() = default;
-
-MidiPortInfo::MidiPortInfo(const MidiPortInfo& info) = default;
-
-}  // namespace midi

media/midi/midi_port_info.h

-// 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.
-
-#ifndef MEDIA_MIDI_MIDI_PORT_INFO_H_
-#define MEDIA_MIDI_MIDI_PORT_INFO_H_
-
-#include <string>
-#include <vector>
-
-#include "media/midi/midi_export.h"
-#include "media/midi/midi_service.mojom.h"
-
-namespace midi {
-
-struct MIDI_EXPORT MidiPortInfo final {
-  MidiPortInfo();
-  MidiPortInfo(const std::string& in_id,
-               const std::string& in_manufacturer,
-               const std::string& in_name,
-               const std::string& in_version,
-               mojom::PortState in_state);
-
-  MidiPortInfo(const MidiPortInfo& info);
-  ~MidiPortInfo();
-
-  std::string id;
-  std::string manufacturer;
-  std::string name;
-  std::string version;
-  mojom::PortState state;
-};
-
-using MidiPortInfoList = std::vector<MidiPortInfo>;
-
-}  // namespace midi
-
-#endif  // MEDIA_MIDI_MIDI_PORT_INFO_H_

media/midi/midi_service.mojom

@@ -31,6 +31,13 @@ enum PortState {
   LAST = OPENED,
 };
 
-// TODO(toyoshim): MidiPortInfo, and MidiService should be
-// declared here.
+struct PortInfo {
+  string id;
+  string manufacturer;
+  string name;
+  string version;
+  PortState state;
+};
+
+// TODO(toyoshim): MidiService should be declared here.
 // http://crbug.com/582327