Switch to standard integer types in media/.

media/midi/midi_manager_mac.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 "media/midi/midi_manager_mac.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 117 matching lines @@
   client_thread_.Stop();
 
   if (coremidi_input_)
     MIDIPortDispose(coremidi_input_);
   if (coremidi_output_)
     MIDIPortDispose(coremidi_output_);
   if (midi_client_)
     MIDIClientDispose(midi_client_);
 }
 
-
 void MidiManagerMac::DispatchSendMidiData(MidiManagerClient* client,
-                                          uint32 port_index,
-                                          const std::vector<uint8>& data,
+                                          uint32_t port_index,
+                                          const std::vector<uint8_t>& data,
                                           double timestamp) {
   RunOnClientThread(
       base::Bind(&MidiManagerMac::SendMidiData,
                  base::Unretained(this), client, port_index, data, timestamp));
 }
 
 void MidiManagerMac::RunOnClientThread(const base::Closure& closure) {
   if (shutdown_)
     return;
 
@@ skipping 28 matching lines @@
   DCHECK_EQ(0u, coremidi_output_);
   result = MIDIOutputPortCreate(
       midi_client_,
       CFSTR("MIDI Output"),
       &coremidi_output_);
   if (result != noErr || coremidi_output_ == 0)
     return CompleteInitialization(Result::INITIALIZATION_ERROR);
 
   // Following loop may miss some newly attached devices, but such device will
   // be captured by ReceiveMidiNotifyDispatch callback.
-  uint32 destination_count = MIDIGetNumberOfDestinations();
+  uint32_t destination_count = MIDIGetNumberOfDestinations();
   destinations_.resize(destination_count);
-  for (uint32 i = 0; i < destination_count ; i++) {
+  for (uint32_t i = 0; i < destination_count; i++) {
     MIDIEndpointRef destination = MIDIGetDestination(i);
     if (destination == 0) {
       // One ore more devices may be detached.
       destinations_.resize(i);
       break;
     }
 
     // Keep track of all destinations (known as outputs by the Web MIDI API).
     // Cache to avoid any possible overhead in calling MIDIGetDestination().
     destinations_[i] = destination;
 
     MidiPortInfo info = GetPortInfoFromEndpoint(destination);
     AddOutputPort(info);
   }
 
   // Open connections from all sources. This loop also may miss new devices.
-  uint32 source_count = MIDIGetNumberOfSources();
-  for (uint32 i = 0; i < source_count; ++i)  {
+  uint32_t source_count = MIDIGetNumberOfSources();
+  for (uint32_t i = 0; i < source_count; ++i) {
     // Receive from all sources.
     MIDIEndpointRef source = MIDIGetSource(i);
     if (source == 0)
       break;
 
     // Start listening.
     MIDIPortConnectSource(
         coremidi_input_, source, reinterpret_cast<void*>(source));
 
     // Keep track of all sources (known as inputs in Web MIDI API terminology).
@@ skipping 29 matching lines @@
     if (notification->childType == kMIDIObjectType_Source) {
       // Attaching device is an input device.
       auto it = source_map_.find(endpoint);
       if (it == source_map_.end()) {
         MidiPortInfo info = GetPortInfoFromEndpoint(endpoint);
         // If the device disappears before finishing queries, MidiPortInfo
         // becomes incomplete. Skip and do not cache such information here.
         // On kMIDIMsgObjectRemoved, the entry will be ignored because it
         // will not be found in the pool.
         if (!info.id.empty()) {
-          uint32 index = source_map_.size();
+          uint32_t index = source_map_.size();
           source_map_[endpoint] = index;
           AddInputPort(info);
           MIDIPortConnectSource(
               coremidi_input_, endpoint, reinterpret_cast<void*>(endpoint));
         }
       } else {
         SetInputPortState(it->second, MIDI_PORT_OPENED);
       }
     } else if (notification->childType == kMIDIObjectType_Destination) {
       // Attaching device is an output device.
@@ skipping 50 matching lines @@
                               const MIDIPacketList* packet_list) {
   // This method is called from ReadMidiDispatch() and runs on a separate
   // high-priority thread owned by CoreMIDI.
 
   // Lookup the port index based on the source.
   auto it = source_map_.find(source);
   if (it == source_map_.end())
     return;
   // This is safe since MidiManagerMac does not remove any existing
   // MIDIEndpointRef, and the order is saved.
-  uint32 port_index = it->second;
+  uint32_t port_index = it->second;
 
   // Go through each packet and process separately.
   const MIDIPacket* packet = &packet_list->packet[0];
   for (size_t i = 0; i < packet_list->numPackets; i++) {
     // Each packet contains MIDI data for one or more messages (like note-on).
     double timestamp_seconds = MIDITimeStampToSeconds(packet->timeStamp);
 
     ReceiveMidiData(
         port_index,
         packet->data,
         packet->length,
         timestamp_seconds);
 
     packet = MIDIPacketNext(packet);
   }
 }
 
 void MidiManagerMac::SendMidiData(MidiManagerClient* client,
-                                  uint32 port_index,
-                                  const std::vector<uint8>& data,
+                                  uint32_t port_index,
+                                  const std::vector<uint8_t>& data,
                                   double timestamp) {
   DCHECK(client_thread_.task_runner()->BelongsToCurrentThread());
 
   // Lookup the destination based on the port index.
   if (static_cast<size_t>(port_index) >= destinations_.size())
     return;
 
   MIDITimeStamp coremidi_timestamp = SecondsToMIDITimeStamp(timestamp);
   MIDIEndpointRef destination = destinations_[port_index];
 
@@ skipping 18 matching lines @@
     DCHECK(midi_packet);
 
     MIDISend(coremidi_output_, destination, packet_list);
   }
 
   AccumulateMidiBytesSent(client, data.size());
 }
 
 }  // namespace midi
 }  // namespace media