media/midi/midi_manager.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/midi/midi_manager.h"
   6
   7 #include "base/bind.h"
   8 #include "base/debug/trace_event.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/message_loop/message_loop_proxy.h"
  11
  12 namespace media {
  13
  14 MidiManager::MidiManager()
  15     : initialized_(false),
  16       result_(MIDI_NOT_SUPPORTED) {
  17 }
  18
  19 MidiManager::~MidiManager() {
  20 }
  21
  22 #if !defined(OS_MACOSX) && !defined(OS_WIN) && !defined(USE_ALSA) && \
  23     !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
  24 MidiManager* MidiManager::Create() {
  25   return new MidiManager;
  26 }
  27 #endif
  28
  29 void MidiManager::StartSession(MidiManagerClient* client, int client_id) {
  30   bool session_is_ready;
  31   bool session_needs_initialization = false;
  32   bool too_many_pending_clients_exist = false;
  33
  34   {
  35     base::AutoLock auto_lock(lock_);
  36     session_is_ready = initialized_;
  37     if (!session_is_ready) {
  38       // Do not accept a new request if the pending client list contains too
  39       // many clients.
  40       too_many_pending_clients_exist =
  41           pending_clients_.size() >= kMaxPendingClientCount;
  42
  43       if (!too_many_pending_clients_exist) {
  44         // Call StartInitialization() only for the first request.
  45         session_needs_initialization = pending_clients_.empty();
  46         pending_clients_.insert(
  47             std::pair<int, MidiManagerClient*>(client_id, client));
  48       }
  49     }
  50   }
  51
  52   // Lazily initialize the MIDI back-end.
  53   if (!session_is_ready) {
  54     if (session_needs_initialization) {
  55       TRACE_EVENT0("midi", "MidiManager::StartInitialization");
  56       session_thread_runner_ =
  57           base::MessageLoop::current()->message_loop_proxy();
  58       StartInitialization();
  59     }
  60     if (too_many_pending_clients_exist) {
  61       // Return an error immediately if there are too many requests.
  62       client->CompleteStartSession(client_id, MIDI_INITIALIZATION_ERROR);
  63       return;
  64     }
  65     // CompleteInitialization() will be called asynchronously when platform
  66     // dependent initialization is finished.
  67     return;
  68   }
  69
  70   // Platform dependent initialization was already finished for previously
  71   // initialized clients.
  72   MidiResult result;
  73   {
  74     base::AutoLock auto_lock(lock_);
  75     if (result_ == MIDI_OK)
  76       clients_.insert(client);
  77     result = result_;
  78   }
  79   client->CompleteStartSession(client_id, result);
  80 }
  81
  82 void MidiManager::EndSession(MidiManagerClient* client) {
  83   base::AutoLock auto_lock(lock_);
  84   ClientList::iterator i = clients_.find(client);
  85   if (i != clients_.end())
  86     clients_.erase(i);
  87 }
  88
  89 void MidiManager::DispatchSendMidiData(MidiManagerClient* client,
  90                                        uint32 port_index,
  91                                        const std::vector<uint8>& data,
  92                                        double timestamp) {
  93   NOTREACHED();
  94 }
  95
  96 void MidiManager::StartInitialization() {
  97   CompleteInitialization(MIDI_NOT_SUPPORTED);
  98 }
  99
 100 void MidiManager::CompleteInitialization(MidiResult result) {
 101   DCHECK(session_thread_runner_.get());
 102   // It is safe to post a task to the IO thread from here because the IO thread
 103   // should have stopped if the MidiManager is going to be destructed.
 104   session_thread_runner_->PostTask(
 105       FROM_HERE,
 106       base::Bind(&MidiManager::CompleteInitializationInternal,
 107                  base::Unretained(this),
 108                  result));
 109 }
 110
 111 void MidiManager::AddInputPort(const MidiPortInfo& info) {
 112   input_ports_.push_back(info);
 113 }
 114
 115 void MidiManager::AddOutputPort(const MidiPortInfo& info) {
 116   output_ports_.push_back(info);
 117 }
 118
 119 void MidiManager::ReceiveMidiData(
 120     uint32 port_index,
 121     const uint8* data,
 122     size_t length,
 123     double timestamp) {
 124   base::AutoLock auto_lock(lock_);
 125
 126   for (ClientList::iterator i = clients_.begin(); i != clients_.end(); ++i)
 127     (*i)->ReceiveMidiData(port_index, data, length, timestamp);
 128 }
 129
 130 void MidiManager::CompleteInitializationInternal(MidiResult result) {
 131   TRACE_EVENT0("midi", "MidiManager::CompleteInitialization");
 132
 133   base::AutoLock auto_lock(lock_);
 134   DCHECK(clients_.empty());
 135   DCHECK(!pending_clients_.empty());
 136   DCHECK(!initialized_);
 137   initialized_ = true;
 138   result_ = result;
 139
 140   for (PendingClientMap::iterator it = pending_clients_.begin();
 141        it != pending_clients_.end();
 142        ++it) {
 143     if (result_ == MIDI_OK)
 144       clients_.insert(it->second);
 145     it->second->CompleteStartSession(it->first, result_);
 146   }
 147   pending_clients_.clear();
 148 }
 149
 150 }  // namespace media