//media/midi: use top level namespace midi rather than media.midi

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"
@@ skipping 10 matching lines @@
 // 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_(media::midi::Result::NOT_INITIALIZED),
+      session_result_(midi::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_ != media::midi::Result::NOT_INITIALIZED) {
+  if (session_result_ != midi::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_ = media::midi::Result::NOT_INITIALIZED;
+    session_result_ = midi::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(media::midi::Result result) {
+void MidiMessageFilter::OnSessionStarted(midi::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(media::midi::MidiPortInfo info) {
+void MidiMessageFilter::OnAddInputPort(midi::MidiPortInfo info) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MidiMessageFilter::HandleAddInputPort, this, info));
 }
 
-void MidiMessageFilter::OnAddOutputPort(media::midi::MidiPortInfo 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,
-                                            media::midi::MidiPortState state) {
+                                            midi::MidiPortState 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,
-                                             media::midi::MidiPortState state) {
+                                             midi::MidiPortState 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");
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   // Handle on the main JS thread.
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MidiMessageFilter::HandleDataReceived, this, port,
                             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(media::midi::Result result) {
+void MidiMessageFilter::HandleClientAdded(midi::Result result) {
   TRACE_EVENT0("midi", "MidiMessageFilter::HandleClientAdded");
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   session_result_ = result;
   std::string error;
   std::string message;
   switch (result) {
-    case media::midi::Result::OK:
+    case midi::Result::OK:
       break;
-    case media::midi::Result::NOT_SUPPORTED:
+    case midi::Result::NOT_SUPPORTED:
       error = "NotSupportedError";
       break;
-    case media::midi::Result::INITIALIZATION_ERROR:
+    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 == media::midi::Result::OK) {
+    if (result == midi::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 == media::midi::Result::OK, error16,
+    client->didStartSession(result == midi::Result::OK, error16,
                             message16);
     clients_.insert(client);
   }
 }
 
-void MidiMessageFilter::HandleAddInputPort(media::midi::MidiPortInfo info) {
+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);
   for (auto* client : clients_)
     client->didAddInputPort(id, manufacturer, name, version, state);
 }
 
-void MidiMessageFilter::HandleAddOutputPort(media::midi::MidiPortInfo info) {
+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);
   for (auto* client : clients_)
     client->didAddOutputPort(id, manufacturer, name, version, state);
@@ skipping 12 matching lines @@
 
 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,
-    media::midi::MidiPortState state) {
+    midi::MidiPortState 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,
-    media::midi::MidiPortState state) {
+    midi::MidiPortState state) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   outputs_[port].state = state;
   for (auto* client : clients_)
     client->didSetOutputPortState(port, ToBlinkState(state));
 }
 
 }  // namespace content