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

content/renderer/media/midi_message_filter.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 "content/renderer/media/midi_message_filter.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/media/midi_messages.h"
 #include "content/renderer/render_thread_impl.h"
 #include "ipc/ipc_logging.h"
 
 using base::AutoLock;
+using midi::mojom::PortState;
 using midi::mojom::Result;
 
 // The maximum number of bytes which we're allowed to send to the browser
 // before getting acknowledgement back from the browser that they've been
 // successfully sent.
 static const size_t kMaxUnacknowledgedBytesSent = 10 * 1024 * 1024;  // 10 MB.
 
 namespace content {
 
 MidiMessageFilter::MidiMessageFilter(
@@ skipping 130 matching lines @@
       base::Bind(&MidiMessageFilter::HandleAddInputPort, this, info));
 }
 
 void MidiMessageFilter::OnAddOutputPort(midi::MidiPortInfo info) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MidiMessageFilter::HandleAddOutputPort, this, info));
 }
 
-void MidiMessageFilter::OnSetInputPortState(uint32_t port,
-                                            midi::MidiPortState state) {
+void MidiMessageFilter::OnSetInputPortState(uint32_t port, PortState state) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MidiMessageFilter::HandleSetInputPortState, this,
                             port, state));
 }
 
-void MidiMessageFilter::OnSetOutputPortState(uint32_t port,
-                                             midi::MidiPortState state) {
+void MidiMessageFilter::OnSetOutputPortState(uint32_t port, PortState state) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MidiMessageFilter::HandleSetOutputPortState, this,
                             port, state));
 }
 
 void MidiMessageFilter::OnDataReceived(uint32_t port,
                                        const std::vector<uint8_t>& data,
                                        double timestamp) {
   TRACE_EVENT0("midi", "MidiMessageFilter::OnDataReceived");
@@ skipping 17 matching lines @@
   session_result_ = result;
 
   // A for-loop using iterators does not work because |client| may touch
   // |clients_waiting_session_queue_| in callbacks.
   while (!clients_waiting_session_queue_.empty()) {
     auto* client = clients_waiting_session_queue_.back();
     clients_waiting_session_queue_.pop_back();
     if (result == Result::OK) {
       // Add the client's input and output ports.
       for (const auto& info : inputs_) {
-        client->didAddInputPort(
-            base::UTF8ToUTF16(info.id),
-            base::UTF8ToUTF16(info.manufacturer),
-            base::UTF8ToUTF16(info.name),
-            base::UTF8ToUTF16(info.version),
-            ToBlinkState(info.state));
+        client->didAddInputPort(base::UTF8ToUTF16(info.id),
+                                base::UTF8ToUTF16(info.manufacturer),
+                                base::UTF8ToUTF16(info.name),
+                                base::UTF8ToUTF16(info.version),
+                                ToBlinkState(info.state));
       }
 
       for (const auto& info : outputs_) {
-        client->didAddOutputPort(
-            base::UTF8ToUTF16(info.id),
-            base::UTF8ToUTF16(info.manufacturer),
-            base::UTF8ToUTF16(info.name),
-            base::UTF8ToUTF16(info.version),
-            ToBlinkState(info.state));
+        client->didAddOutputPort(base::UTF8ToUTF16(info.id),
+                                 base::UTF8ToUTF16(info.manufacturer),
+                                 base::UTF8ToUTF16(info.name),
+                                 base::UTF8ToUTF16(info.version),
+                                 ToBlinkState(info.state));
       }
     }
     client->didStartSession(result);
     clients_.insert(client);
   }
 }
 
 void MidiMessageFilter::HandleAddInputPort(midi::MidiPortInfo info) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   inputs_.push_back(info);
   const base::string16 id = base::UTF8ToUTF16(info.id);
   const base::string16 manufacturer = base::UTF8ToUTF16(info.manufacturer);
   const base::string16 name = base::UTF8ToUTF16(info.name);
   const base::string16 version = base::UTF8ToUTF16(info.version);
-  const blink::WebMIDIAccessorClient::MIDIPortState state =
-      ToBlinkState(info.state);
+  const PortState state = ToBlinkState(info.state);
   for (auto* client : clients_)
     client->didAddInputPort(id, manufacturer, name, version, state);
 }
 
 void MidiMessageFilter::HandleAddOutputPort(midi::MidiPortInfo info) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   outputs_.push_back(info);
   const base::string16 id = base::UTF8ToUTF16(info.id);
   const base::string16 manufacturer = base::UTF8ToUTF16(info.manufacturer);
   const base::string16 name = base::UTF8ToUTF16(info.name);
   const base::string16 version = base::UTF8ToUTF16(info.version);
-  const blink::WebMIDIAccessorClient::MIDIPortState state =
-      ToBlinkState(info.state);
+  const PortState state = ToBlinkState(info.state);
   for (auto* client : clients_)
     client->didAddOutputPort(id, manufacturer, name, version, state);
 }
 
 void MidiMessageFilter::HandleDataReceived(uint32_t port,
                                            const std::vector<uint8_t>& data,
                                            double timestamp) {
   TRACE_EVENT0("midi", "MidiMessageFilter::HandleDataReceived");
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(!data.empty());
 
   for (auto* client : clients_)
     client->didReceiveMIDIData(port, &data[0], data.size(), timestamp);
 }
 
 void MidiMessageFilter::HandleAckknowledgeSentData(size_t bytes_sent) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_GE(unacknowledged_bytes_sent_, bytes_sent);
   if (unacknowledged_bytes_sent_ >= bytes_sent)
     unacknowledged_bytes_sent_ -= bytes_sent;
 }
 
-void MidiMessageFilter::HandleSetInputPortState(
-    uint32_t port,
-    midi::MidiPortState state) {
+void MidiMessageFilter::HandleSetInputPortState(uint32_t port,
+                                                PortState state) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   inputs_[port].state = state;
   for (auto* client : clients_)
     client->didSetInputPortState(port, ToBlinkState(state));
 }
 
-void MidiMessageFilter::HandleSetOutputPortState(
-    uint32_t port,
-    midi::MidiPortState state) {
+void MidiMessageFilter::HandleSetOutputPortState(uint32_t port,
+                                                 PortState state) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   outputs_[port].state = state;
   for (auto* client : clients_)
     client->didSetOutputPortState(port, ToBlinkState(state));
 }
 
 }  // namespace content