[WebMIDI] Introduce MidiManagerUsb

media/midi/midi_manager_usb.h

Index: media/midi/midi_manager_usb.h
diff --git a/media/midi/midi_manager_usb.h b/media/midi/midi_manager_usb.h
new file mode 100644
index 0000000000000000000000000000000000000000..1cc807ff99872624fb5b25a65bf7cfc523c180a2
--- /dev/null
+++ b/media/midi/midi_manager_usb.h
@@ -0,0 +1,82 @@
+// Copyright 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.
+
+#ifndef MEDIA_MIDI_MIDI_MANAGER_USB_H_
+#define MEDIA_MIDI_MIDI_MANAGER_USB_H_
+
+#include <utility>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/containers/hash_tables.h"
+#include "base/memory/scoped_ptr.h"
+#include "media/midi/midi_manager.h"
+#include "media/midi/usb_midi_device.h"
+#include "media/midi/usb_midi_input_stream.h"
+#include "media/midi/usb_midi_jack.h"
+#include "media/midi/usb_midi_output_stream.h"
+
+namespace media {
+
+class MIDIManagerUsb : public MIDIManager,

[Takashi Toyoshima, 2013/12/24 04:33:23]

Any reason to implement this as a MIDIManager subclass?
How will you use this class from MIDIManagerAndroid?

[yhirano, 2013/12/24 04:42:50]

We have two device dependent classes, UsbMidiDevice and UsbMidiDevice::Factory.
The next (and hopefully last) step is implement them for Android.
MIDIManager::Create will return a MIDIManagerUsb with
UsbMidiDeviceFactoryAndroid.

+                       public UsbMidiDeviceDelegate,
+                       public UsbMidiInputStream::Delegate {
+ public:
+  explicit MIDIManagerUsb(scoped_ptr<UsbMidiDevice::Factory> device_factory);
+  virtual ~MIDIManagerUsb();
+
+  // MIDIManager implementation.
+  virtual bool Initialize() OVERRIDE;
+  virtual void DispatchSendMIDIData(MIDIManagerClient* client,
+                                    uint32 port_index,
+                                    const std::vector<uint8>& data,
+                                    double timestamp) OVERRIDE;
+
+  // UsbMidiDeviceDelegate implementation.
+  virtual void ReceiveUsbMidiData(UsbMidiDevice* device,
+                                  int endpoint_number,
+                                  const uint8* data,
+                                  size_t size,
+                                  double timestamp) OVERRIDE;
+
+  // UsbMidiInputStream::Delegate implementation.
+  virtual void OnReceivedData(size_t jack_index,
+                              const uint8* data,
+                              size_t size,
+                              double timestamp) OVERRIDE;
+
+  const ScopedVector<UsbMidiOutputStream>& output_streams() const {
+    return output_streams_;
+  }
+  const UsbMidiInputStream* input_stream() const { return input_stream_.get(); }
+
+  // Initializes this object.
+  // When the initialization finishes, |callback| will be called with the
+  // result.
+  // When this factory is destroyed during the operation, the operation
+  // will be canceled silently (i.e. |callback| will not be called).
+  void Initialize(base::Callback<void(bool result)> callback);
+
+ private:
+  static void OnRequestPermissionDone(bool result);
+  void OnEnumerateDevicesDone(bool result, UsbMidiDevice::Devices* devices);
+
+  scoped_ptr<UsbMidiDevice::Factory> device_factory_;
+  ScopedVector<UsbMidiDevice> devices_;
+  ScopedVector<UsbMidiOutputStream> output_streams_;
+  scoped_ptr<UsbMidiInputStream> input_stream_;
+
+  base::Callback<void(bool result)> initialize_callback_;
+
+  // A map from <endpoint_number, cable_number> to the index of input jacks.
+  base::hash_map<std::pair<int, int>, size_t> input_jack_dictionary_;
+
+  DISALLOW_COPY_AND_ASSIGN(MIDIManagerUsb);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_MIDI_MIDI_MANAGER_USB_H_