Switch to standard integer types in media/.

media/midi/midi_manager.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.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 144 matching lines @@
 
   // Continue to hold lock_ here in case another thread is currently doing
   // EndSession.
   // Note that if we are in EndSession, then a destructor is being called and
   // it isn't really safe to call this method. But we don't have another way to
   // check this right now.
   client->AccumulateMidiBytesSent(n);
 }
 
 void MidiManager::DispatchSendMidiData(MidiManagerClient* client,
-                                       uint32 port_index,
-                                       const std::vector<uint8>& data,
+                                       uint32_t port_index,
+                                       const std::vector<uint8_t>& data,
                                        double timestamp) {
   NOTREACHED();
 }
 
 void MidiManager::StartInitialization() {
   CompleteInitialization(Result::NOT_SUPPORTED);
 }
 
 void MidiManager::CompleteInitialization(Result result) {
   base::AutoLock auto_lock(lock_);
@@ skipping 13 matching lines @@
 }
 
 void MidiManager::AddOutputPort(const MidiPortInfo& info) {
   ReportUsage(Usage::OUTPUT_PORT_ADDED);
   base::AutoLock auto_lock(lock_);
   output_ports_.push_back(info);
   for (auto client : clients_)
     client->AddOutputPort(info);
 }
 
-void MidiManager::SetInputPortState(uint32 port_index, MidiPortState state) {
+void MidiManager::SetInputPortState(uint32_t port_index, MidiPortState state) {
   base::AutoLock auto_lock(lock_);
   DCHECK_LT(port_index, input_ports_.size());
   input_ports_[port_index].state = state;
   for (auto client : clients_)
     client->SetInputPortState(port_index, state);
 }
 
-void MidiManager::SetOutputPortState(uint32 port_index, MidiPortState state) {
+void MidiManager::SetOutputPortState(uint32_t port_index, MidiPortState state) {
   base::AutoLock auto_lock(lock_);
   DCHECK_LT(port_index, output_ports_.size());
   output_ports_[port_index].state = state;
   for (auto client : clients_)
     client->SetOutputPortState(port_index, state);
 }
 
-void MidiManager::ReceiveMidiData(
-    uint32 port_index,
-    const uint8* data,
-    size_t length,
-    double timestamp) {
+void MidiManager::ReceiveMidiData(uint32_t port_index,
+                                  const uint8_t* data,
+                                  size_t length,
+                                  double timestamp) {
   base::AutoLock auto_lock(lock_);
 
   for (auto client : clients_)
     client->ReceiveMidiData(port_index, data, length, timestamp);
 }
 
 void MidiManager::CompleteInitializationInternal(Result result) {
   TRACE_EVENT0("midi", "MidiManager::CompleteInitialization");
   ReportUsage(Usage::INITIALIZED);
   UMA_HISTOGRAM_ENUMERATION("Media.Midi.InputPorts",
@@ skipping 33 matching lines @@
   base::AutoLock auto_lock(lock_);
   finalized_ = true;
 
   // Detach all clients so that they do not call MidiManager methods any more.
   for (auto client : clients_)
     client->Detach();
 }
 
 }  // namespace midi
 }  // namespace media