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

content/renderer/media/midi_message_filter.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/renderer/media/midi_message_filter.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 135 matching lines @@
   // will be very few clients (usually one).  Additionally, this lookup
   // usually happens one time during page load. So the performance hit is
   // negligible.
   for (ClientsMap::iterator i = clients_.begin(); i != clients_.end(); ++i) {
     if ((*i).second == client_id)
       return (*i).first;
   }
   return NULL;
 }
 
-void MIDIMessageFilter::OnDataReceived(int port,
+void MIDIMessageFilter::OnDataReceived(uint32 port,
                                        const std::vector<uint8>& data,
                                        double timestamp) {
   TRACE_EVENT0("midi", "MIDIMessageFilter::OnDataReceived");
 
   main_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&MIDIMessageFilter::HandleDataReceived, this,
                  port, data, timestamp));
 }
 
 void MIDIMessageFilter::OnAcknowledgeSentData(size_t bytes_sent) {
   DCHECK_GE(unacknowledged_bytes_sent_, bytes_sent);
   if (unacknowledged_bytes_sent_ >= bytes_sent)
     unacknowledged_bytes_sent_ -= bytes_sent;
 }
 
-void MIDIMessageFilter::HandleDataReceived(int port,
+void MIDIMessageFilter::HandleDataReceived(uint32 port,
                                            const std::vector<uint8>& data,
                                            double timestamp) {
   TRACE_EVENT0("midi", "MIDIMessageFilter::HandleDataReceived");
 
 #if defined(OS_ANDROID)
   // TODO(crogers): figure out why data() method does not compile on Android.
   NOTIMPLEMENTED();
 #else
   for (ClientsMap::iterator i = clients_.begin(); i != clients_.end(); ++i)
     (*i).first->didReceiveMIDIData(port, data.data(), data.size(), timestamp);
 #endif
 }
 
-void MIDIMessageFilter::SendMIDIData(int port,
+void MIDIMessageFilter::SendMIDIData(uint32 port,
                                      const uint8* data,
                                      size_t length,
                                      double timestamp) {
   if (length > kMaxUnacknowledgedBytesSent) {
     // TODO(crogers): buffer up the data to send at a later time.
     // For now we're just dropping these bytes on the floor.
     return;
   }
 
   std::vector<uint8> v(data, data + length);
   io_message_loop_->PostTask(FROM_HERE,
       base::Bind(&MIDIMessageFilter::SendMIDIDataOnIOThread, this,
                  port, v, timestamp));
 }
 
-void MIDIMessageFilter::SendMIDIDataOnIOThread(int port,
+void MIDIMessageFilter::SendMIDIDataOnIOThread(uint32 port,
                                                const std::vector<uint8>& data,
                                                double timestamp) {
   size_t n = data.size();
   if (n > kMaxUnacknowledgedBytesSent ||
       unacknowledged_bytes_sent_ > kMaxUnacknowledgedBytesSent ||
       n + unacknowledged_bytes_sent_ > kMaxUnacknowledgedBytesSent) {
     // TODO(crogers): buffer up the data to send at a later time.
     // For now we're just dropping these bytes on the floor.
     return;
   }
 
   unacknowledged_bytes_sent_ += n;
 
   // Send to the browser.
   Send(new MIDIHostMsg_SendData(port, data, timestamp));
 }
 
 }  // namespace content