Web MIDI: add MidiScheduler for send() with timestamp

media/midi/midi_manager_usb.cc

 // 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.
 
 #include "media/midi/midi_manager_usb.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
+#include "media/midi/midi_scheduler.h"
 #include "media/midi/usb_midi_descriptor_parser.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 {
 
 MidiManagerUsb::MidiManagerUsb(scoped_ptr<UsbMidiDevice::Factory> factory)
     : device_factory_(factory.Pass()) {
 }
 
 MidiManagerUsb::~MidiManagerUsb() {
 }
 
 void MidiManagerUsb::StartInitialization() {
   Initialize(
       base::Bind(&MidiManager::CompleteInitialization, base::Unretained(this)));
 }
 
 void MidiManagerUsb::Initialize(
     base::Callback<void(MidiResult result)> callback) {
   initialize_callback_ = callback;
+  scheduler_.reset(new MidiScheduler);
   // This is safe because EnumerateDevices cancels the operation on destruction.
   device_factory_->EnumerateDevices(
       this,
       base::Bind(&MidiManagerUsb::OnEnumerateDevicesDone,
                  base::Unretained(this)));
 }
 
 void MidiManagerUsb::DispatchSendMidiData(MidiManagerClient* client,
                                           uint32_t port_index,
                                           const std::vector<uint8>& data,
                                           double timestamp) {
   if (port_index >= output_streams_.size()) {
     // |port_index| is provided by a renderer so we can't believe that it is
     // in the valid range.
     return;
   }
-  output_streams_[port_index]->Send(data);
-  client->AccumulateMidiBytesSent(data.size());
+  // output_streams_[port_index] is alive unless MidiManagerUsb is deleted.
+  // The task posted to the MidiScheduler will be disposed safely on deleting
+  // the scheduler.
+  scheduler_->PostSendDataTask(
+      client, data.size(), timestamp,
+      base::Bind(&UsbMidiOutputStream::Send,
+                 base::Unretained(output_streams_[port_index]), data));
 }
 
 void MidiManagerUsb::ReceiveUsbMidiData(UsbMidiDevice* device,
                                         int endpoint_number,
                                         const uint8* data,
                                         size_t size,
                                         base::TimeTicks time) {
   if (!input_stream_)
     return;
   input_stream_->OnReceivedData(device,
@@ skipping 87 matching lines @@
       port.id = base::StringPrintf("port-%d-%ld",
                                    device_id,
                                    static_cast<long>(j));
       AddInputPort(port);
     }
   }
   return true;
 }
 
 }  // namespace media