Make MidiManager::StartSession() asynchronous

Some operating systems need to initialize MidiManager asynchronously.
This change is the first step to make it asynchronous.

In this change, make StartSession() asynchronous. And in the next
change, let's make platform specific Initialize() asynchronous.

BUG=339746

Review URL: https://codereview.chromium.org/226123002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@263215 0039d316-1c4b-4281-b951-d872f2087c98

12 files changed, 63 insertions, 31 deletions

diff --git a/media/midi/midi_manager.cc b/media/midi/midi_manager.cc
index 77b764f..7384703 100644
--- a/media/midi/midi_manager.cc
+++ b/media/midi/midi_manager.cc
@@ -18,23 +18,26 @@ MidiManager* MidiManager::Create() {
 #endif
 
 MidiManager::MidiManager()
-    : initialized_(false) {
+    : initialized_(false),
+      result_(MIDI_NOT_SUPPORTED) {
 }
 
 MidiManager::~MidiManager() {
 }
 
-bool MidiManager::StartSession(MidiManagerClient* client) {
+void MidiManager::StartSession(MidiManagerClient* client, int client_id) {
   // Lazily initialize the MIDI back-end.
-  if (!initialized_)
-    initialized_ = Initialize();
+  if (!initialized_) {
+    initialized_ = true;
+    result_ = Initialize();
+  }
 
-  if (initialized_) {
+  if (result_ == MIDI_OK) {
     base::AutoLock auto_lock(clients_lock_);
     clients_.insert(client);
   }
-
-  return initialized_;
+  // TODO(toyoshim): Make Initialize() asynchronous.
+  client->CompleteStartSession(client_id, result_);
 }
 
 void MidiManager::EndSession(MidiManagerClient* client) {
@@ -51,9 +54,9 @@ void MidiManager::DispatchSendMidiData(MidiManagerClient* client,
   NOTREACHED();
 }
 
-bool MidiManager::Initialize() {
+MidiResult MidiManager::Initialize() {
   TRACE_EVENT0("midi", "MidiManager::Initialize");
-  return false;
+  return MIDI_NOT_SUPPORTED;
 }
 
 void MidiManager::AddInputPort(const MidiPortInfo& info) {
diff --git a/media/midi/midi_manager.h b/media/midi/midi_manager.h
index dd7828b..88c930b 100644
--- a/media/midi/midi_manager.h
+++ b/media/midi/midi_manager.h
@@ -12,6 +12,7 @@
 #include "base/synchronization/lock.h"
 #include "media/base/media_export.h"
 #include "media/midi/midi_port_info.h"
+#include "media/midi/midi_result.h"
 
 namespace media {
 
@@ -20,7 +21,11 @@ namespace media {
 // for details.
 class MEDIA_EXPORT MidiManagerClient {
  public:
-   virtual ~MidiManagerClient() {}
+  virtual ~MidiManagerClient() {}
+
+  // CompleteStartSession() is called when platform dependent preparation is
+  // finished.
+  virtual void CompleteStartSession(int client_id, MidiResult result) = 0;
 
   // ReceiveMidiData() is called when MIDI data has been received from the
   // MIDI system.
@@ -51,10 +56,11 @@ class MEDIA_EXPORT MidiManager {
   // A client calls StartSession() to receive and send MIDI data.
   // If the session is ready to start, the MIDI system is lazily initialized
   // and the client is registered to receive MIDI data.
-  // Returns |true| if the session succeeds to start.
-  bool StartSession(MidiManagerClient* client);
+  // CompleteStartSession() is called with MIDI_OK if the session is started.
+  // Otherwise CompleteStartSession() is called with proper MidiResult code.
+  void StartSession(MidiManagerClient* client, int client_id);
 
-  // A client calls ReleaseSession() to stop receiving MIDI data.
+  // A client calls EndSession() to stop receiving MIDI data.
   void EndSession(MidiManagerClient* client);
 
   // DispatchSendMidiData() is called when MIDI data should be sent to the MIDI
@@ -84,7 +90,7 @@ class MEDIA_EXPORT MidiManager {
  protected:
   // Initializes the MIDI system, returning |true| on success.
   // The default implementation is for unsupported platforms.
-  virtual bool Initialize();
+  virtual MidiResult Initialize();
 
   void AddInputPort(const MidiPortInfo& info);
   void AddOutputPort(const MidiPortInfo& info);
@@ -96,6 +102,7 @@ class MEDIA_EXPORT MidiManager {
                        double timestamp);
 
   bool initialized_;
+  MidiResult result_;
 
   // Keeps track of all clients who wish to receive MIDI data.
   typedef std::set<MidiManagerClient*> ClientList;
diff --git a/media/midi/midi_manager_alsa.cc b/media/midi/midi_manager_alsa.cc
index 8f580e1..eb79540 100644
--- a/media/midi/midi_manager_alsa.cc
+++ b/media/midi/midi_manager_alsa.cc
@@ -127,7 +127,7 @@ MidiManagerAlsa::MidiManagerAlsa()
     pipe_fd_[i] = -1;
 }
 
-bool MidiManagerAlsa::Initialize() {
+MidiResult MidiManagerAlsa::Initialize() {
   // TODO(toyoshim): Make Initialize() asynchronous.
   // See http://crbug.com/339746.
   TRACE_EVENT0("midi", "MidiManagerAlsa::Initialize");
@@ -188,14 +188,14 @@ bool MidiManagerAlsa::Initialize() {
 
   if (pipe(pipe_fd_) < 0) {
     VPLOG(1) << "pipe() failed";
-    return false;
+    return MIDI_INITIALIZATION_ERROR;
   }
   event_thread_.Start();
   event_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&MidiManagerAlsa::EventReset, base::Unretained(this)));
 
-  return true;
+  return MIDI_OK;
 }
 
 MidiManagerAlsa::~MidiManagerAlsa() {
diff --git a/media/midi/midi_manager_alsa.h b/media/midi/midi_manager_alsa.h
index d97650c..803496b 100644
--- a/media/midi/midi_manager_alsa.h
+++ b/media/midi/midi_manager_alsa.h
@@ -21,7 +21,7 @@ class MidiManagerAlsa : public MidiManager {
   virtual ~MidiManagerAlsa();
 
   // MidiManager implementation.
-  virtual bool Initialize() OVERRIDE;
+  virtual MidiResult Initialize() OVERRIDE;
   virtual void DispatchSendMidiData(MidiManagerClient* client,
                                     uint32 port_index,
                                     const std::vector<uint8>& data,
diff --git a/media/midi/midi_manager_mac.cc b/media/midi/midi_manager_mac.cc
index b172f86..0c9c869 100644
--- a/media/midi/midi_manager_mac.cc
+++ b/media/midi/midi_manager_mac.cc
@@ -36,7 +36,7 @@ MidiManagerMac::MidiManagerMac()
       send_thread_("MidiSendThread") {
 }
 
-bool MidiManagerMac::Initialize() {
+MidiResult MidiManagerMac::Initialize() {
   TRACE_EVENT0("midi", "MidiManagerMac::Initialize");
 
   // CoreMIDI registration.
@@ -48,7 +48,7 @@ bool MidiManagerMac::Initialize() {
       &midi_client_);
 
   if (result != noErr)
-    return false;
+    return MIDI_INITIALIZATION_ERROR;
 
   coremidi_input_ = 0;
 
@@ -60,14 +60,14 @@ bool MidiManagerMac::Initialize() {
       this,
       &coremidi_input_);
   if (result != noErr)
-    return false;
+    return MIDI_INITIALIZATION_ERROR;
 
   result = MIDIOutputPortCreate(
       midi_client_,
       CFSTR("MIDI Output"),
       &coremidi_output_);
   if (result != noErr)
-    return false;
+    return MIDI_INITIALIZATION_ERROR;
 
   uint32 destination_count = MIDIGetNumberOfDestinations();
   destinations_.resize(destination_count);
@@ -102,7 +102,7 @@ bool MidiManagerMac::Initialize() {
   packet_list_ = reinterpret_cast<MIDIPacketList*>(midi_buffer_);
   midi_packet_ = MIDIPacketListInit(packet_list_);
 
-  return true;
+  return MIDI_OK;
 }
 
 void MidiManagerMac::DispatchSendMidiData(MidiManagerClient* client,
diff --git a/media/midi/midi_manager_mac.h b/media/midi/midi_manager_mac.h
index 5b27837..5bd072d 100644
--- a/media/midi/midi_manager_mac.h
+++ b/media/midi/midi_manager_mac.h
@@ -24,7 +24,7 @@ class MEDIA_EXPORT MidiManagerMac : public MidiManager {
   virtual ~MidiManagerMac();
 
   // MidiManager implementation.
-  virtual bool Initialize() OVERRIDE;
+  virtual MidiResult Initialize() OVERRIDE;
   virtual void DispatchSendMidiData(MidiManagerClient* client,
                                     uint32 port_index,
                                     const std::vector<uint8>& data,
diff --git a/media/midi/midi_manager_usb.cc b/media/midi/midi_manager_usb.cc
index 844c621..0991f1d 100644
--- a/media/midi/midi_manager_usb.cc
+++ b/media/midi/midi_manager_usb.cc
@@ -34,10 +34,10 @@ MidiManagerUsb::MidiManagerUsb(scoped_ptr<UsbMidiDevice::Factory> factory)
 MidiManagerUsb::~MidiManagerUsb() {
 }
 
-bool MidiManagerUsb::Initialize() {
+MidiResult MidiManagerUsb::Initialize() {
   TRACE_EVENT0("midi", "MidiManagerUsb::Initialize");
   Initialize(base::Bind(Noop));
-  return true;
+  return MIDI_OK;
 }
 
 void MidiManagerUsb::Initialize(base::Callback<void(bool result)> callback) {
diff --git a/media/midi/midi_manager_usb.h b/media/midi/midi_manager_usb.h
index a08b986..bccc1b8 100644
--- a/media/midi/midi_manager_usb.h
+++ b/media/midi/midi_manager_usb.h
@@ -31,7 +31,7 @@ class MEDIA_EXPORT MidiManagerUsb : public MidiManager,
   virtual ~MidiManagerUsb();
 
   // MidiManager implementation.
-  virtual bool Initialize() OVERRIDE;
+  virtual MidiResult Initialize() OVERRIDE;
   virtual void DispatchSendMidiData(MidiManagerClient* client,
                                     uint32 port_index,
                                     const std::vector<uint8>& data,
diff --git a/media/midi/midi_manager_usb_unittest.cc b/media/midi/midi_manager_usb_unittest.cc
index 567b60c..2bfb85e 100644
--- a/media/midi/midi_manager_usb_unittest.cc
+++ b/media/midi/midi_manager_usb_unittest.cc
@@ -73,6 +73,9 @@ class FakeMidiManagerClient : public MidiManagerClient {
   explicit FakeMidiManagerClient(Logger* logger) : logger_(logger) {}
   virtual ~FakeMidiManagerClient() {}
 
+  virtual void CompleteStartSession(int client_id, MidiResult result) OVERRIDE {
+  }
+
   virtual void ReceiveMidiData(uint32 port_index,
                                const uint8* data,
                                size_t size,
@@ -300,7 +303,7 @@ TEST_F(MidiManagerUsbTest, Receive) {
   ASSERT_TRUE(initialize_callback_run_);
   ASSERT_TRUE(initialize_result_);
 
-  manager_->StartSession(&client);
+  manager_->StartSession(&client, 0);
   manager_->ReceiveUsbMidiData(device_raw, 2, data, arraysize(data), 0);
   manager_->EndSession(&client);
 
diff --git a/media/midi/midi_manager_win.cc b/media/midi/midi_manager_win.cc
index a2343f6..95d7379 100644
--- a/media/midi/midi_manager_win.cc
+++ b/media/midi/midi_manager_win.cc
@@ -501,7 +501,7 @@ MidiManagerWin::MidiManagerWin()
     : send_thread_("MidiSendThread") {
 }
 
-bool MidiManagerWin::Initialize() {
+MidiResult MidiManagerWin::Initialize() {
   TRACE_EVENT0("midi", "MidiManagerWin::Initialize");
   const UINT num_in_devices = midiInGetNumDevs();
   in_devices_.reserve(num_in_devices);
@@ -548,7 +548,7 @@ bool MidiManagerWin::Initialize() {
     out_devices_.push_back(out_port.Pass());
   }
 
-  return true;
+  return MIDI_OK;
 }
 
 MidiManagerWin::~MidiManagerWin() {
diff --git a/media/midi/midi_manager_win.h b/media/midi/midi_manager_win.h
index 8e1cc36..7b38ab4b 100644
--- a/media/midi/midi_manager_win.h
+++ b/media/midi/midi_manager_win.h
@@ -20,7 +20,7 @@ class MidiManagerWin : public MidiManager {
   virtual ~MidiManagerWin();
 
   // MidiManager implementation.
-  virtual bool Initialize() OVERRIDE;
+  virtual MidiResult Initialize() OVERRIDE;
   virtual void DispatchSendMidiData(MidiManagerClient* client,
                                     uint32 port_index,
                                     const std::vector<uint8>& data,
diff --git a/media/midi/midi_result.h b/media/midi/midi_result.h
new file mode 100644
index 0000000..99233c4
--- /dev/null
+++ b/media/midi/midi_result.h
@@ -0,0 +1,19 @@
+// Copyright 2014 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.
+
+#ifndef MEDIA_MIDI_MIDI_RESULT_H_
+#define MEDIA_MIDI_MIDI_RESULT_H_
+
+namespace media {
+
+// Result codes for MIDI.
+enum MidiResult {
+  MIDI_OK,
+  MIDI_NOT_SUPPORTED,
+  MIDI_INITIALIZATION_ERROR,
+};
+
+}  // namespace media
+
+#endif  // MEDIA_MIDI_MIDI_RESULT_H_