Web MIDI: distributes MIDIPort information asynchronously

media/midi/midi_manager.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_manager.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 59 matching lines @@
     // CompleteInitialization() will be called asynchronously when platform
     // dependent initialization is finished.
     return;
   }
 
   // Platform dependent initialization was already finished for previously
   // initialized clients.
   MidiResult result;
   {
     base::AutoLock auto_lock(lock_);
-    if (result_ == MIDI_OK)
+    if (result_ == MIDI_OK) {
+      AddInitialPorts(client);
       clients_.insert(client);
+    }
     result = result_;
   }
   client->CompleteStartSession(result);
 }
 
 void MidiManager::EndSession(MidiManagerClient* client) {
   // At this point, |client| can be in the destruction process, and calling
   // any method of |client| is dangerous.
   base::AutoLock auto_lock(lock_);
   clients_.erase(client);
@@ skipping 16 matching lines @@
   // It is safe to post a task to the IO thread from here because the IO thread
   // should have stopped if the MidiManager is going to be destructed.
   session_thread_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MidiManager::CompleteInitializationInternal,
                  base::Unretained(this),
                  result));
 }
 
 void MidiManager::AddInputPort(const MidiPortInfo& info) {
+  base::AutoLock auto_lock(lock_);
   input_ports_.push_back(info);
+  for (auto client : clients_)
+    client->AddInputPort(info);
 }
 
 void MidiManager::AddOutputPort(const MidiPortInfo& info) {
+  base::AutoLock auto_lock(lock_);
   output_ports_.push_back(info);
+  for (auto client : clients_)
+    client->AddOutputPort(info);
 }
 
 void MidiManager::ReceiveMidiData(
     uint32 port_index,
     const uint8* data,
     size_t length,
     double timestamp) {
   base::AutoLock auto_lock(lock_);
 
-  for (MidiManagerClient* client : clients_)
+  for (auto client : clients_)
     client->ReceiveMidiData(port_index, data, length, timestamp);
 }
 
 void MidiManager::CompleteInitializationInternal(MidiResult result) {
   TRACE_EVENT0("midi", "MidiManager::CompleteInitialization");
 
   base::AutoLock auto_lock(lock_);
   DCHECK(clients_.empty());
   DCHECK(!initialized_);
   initialized_ = true;
   result_ = result;
 
-  for (MidiManagerClient* client : pending_clients_) {
-    if (result_ == MIDI_OK)
+  for (auto client : pending_clients_) {
+    if (result_ == MIDI_OK) {
+      AddInitialPorts(client);
       clients_.insert(client);
+    }
     client->CompleteStartSession(result_);
   }
   pending_clients_.clear();
 }
 
+void MidiManager::AddInitialPorts(MidiManagerClient* client) {
+  lock_.AssertAcquired();
+
+  for (const auto& info : input_ports_)
+    client->AddInputPort(info);
+  for (const auto& info : output_ports_)
+    client->AddOutputPort(info);
+}
+
 }  // namespace media