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

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::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(
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
     : sender_(nullptr),
       io_task_runner_(io_task_runner),
       main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      session_result_(midi::Result::NOT_INITIALIZED),
-      unacknowledged_bytes_sent_(0u) {
-}
+      session_result_(Result::NOT_INITIALIZED),
+      unacknowledged_bytes_sent_(0u) {}
 
 MidiMessageFilter::~MidiMessageFilter() {}
 
 void MidiMessageFilter::AddClient(blink::WebMIDIAccessorClient* client) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT0("midi", "MidiMessageFilter::AddClient");
   clients_waiting_session_queue_.push_back(client);
-  if (session_result_ != midi::Result::NOT_INITIALIZED) {
+  if (session_result_ != Result::NOT_INITIALIZED) {
     HandleClientAdded(session_result_);
   } else if (clients_waiting_session_queue_.size() == 1u) {
     io_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&MidiMessageFilter::StartSessionOnIOThread, this));
   }
 }
 
 void MidiMessageFilter::RemoveClient(blink::WebMIDIAccessorClient* client) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   clients_.erase(client);
   ClientsQueue::iterator it = std::find(clients_waiting_session_queue_.begin(),
                                         clients_waiting_session_queue_.end(),
                                         client);
   if (it != clients_waiting_session_queue_.end())
     clients_waiting_session_queue_.erase(it);
   if (clients_.empty() && clients_waiting_session_queue_.empty()) {
-    session_result_ = midi::Result::NOT_INITIALIZED;
+    session_result_ = Result::NOT_INITIALIZED;
     inputs_.clear();
     outputs_.clear();
     io_task_runner_->PostTask(
         FROM_HERE, base::Bind(&MidiMessageFilter::EndSessionOnIOThread, this));
   }
 }
 
 void MidiMessageFilter::SendMidiData(uint32_t port,
                                      const uint8_t* data,
                                      size_t length,
@@ skipping 65 matching lines @@
   // Once removed, a filter will not be used again.  At this time all
   // delegates must be notified so they release their reference.
   OnChannelClosing();
 }
 
 void MidiMessageFilter::OnChannelClosing() {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   sender_ = nullptr;
 }
 
-void MidiMessageFilter::OnSessionStarted(midi::Result result) {
+void MidiMessageFilter::OnSessionStarted(Result result) {
   TRACE_EVENT0("midi", "MidiMessageFilter::OnSessionStarted");
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   // Handle on the main JS thread.
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MidiMessageFilter::HandleClientAdded, this, result));
 }
 
 void MidiMessageFilter::OnAddInputPort(midi::MidiPortInfo info) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
@@ skipping 36 matching lines @@
                             data, timestamp));
 }
 
 void MidiMessageFilter::OnAcknowledgeSentData(size_t bytes_sent) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MidiMessageFilter::HandleAckknowledgeSentData,
                             this, bytes_sent));
 }
 
-void MidiMessageFilter::HandleClientAdded(midi::Result result) {
+void MidiMessageFilter::HandleClientAdded(Result result) {
   TRACE_EVENT0("midi", "MidiMessageFilter::HandleClientAdded");
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   session_result_ = result;
-  std::string error;
-  std::string message;
-  switch (result) {
-    case midi::Result::OK:
-      break;
-    case midi::Result::NOT_SUPPORTED:
-      error = "NotSupportedError";
-      break;
-    case midi::Result::INITIALIZATION_ERROR:
-      error = "InvalidStateError";
-      message = "Platform dependent initialization failed.";
-      break;
-    default:
-      NOTREACHED();
-      error = "InvalidStateError";
-      message = "Unknown internal error occurred.";
-      break;
-  }
-  base::string16 error16 = base::UTF8ToUTF16(error);
-  base::string16 message16 = base::UTF8ToUTF16(message);
 
   // 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 == midi::Result::OK) {
+    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));
       }
 
       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->didStartSession(result == midi::Result::OK, error16,
-                            message16);
+    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);
@@ skipping 47 matching lines @@
 void MidiMessageFilter::HandleSetOutputPortState(
     uint32_t port,
     midi::MidiPortState state) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   outputs_[port].state = state;
   for (auto* client : clients_)
     client->didSetOutputPortState(port, ToBlinkState(state));
 }
 
 }  // namespace content