Web MIDI: fix multi-threading problem around message buffer handling

content/browser/renderer_host/media/midi_host.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 "content/browser/renderer_host/media/midi_host.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/process/process.h"
@@ skipping 70 matching lines @@
     }
   }
 
   Send(new MIDIMsg_SessionStarted(
        client_id,
        success,
        input_ports,
        output_ports));
 }
 
-void MIDIHost::OnSendData(int port,
+void MIDIHost::OnSendData(uint32 port,
                           const std::vector<uint8>& data,
                           double timestamp) {
   if (!midi_manager_)
     return;
 
   if (data.empty())
     return;
 
   base::AutoLock auto_lock(in_flight_lock_);
 
   // Sanity check that we won't send too much.
   if (sent_bytes_in_flight_ > kMaxInFlightBytes ||
       data.size() > kMaxInFlightBytes ||
       data.size() + sent_bytes_in_flight_ > kMaxInFlightBytes)
     return;
 
   // For now disallow all System Exclusive messages even if we
   // have permission.
   // TODO(toyoshim): allow System Exclusive if browser has granted
   // this client access.  We'll likely need to pass a GURL
   // here to compare against our permissions.
   if (data[0] >= kSysExMessage)
-      return;
+    return;
 
   midi_manager_->DispatchSendMIDIData(
       this,
       port,
-      &data[0],
-      data.size(),
+      data,
       timestamp);
 
   sent_bytes_in_flight_ += data.size();
 }
 
 void MIDIHost::ReceiveMIDIData(
-    int port_index,
+    uint32 port,
     const uint8* data,
     size_t length,
     double timestamp) {
   TRACE_EVENT0("midi", "MIDIHost::ReceiveMIDIData");
 
   // For now disallow all System Exclusive messages even if we
   // have permission.
   // TODO(toyoshim): allow System Exclusive if browser has granted
   // this client access.  We'll likely need to pass a GURL
   // here to compare against our permissions.
   if (length > 0 && data[0] >= kSysExMessage)
       return;
 
   // Send to the renderer.
   std::vector<uint8> v(data, data + length);
-  Send(new MIDIMsg_DataReceived(port_index, v, timestamp));
+  Send(new MIDIMsg_DataReceived(port, v, timestamp));
 }
 
 void MIDIHost::AccumulateMIDIBytesSent(size_t n) {
   {
     base::AutoLock auto_lock(in_flight_lock_);
     if (n <= sent_bytes_in_flight_)
       sent_bytes_in_flight_ -= n;
   }
 
   if (bytes_sent_since_last_acknowledgement_ + n >=
       bytes_sent_since_last_acknowledgement_)
     bytes_sent_since_last_acknowledgement_ += n;
 
   if (bytes_sent_since_last_acknowledgement_ >=
       kAcknowledgementThresholdBytes) {
     Send(new MIDIMsg_AcknowledgeSentData(
         bytes_sent_since_last_acknowledgement_));
     bytes_sent_since_last_acknowledgement_ = 0;
   }
 }
 
 }  // namespace content