Update Chromium to branch 1650 (31.0.1650.63)

Change-Id: I57d8c832eaec1eb2364e0a8e7352a6dd354db99f
Reviewed-by: Jocelyn Turcotte <jocelyn.turcotte@digia.com>

4 files changed, 47 insertions, 43 deletions

diff --git a/chromium/media/midi/midi_manager.cc b/chromium/media/midi/midi_manager.cc
index 05fcfa45a96..b3262e4a034 100644
--- a/chromium/media/midi/midi_manager.cc
+++ b/chromium/media/midi/midi_manager.cc
@@ -6,6 +6,7 @@
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/message_loop/message_loop.h"
 #include "base/threading/thread.h"
 
 namespace media {
@@ -52,7 +53,7 @@ void MIDIManager::AddOutputPort(const MIDIPortInfo& info) {
 }
 
 void MIDIManager::ReceiveMIDIData(
-    int port_index,
+    uint32 port_index,
     const uint8* data,
     size_t length,
     double timestamp) {
@@ -62,10 +63,13 @@ void MIDIManager::ReceiveMIDIData(
     (*i)->ReceiveMIDIData(port_index, data, length, timestamp);
 }
 
+bool MIDIManager::CurrentlyOnMIDISendThread() {
+  return send_thread_->message_loop() == base::MessageLoop::current();
+}
+
 void MIDIManager::DispatchSendMIDIData(MIDIManagerClient* client,
-                                       int port_index,
-                                       const uint8* data,
-                                       size_t length,
+                                       uint32 port_index,
+                                       const std::vector<uint8>& data,
                                        double timestamp) {
   // Lazily create the thread when first needed.
   if (!send_thread_) {
@@ -77,7 +81,7 @@ void MIDIManager::DispatchSendMIDIData(MIDIManagerClient* client,
   send_message_loop_->PostTask(
      FROM_HERE,
      base::Bind(&MIDIManager::SendMIDIData, base::Unretained(this),
-         client, port_index, data, length, timestamp));
+         client, port_index, data, timestamp));
 }
 
 }  // namespace media
diff --git a/chromium/media/midi/midi_manager.h b/chromium/media/midi/midi_manager.h
index c2b26ab1b13..6a301a942d9 100644
--- a/chromium/media/midi/midi_manager.h
+++ b/chromium/media/midi/midi_manager.h
@@ -6,6 +6,7 @@
 #define MEDIA_MIDI_MIDI_MANAGER_H_
 
 #include <set>
+#include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
@@ -33,7 +34,7 @@ class MEDIA_EXPORT MIDIManagerClient {
   // |data| represents a series of bytes encoding one or more MIDI messages.
   // |length| is the number of bytes in |data|.
   // |timestamp| is the time the data was received, in seconds.
-  virtual void ReceiveMIDIData(int port_index,
+  virtual void ReceiveMIDIData(uint32 port_index,
                                const uint8* data,
                                size_t length,
                                double timestamp) = 0;
@@ -70,9 +71,8 @@ class MEDIA_EXPORT MIDIManager {
   // |timestamp| is the time to send the data, in seconds. A value of 0
   // means send "now" or as soon as possible.
   void DispatchSendMIDIData(MIDIManagerClient* client,
-                            int port_index,
-                            const uint8* data,
-                            size_t length,
+                            uint32 port_index,
+                            const std::vector<uint8>& data,
                             double timestamp);
 
   // input_ports() is a list of MIDI ports for receiving MIDI data.
@@ -90,21 +90,23 @@ class MEDIA_EXPORT MIDIManager {
   virtual bool Initialize() = 0;
 
   // Implements the platform-specific details of sending MIDI data.
+  // This function runs on MIDISendThread.
   virtual void SendMIDIData(MIDIManagerClient* client,
-                            int port_index,
-                            const uint8* data,
-                            size_t length,
+                            uint32 port_index,
+                            const std::vector<uint8>& data,
                             double timestamp) = 0;
 
   void AddInputPort(const MIDIPortInfo& info);
   void AddOutputPort(const MIDIPortInfo& info);
 
   // Dispatches to all clients.
-  void ReceiveMIDIData(
-      int port_index,
-      const uint8* data,
-      size_t length,
-      double timestamp);
+  void ReceiveMIDIData(uint32 port_index,
+                       const uint8* data,
+                       size_t length,
+                       double timestamp);
+
+  // Checks if current thread is MIDISendThread.
+  bool CurrentlyOnMIDISendThread();
 
   bool initialized_;
 
diff --git a/chromium/media/midi/midi_manager_mac.cc b/chromium/media/midi/midi_manager_mac.cc
index d766bdb6c5f..4477944e773 100644
--- a/chromium/media/midi/midi_manager_mac.cc
+++ b/chromium/media/midi/midi_manager_mac.cc
@@ -54,7 +54,7 @@ bool MIDIManagerMac::Initialize() {
   result = MIDIInputPortCreate(
       midi_client_,
       CFSTR("MIDI Input"),
-      ReadMidiDispatch,
+      ReadMIDIDispatch,
       this,
       &coremidi_input_);
   if (result != noErr)
@@ -67,10 +67,10 @@ bool MIDIManagerMac::Initialize() {
   if (result != noErr)
     return false;
 
-  int destination_count = MIDIGetNumberOfDestinations();
-  destinations_.reserve(destination_count);
+  uint32 destination_count = MIDIGetNumberOfDestinations();
+  destinations_.resize(destination_count);
 
-  for (int i = 0; i < destination_count ; i++) {
+  for (uint32 i = 0; i < destination_count ; i++) {
     MIDIEndpointRef destination = MIDIGetDestination(i);
 
     // Keep track of all destinations (known as outputs by the Web MIDI API).
@@ -82,9 +82,9 @@ bool MIDIManagerMac::Initialize() {
   }
 
   // Open connections from all sources.
-  int source_count = MIDIGetNumberOfSources();
+  uint32 source_count = MIDIGetNumberOfSources();
 
-  for (int i = 0; i < source_count; ++i)  {
+  for (uint32 i = 0; i < source_count; ++i)  {
     // Receive from all sources.
     MIDIEndpointRef src = MIDIGetSource(i);
     MIDIPortConnectSource(coremidi_input_, src, reinterpret_cast<void*>(src));
@@ -110,7 +110,7 @@ MIDIManagerMac::~MIDIManagerMac() {
     MIDIPortDispose(coremidi_output_);
 }
 
-void MIDIManagerMac::ReadMidiDispatch(const MIDIPacketList* packet_list,
+void MIDIManagerMac::ReadMIDIDispatch(const MIDIPacketList* packet_list,
                                       void* read_proc_refcon,
                                       void* src_conn_refcon) {
   MIDIManagerMac* manager = static_cast<MIDIManagerMac*>(read_proc_refcon);
@@ -121,16 +121,16 @@ void MIDIManagerMac::ReadMidiDispatch(const MIDIPacketList* packet_list,
 #endif
 
   // Dispatch to class method.
-  manager->ReadMidi(source, packet_list);
+  manager->ReadMIDI(source, packet_list);
 }
 
-void MIDIManagerMac::ReadMidi(MIDIEndpointRef source,
+void MIDIManagerMac::ReadMIDI(MIDIEndpointRef source,
                               const MIDIPacketList* packet_list) {
   // Lookup the port index based on the source.
   SourceMap::iterator j = source_map_.find(source);
   if (j == source_map_.end())
     return;
-  int port_index = source_map_[source];
+  uint32 port_index = source_map_[source];
 
   // Go through each packet and process separately.
   for(size_t i = 0; i < packet_list->numPackets; i++) {
@@ -147,10 +147,11 @@ void MIDIManagerMac::ReadMidi(MIDIEndpointRef source,
 }
 
 void MIDIManagerMac::SendMIDIData(MIDIManagerClient* client,
-                                  int port_index,
-                                  const uint8* data,
-                                  size_t length,
+                                  uint32 port_index,
+                                  const std::vector<uint8>& data,
                                   double timestamp) {
+  DCHECK(CurrentlyOnMIDISendThread());
+
   // System Exclusive has already been filtered.
   MIDITimeStamp coremidi_timestamp = SecondsToMIDITimeStamp(timestamp);
 
@@ -159,14 +160,11 @@ void MIDIManagerMac::SendMIDIData(MIDIManagerClient* client,
       kMaxPacketListSize,
       midi_packet_,
       coremidi_timestamp,
-      length,
-      data);
+      data.size(),
+      &data[0]);
 
   // Lookup the destination based on the port index.
-  // TODO(crogers): re-factor |port_index| to use unsigned
-  // to avoid the need for this check.
-  if (port_index < 0 ||
-      static_cast<size_t>(port_index) >= destinations_.size())
+  if (static_cast<size_t>(port_index) >= destinations_.size())
     return;
 
   MIDIEndpointRef destination = destinations_[port_index];
@@ -176,7 +174,7 @@ void MIDIManagerMac::SendMIDIData(MIDIManagerClient* client,
   // Re-initialize for next time.
   midi_packet_ = MIDIPacketListInit(packet_list_);
 
-  client->AccumulateMIDIBytesSent(length);
+  client->AccumulateMIDIBytesSent(data.size());
 }
 
 MIDIPortInfo MIDIManagerMac::GetPortInfoFromEndpoint(
diff --git a/chromium/media/midi/midi_manager_mac.h b/chromium/media/midi/midi_manager_mac.h
index ed7b524f5c4..2397b8034f7 100644
--- a/chromium/media/midi/midi_manager_mac.h
+++ b/chromium/media/midi/midi_manager_mac.h
@@ -8,6 +8,7 @@
 #include <CoreMIDI/MIDIServices.h>
 #include <map>
 #include <string>
+#include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ -24,20 +25,19 @@ class MEDIA_EXPORT MIDIManagerMac : public MIDIManager {
   // MIDIManager implementation.
   virtual bool Initialize() OVERRIDE;
   virtual void SendMIDIData(MIDIManagerClient* client,
-                            int port_index,
-                            const uint8* data,
-                            size_t length,
+                            uint32 port_index,
+                            const std::vector<uint8>& data,
                             double timestamp) OVERRIDE;
 
  private:
   // CoreMIDI callback for MIDI data.
   // Each callback can contain multiple packets, each of which can contain
   // multiple MIDI messages.
-  static void ReadMidiDispatch(
+  static void ReadMIDIDispatch(
       const MIDIPacketList *pktlist,
       void *read_proc_refcon,
       void *src_conn_refcon);
-  virtual void ReadMidi(MIDIEndpointRef source, const MIDIPacketList *pktlist);
+  virtual void ReadMIDI(MIDIEndpointRef source, const MIDIPacketList *pktlist);
 
   // Helper
   static media::MIDIPortInfo GetPortInfoFromEndpoint(MIDIEndpointRef endpoint);
@@ -54,7 +54,7 @@ class MEDIA_EXPORT MIDIManagerMac : public MIDIManager {
   MIDIPacketList* packet_list_;
   MIDIPacket* midi_packet_;
 
-  typedef std::map<MIDIEndpointRef, int> SourceMap;
+  typedef std::map<MIDIEndpointRef, uint32> SourceMap;
 
   // Keeps track of the index (0-based) for each of our sources.
   SourceMap source_map_;