Switch to standard integer types in media/.

media/midi/midi_manager_win.cc

 // Copyright 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_win.h"
 
 #include <windows.h>
 #include <ks.h>
 #include <ksmedia.h>
 #include <mmreg.h>
@@ skipping 86 matching lines @@
 
 ScopedMIDIHDR CreateMIDIHDR(size_t size) {
   ScopedMIDIHDR header(new MIDIHDR);
   ZeroMemory(header.get(), sizeof(*header));
   header->lpData = new char[size];
   header->dwBufferLength = static_cast<DWORD>(size);
   return header.Pass();
 }
 
 void SendShortMidiMessageInternal(HMIDIOUT midi_out_handle,
-                                  const std::vector<uint8>& message) {
+                                  const std::vector<uint8_t>& message) {
   DCHECK_LE(message.size(), static_cast<size_t>(3))
       << "A short MIDI message should be up to 3 bytes.";
 
   DWORD packed_message = 0;
   for (size_t i = 0; i < message.size(); ++i)
-    packed_message |= (static_cast<uint32>(message[i]) << (i * 8));
+    packed_message |= (static_cast<uint32_t>(message[i]) << (i * 8));
   MMRESULT result = midiOutShortMsg(midi_out_handle, packed_message);
   DLOG_IF(ERROR, result != MMSYSERR_NOERROR)
       << "Failed to output short message: " << GetOutErrorMessage(result);
 }
 
 void SendLongMidiMessageInternal(HMIDIOUT midi_out_handle,
-                                 const std::vector<uint8>& message) {
+                                 const std::vector<uint8_t>& message) {
   // Implementation note:
   // Sending a long MIDI message can be performed synchronously or
   // asynchronously depending on the driver. There are 2 options to support both
   // cases:
   // 1) Call midiOutLongMsg() API and wait for its completion within this
   //   function. In this approach, we can avoid memory copy by directly pointing
   //   |message| as the data buffer to be sent.
   // 2) Allocate a buffer and copy |message| to it, then call midiOutLongMsg()
   //   API. The buffer will be freed in the MOM_DONE event hander, which tells
   //   us that the task of midiOutLongMsg() API is completed.
@@ skipping 76 matching lines @@
         driver_version(info.driver_version),
         product_name(info.product_name),
         usb_vendor_id(info.usb_vendor_id),
         usb_product_id(info.usb_product_id),
         is_usb_device(info.is_usb_device),
         is_software_synth(info.is_software_synth) {}
   // Currently only following entities are considered when testing the equality
   // of two MIDI devices.
   // TODO(toyoshim): Consider to calculate MIDIPort.id here and use it as the
   // key. See crbug.com/467448.  Then optimize the data for |MidiPortInfo|.
-  const uint16 manufacturer_id;
-  const uint16 product_id;
-  const uint32 driver_version;
+  const uint16_t manufacturer_id;
+  const uint16_t product_id;
+  const uint32_t driver_version;
   const base::string16 product_name;
-  const uint16 usb_vendor_id;
-  const uint16 usb_product_id;
+  const uint16_t usb_vendor_id;
+  const uint16_t usb_product_id;
   const bool is_usb_device;
   const bool is_software_synth;
 
   // Required to be used as the key of base::hash_map.
   bool operator==(const MidiDeviceInfo& that) const {
     return manufacturer_id == that.manufacturer_id &&
            product_id == that.product_id &&
            driver_version == that.driver_version &&
            product_name == that.product_name &&
            is_usb_device == that.is_usb_device &&
@@ skipping 28 matching lines @@
     return IS_COMPATIBLE_USBAUDIO_MID(&caps.ManufacturerGuid) &&
            IS_COMPATIBLE_USBAUDIO_PID(&caps.ProductGuid);
   }
   static bool IsUsbDevice(const MIDIOUTCAPS2W& caps) {
     return IS_COMPATIBLE_USBAUDIO_MID(&caps.ManufacturerGuid) &&
            IS_COMPATIBLE_USBAUDIO_PID(&caps.ProductGuid);
   }
   static bool IsSoftwareSynth(const MIDIOUTCAPS2W& caps) {
     return caps.wTechnology == MOD_SWSYNTH;
   }
-  static uint16 ExtractUsbVendorIdIfExists(const MIDIINCAPS2W& caps) {
+  static uint16_t ExtractUsbVendorIdIfExists(const MIDIINCAPS2W& caps) {
     if (!IS_COMPATIBLE_USBAUDIO_MID(&caps.ManufacturerGuid))
       return 0;
     return EXTRACT_USBAUDIO_MID(&caps.ManufacturerGuid);
   }
-  static uint16 ExtractUsbVendorIdIfExists(const MIDIOUTCAPS2W& caps) {
+  static uint16_t ExtractUsbVendorIdIfExists(const MIDIOUTCAPS2W& caps) {
     if (!IS_COMPATIBLE_USBAUDIO_MID(&caps.ManufacturerGuid))
       return 0;
     return EXTRACT_USBAUDIO_MID(&caps.ManufacturerGuid);
   }
-  static uint16 ExtractUsbProductIdIfExists(const MIDIINCAPS2W& caps) {
+  static uint16_t ExtractUsbProductIdIfExists(const MIDIINCAPS2W& caps) {
     if (!IS_COMPATIBLE_USBAUDIO_PID(&caps.ProductGuid))
       return 0;
     return EXTRACT_USBAUDIO_PID(&caps.ProductGuid);
   }
-  static uint16 ExtractUsbProductIdIfExists(const MIDIOUTCAPS2W& caps) {
+  static uint16_t ExtractUsbProductIdIfExists(const MIDIOUTCAPS2W& caps) {
     if (!IS_COMPATIBLE_USBAUDIO_PID(&caps.ProductGuid))
       return 0;
     return EXTRACT_USBAUDIO_PID(&caps.ProductGuid);
   }
 };
 
 std::string GetManufacturerName(const MidiDeviceInfo& info) {
   if (info.is_usb_device) {
     const char* name = device::UsbIds::GetVendorName(info.usb_vendor_id);
     return std::string(name ? name : "");
   }
 
   switch (info.manufacturer_id) {
     case MM_MICROSOFT:
       return "Microsoft Corporation";
     default:
       // TODO(toyoshim): Support other manufacture IDs.  crbug.com/472341.
       return "";
   }
 }
 
 bool IsUnsupportedDevice(const MidiDeviceInfo& info) {
   return info.is_software_synth && info.manufacturer_id == MM_MICROSOFT &&
          (info.product_id == MM_MSFT_WDMAUDIO_MIDIOUT ||
           info.product_id == MM_MSFT_GENERIC_MIDISYNTH);
 }
 
-using PortNumberCache = base::hash_map<
-    MidiDeviceInfo,
-    std::priority_queue<uint32, std::vector<uint32>, std::greater<uint32>>,
-    MidiDeviceInfo::Hasher>;
+using PortNumberCache =
+    base::hash_map<MidiDeviceInfo,
+                   std::priority_queue<uint32_t,
+                                       std::vector<uint32_t>,
+                                       std::greater<uint32_t>>,
+                   MidiDeviceInfo::Hasher>;
 
 struct MidiInputDeviceState final
     : base::RefCountedThreadSafe<MidiInputDeviceState> {
   explicit MidiInputDeviceState(const MidiDeviceInfo& device_info)
       : device_info(device_info),
         midi_handle(kInvalidMidiInHandle),
         port_index(0),
         port_age(0),
         start_time_initialized(false) {}
 
   const MidiDeviceInfo device_info;
   HMIDIIN midi_handle;
   ScopedMIDIHDR midi_header;
   // Since Win32 multimedia system uses a relative time offset from when
   // |midiInStart| API is called, we need to record when it is called.
   base::TimeTicks start_time;
   // 0-based port index.  We will try to reuse the previous port index when the
   // MIDI device is closed then reopened.
-  uint32 port_index;
+  uint32_t port_index;
   // A sequence number which represents how many times |port_index| is reused.
   // We can remove this field if we decide not to clear unsent events
   // when the device is disconnected.
   // See https://github.com/WebAudio/web-midi-api/issues/133
-  uint64 port_age;
+  uint64_t port_age;
   // True if |start_time| is initialized. This field is not used so far, but
   // kept for the debugging purpose.
   bool start_time_initialized;
 
  private:
   friend class base::RefCountedThreadSafe<MidiInputDeviceState>;
   ~MidiInputDeviceState() {}
 };
 
 struct MidiOutputDeviceState final
     : base::RefCountedThreadSafe<MidiOutputDeviceState> {
   explicit MidiOutputDeviceState(const MidiDeviceInfo& device_info)
       : device_info(device_info),
         midi_handle(kInvalidMidiOutHandle),
         port_index(0),
         port_age(0),
         closed(false) {}
 
   const MidiDeviceInfo device_info;
   HMIDIOUT midi_handle;
   // 0-based port index.  We will try to reuse the previous port index when the
   // MIDI device is closed then reopened.
-  uint32 port_index;
+  uint32_t port_index;
   // A sequence number which represents how many times |port_index| is reused.
   // We can remove this field if we decide not to clear unsent events
   // when the device is disconnected.
   // See https://github.com/WebAudio/web-midi-api/issues/133
-  uint64 port_age;
+  uint64_t port_age;
   // True if the device is already closed and |midi_handle| is considered to be
   // invalid.
   // TODO(toyoshim): Use std::atomic<bool> when it is allowed in Chromium
   // project.
   volatile bool closed;
 
  private:
   friend class base::RefCountedThreadSafe<MidiOutputDeviceState>;
   ~MidiOutputDeviceState() {}
 };
@@ skipping 115 matching lines @@
     base::SystemMonitor::Get()->AddDevicesChangedObserver(this);
 
     UpdateDeviceList();
 
     task_thread_.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&MidiServiceWinImpl::CompleteInitializationOnTaskThread,
                    base::Unretained(this), Result::OK));
   }
 
-  void SendMidiDataAsync(uint32 port_number,
-                         const std::vector<uint8>& data,
+  void SendMidiDataAsync(uint32_t port_number,
+                         const std::vector<uint8_t>& data,
                          base::TimeTicks time) final {
     if (destructor_started) {
       LOG(ERROR) << "ThreadSafeSendData failed because MidiServiceWinImpl is "
                     "being destructed.  port: " << port_number;
       return;
     }
     auto state = GetOutputDeviceFromPort(port_number);
     if (!state) {
       LOG(ERROR) << "ThreadSafeSendData failed due to an invalid port number. "
                  << "port: " << port_number;
@@ skipping 48 matching lines @@
   }
 
   scoped_refptr<MidiOutputDeviceState> GetOutputDeviceFromHandle(
       HMIDIOUT midi_handle) {
     base::AutoLock auto_lock(output_ports_lock_);
     const auto it = output_device_map_.find(midi_handle);
     return (it != output_device_map_.end() ? it->second : nullptr);
   }
 
   scoped_refptr<MidiOutputDeviceState> GetOutputDeviceFromPort(
-      uint32 port_number) {
+      uint32_t port_number) {
     base::AutoLock auto_lock(output_ports_lock_);
     if (output_ports_.size() <= port_number)
       return nullptr;
     return output_ports_[port_number];
   }
 
   void UpdateDeviceList() {
     task_thread_.message_loop()->PostTask(
         FROM_HERE, base::Bind(&MidiServiceWinImpl::UpdateDeviceListOnTaskThread,
                               base::Unretained(this)));
@@ skipping 42 matching lines @@
     if (result != MMSYSERR_NOERROR) {
       DLOG(ERROR) << "midiInGetDevCaps failed: " << GetInErrorMessage(result);
       return;
     }
     auto state =
         make_scoped_refptr(new MidiInputDeviceState(MidiDeviceInfo(caps)));
     state->midi_handle = midi_in_handle;
     state->midi_header = CreateMIDIHDR(kBufferLength);
     const auto& state_device_info = state->device_info;
     bool add_new_port = false;
-    uint32 port_number = 0;
+    uint32_t port_number = 0;
     {
       base::AutoLock auto_lock(input_ports_lock_);
       const auto it = unused_input_ports_.find(state_device_info);
       if (it == unused_input_ports_.end()) {
-        port_number = static_cast<uint32>(input_ports_.size());
+        port_number = static_cast<uint32_t>(input_ports_.size());
         add_new_port = true;
         input_ports_.push_back(nullptr);
         input_ports_ages_.push_back(0);
       } else {
         port_number = it->second.top();
         it->second.pop();
         if (it->second.empty()) {
           unused_input_ports_.erase(it);
         }
       }
@@ skipping 28 matching lines @@
                      MidiPortState::MIDI_PORT_CONNECTED));
     }
   }
 
   void OnMidiInDataOnMultimediaThread(HMIDIIN midi_in_handle,
                                       DWORD_PTR param1,
                                       DWORD_PTR param2) {
     auto state = GetInputDeviceFromHandle(midi_in_handle);
     if (!state)
       return;
-    const uint8 status_byte = static_cast<uint8>(param1 & 0xff);
-    const uint8 first_data_byte = static_cast<uint8>((param1 >> 8) & 0xff);
-    const uint8 second_data_byte = static_cast<uint8>((param1 >> 16) & 0xff);
+    const uint8_t status_byte = static_cast<uint8_t>(param1 & 0xff);
+    const uint8_t first_data_byte = static_cast<uint8_t>((param1 >> 8) & 0xff);
+    const uint8_t second_data_byte =
+        static_cast<uint8_t>((param1 >> 16) & 0xff);
     const DWORD elapsed_ms = param2;
     const size_t len = GetMidiMessageLength(status_byte);
-    const uint8 kData[] = {status_byte, first_data_byte, second_data_byte};
-    std::vector<uint8> data;
+    const uint8_t kData[] = {status_byte, first_data_byte, second_data_byte};
+    std::vector<uint8_t> data;
     data.assign(kData, kData + len);
     DCHECK_LE(len, arraysize(kData));
     // MIM_DATA/MIM_LONGDATA message treats the time when midiInStart() is
     // called as the origin of |elapsed_ms|.
     // http://msdn.microsoft.com/en-us/library/windows/desktop/dd757284.aspx
     // http://msdn.microsoft.com/en-us/library/windows/desktop/dd757286.aspx
     const base::TimeTicks event_time =
         state->start_time + base::TimeDelta::FromMilliseconds(elapsed_ms);
     task_thread_.message_loop()->PostTask(
         FROM_HERE, base::Bind(&MidiServiceWinImpl::ReceiveMidiDataOnTaskThread,
@@ skipping 16 matching lines @@
         result =
             midiInUnprepareHeader(state->midi_handle, state->midi_header.get(),
                                   sizeof(*state->midi_header));
         DLOG_IF(ERROR, result != MMSYSERR_NOERROR)
             << "Failed to uninitialize input buffer: "
             << GetInErrorMessage(result);
       }
       return;
     }
     if (header->dwBytesRecorded > 0) {
-      const uint8* src = reinterpret_cast<const uint8*>(header->lpData);
-      std::vector<uint8> data;
+      const uint8_t* src = reinterpret_cast<const uint8_t*>(header->lpData);
+      std::vector<uint8_t> data;
       data.assign(src, src + header->dwBytesRecorded);
       // MIM_DATA/MIM_LONGDATA message treats the time when midiInStart() is
       // called as the origin of |elapsed_ms|.
       // http://msdn.microsoft.com/en-us/library/windows/desktop/dd757284.aspx
       // http://msdn.microsoft.com/en-us/library/windows/desktop/dd757286.aspx
       const base::TimeTicks event_time =
           state->start_time + base::TimeDelta::FromMilliseconds(elapsed_ms);
       task_thread_.message_loop()->PostTask(
           FROM_HERE,
           base::Bind(&MidiServiceWinImpl::ReceiveMidiDataOnTaskThread,
                      base::Unretained(this), state->port_index, data,
                      event_time));
     }
     result = midiInAddBuffer(state->midi_handle, header, sizeof(*header));
     DLOG_IF(ERROR, result != MMSYSERR_NOERROR)
         << "Failed to attach input buffer: " << GetInErrorMessage(result)
         << "port number:" << state->port_index;
   }
 
   void OnMidiInCloseOnMultimediaThread(HMIDIIN midi_in_handle) {
     auto state = GetInputDeviceFromHandle(midi_in_handle);
     if (!state)
       return;
-    const uint32 port_number = state->port_index;
+    const uint32_t port_number = state->port_index;
     const auto device_info(state->device_info);
     {
       base::AutoLock auto_lock(input_ports_lock_);
       input_device_map_.erase(state->midi_handle);
       input_ports_[port_number] = nullptr;
       input_ports_ages_[port_number] += 1;
       unused_input_ports_[device_info].push(port_number);
     }
     task_thread_.message_loop()->PostTask(
         FROM_HERE,
@@ skipping 40 matching lines @@
       DLOG(ERROR) << "midiInGetDevCaps failed: " << GetOutErrorMessage(result);
       return;
     }
     auto state =
         make_scoped_refptr(new MidiOutputDeviceState(MidiDeviceInfo(caps)));
     state->midi_handle = midi_out_handle;
     const auto& state_device_info = state->device_info;
     if (IsUnsupportedDevice(state_device_info))
       return;
     bool add_new_port = false;
-    uint32 port_number = 0;
+    uint32_t port_number = 0;
     {
       base::AutoLock auto_lock(output_ports_lock_);
       const auto it = unused_output_ports_.find(state_device_info);
       if (it == unused_output_ports_.end()) {
-        port_number = static_cast<uint32>(output_ports_.size());
+        port_number = static_cast<uint32_t>(output_ports_.size());
         add_new_port = true;
         output_ports_.push_back(nullptr);
         output_ports_ages_.push_back(0);
       } else {
         port_number = it->second.top();
         it->second.pop();
         if (it->second.empty())
           unused_output_ports_.erase(it);
       }
       output_ports_[port_number] = state;
@@ skipping 35 matching lines @@
                                              sizeof(*header));
     DLOG_IF(ERROR, result != MMSYSERR_NOERROR)
         << "Failed to uninitialize output buffer: "
         << GetOutErrorMessage(result);
   }
 
   void OnMidiOutCloseOnMultimediaThread(HMIDIOUT midi_out_handle) {
     auto state = GetOutputDeviceFromHandle(midi_out_handle);
     if (!state)
       return;
-    const uint32 port_number = state->port_index;
+    const uint32_t port_number = state->port_index;
     const auto device_info(state->device_info);
     {
       base::AutoLock auto_lock(output_ports_lock_);
       output_device_map_.erase(state->midi_handle);
       output_ports_[port_number] = nullptr;
       output_ports_ages_[port_number] += 1;
       unused_output_ports_[device_info].push(port_number);
       state->closed = true;
     }
     task_thread_.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&MidiServiceWinImpl::SetOutputPortStateOnTaskThread,
                    base::Unretained(this), port_number,
                    MIDI_PORT_DISCONNECTED));
   }
 
   /////////////////////////////////////////////////////////////////////////////
   // Callbacks on the sender thread.
   /////////////////////////////////////////////////////////////////////////////
 
   void AssertOnSenderThread() {
     DCHECK_EQ(sender_thread_.GetThreadId(), base::PlatformThread::CurrentId());
   }
 
-  void SendOnSenderThread(uint32 port_number,
-                          uint64 port_age,
-                          const std::vector<uint8>& data,
+  void SendOnSenderThread(uint32_t port_number,
+                          uint64_t port_age,
+                          const std::vector<uint8_t>& data,
                           base::TimeTicks time) {
     AssertOnSenderThread();
     if (destructor_started) {
       LOG(ERROR) << "ThreadSafeSendData failed because MidiServiceWinImpl is "
                     "being destructed. port: " << port_number;
     }
     auto state = GetOutputDeviceFromPort(port_number);
     if (!state) {
       LOG(ERROR) << "ThreadSafeSendData failed due to an invalid port number. "
                  << "port: " << port_number;
       return;
     }
     if (state->closed) {
       LOG(ERROR)
           << "ThreadSafeSendData failed because target port is already closed."
           << "port: " << port_number;
       return;
     }
     if (state->port_age != port_age) {
       LOG(ERROR)
           << "ThreadSafeSendData failed because target port is being closed."
           << "port: " << port_number << "expected port age: " << port_age
           << "actual port age: " << state->port_age;
     }
 
     // MIDI Running status must be filtered out.
     MidiMessageQueue message_queue(false);
     message_queue.Add(data);
-    std::vector<uint8> message;
+    std::vector<uint8_t> message;
     while (true) {
       if (destructor_started)
         break;
       if (state->closed)
         break;
       message_queue.Get(&message);
       if (message.empty())
         break;
       // SendShortMidiMessageInternal can send a MIDI message up to 3 bytes.
       if (message.size() <= 3)
@@ skipping 92 matching lines @@
     }
     state->start_time = base::TimeTicks::Now();
     state->start_time_initialized = true;
   }
 
   void CompleteInitializationOnTaskThread(Result result) {
     AssertOnTaskThread();
     delegate_->OnCompleteInitialization(result);
   }
 
-  void ReceiveMidiDataOnTaskThread(uint32 port_index,
-                                   std::vector<uint8> data,
+  void ReceiveMidiDataOnTaskThread(uint32_t port_index,
+                                   std::vector<uint8_t> data,
                                    base::TimeTicks time) {
     AssertOnTaskThread();
     delegate_->OnReceiveMidiData(port_index, data, time);
   }
 
   void AddInputPortOnTaskThread(MidiPortInfo info) {
     AssertOnTaskThread();
     delegate_->OnAddInputPort(info);
   }
 
   void AddOutputPortOnTaskThread(MidiPortInfo info) {
     AssertOnTaskThread();
     delegate_->OnAddOutputPort(info);
   }
 
-  void SetInputPortStateOnTaskThread(uint32 port_index, MidiPortState state) {
+  void SetInputPortStateOnTaskThread(uint32_t port_index, MidiPortState state) {
     AssertOnTaskThread();
     delegate_->OnSetInputPortState(port_index, state);
   }
 
-  void SetOutputPortStateOnTaskThread(uint32 port_index, MidiPortState state) {
+  void SetOutputPortStateOnTaskThread(uint32_t port_index,
+                                      MidiPortState state) {
     AssertOnTaskThread();
     delegate_->OnSetOutputPortState(port_index, state);
   }
 
   /////////////////////////////////////////////////////////////////////////////
   // Fields:
   /////////////////////////////////////////////////////////////////////////////
 
   // Does not take ownership.
   MidiServiceWinDelegate* delegate_;
 
   base::ThreadChecker thread_checker_;
 
   base::Thread sender_thread_;
   base::Thread task_thread_;
 
   base::Lock input_ports_lock_;
   base::hash_map<HMIDIIN, scoped_refptr<MidiInputDeviceState>>
       input_device_map_;                // GUARDED_BY(input_ports_lock_)
   PortNumberCache unused_input_ports_;  // GUARDED_BY(input_ports_lock_)
   std::vector<scoped_refptr<MidiInputDeviceState>>
       input_ports_;                       // GUARDED_BY(input_ports_lock_)
-  std::vector<uint64> input_ports_ages_;  // GUARDED_BY(input_ports_lock_)
+  std::vector<uint64_t> input_ports_ages_;  // GUARDED_BY(input_ports_lock_)
 
   base::Lock output_ports_lock_;
   base::hash_map<HMIDIOUT, scoped_refptr<MidiOutputDeviceState>>
       output_device_map_;                // GUARDED_BY(output_ports_lock_)
   PortNumberCache unused_output_ports_;  // GUARDED_BY(output_ports_lock_)
   std::vector<scoped_refptr<MidiOutputDeviceState>>
       output_ports_;                       // GUARDED_BY(output_ports_lock_)
-  std::vector<uint64> output_ports_ages_;  // GUARDED_BY(output_ports_lock_)
+  std::vector<uint64_t> output_ports_ages_;  // GUARDED_BY(output_ports_lock_)
 
   // True if one thread reached MidiServiceWinImpl::~MidiServiceWinImpl(). Note
   // that MidiServiceWinImpl::~MidiServiceWinImpl() is blocked until
   // |sender_thread_|, and |task_thread_| are stopped.
   // This flag can be used as the signal that when background tasks must be
   // interrupted.
   // TODO(toyoshim): Use std::atomic<bool> when it is allowed.
   volatile bool destructor_started;
 
   DISALLOW_COPY_AND_ASSIGN(MidiServiceWinImpl);
@@ skipping 11 matching lines @@
   midi_service_.reset(new MidiServiceWinImpl);
   // Note that |CompleteInitialization()| will be called from the callback.
   midi_service_->InitializeAsync(this);
 }
 
 void MidiManagerWin::Finalize() {
   midi_service_.reset();
 }
 
 void MidiManagerWin::DispatchSendMidiData(MidiManagerClient* client,
-                                          uint32 port_index,
-                                          const std::vector<uint8>& data,
+                                          uint32_t port_index,
+                                          const std::vector<uint8_t>& data,
                                           double timestamp) {
   if (!midi_service_)
     return;
 
   base::TimeTicks time_to_send = base::TimeTicks::Now();
   if (timestamp != 0.0) {
     time_to_send =
         base::TimeTicks() + base::TimeDelta::FromMicroseconds(
                                 timestamp * base::Time::kMicrosecondsPerSecond);
   }
   midi_service_->SendMidiDataAsync(port_index, data, time_to_send);
 
   // TOOD(toyoshim): This calculation should be done when the date is actually
   // sent.
   client->AccumulateMidiBytesSent(data.size());
 }
 
 void MidiManagerWin::OnCompleteInitialization(Result result) {
   CompleteInitialization(result);
 }
 
 void MidiManagerWin::OnAddInputPort(MidiPortInfo info) {
   AddInputPort(info);
 }
 
 void MidiManagerWin::OnAddOutputPort(MidiPortInfo info) {
   AddOutputPort(info);
 }
 
-void MidiManagerWin::OnSetInputPortState(uint32 port_index,
+void MidiManagerWin::OnSetInputPortState(uint32_t port_index,
                                          MidiPortState state) {
   SetInputPortState(port_index, state);
 }
 
-void MidiManagerWin::OnSetOutputPortState(uint32 port_index,
+void MidiManagerWin::OnSetOutputPortState(uint32_t port_index,
                                           MidiPortState state) {
   SetOutputPortState(port_index, state);
 }
 
-void MidiManagerWin::OnReceiveMidiData(uint32 port_index,
-                                       const std::vector<uint8>& data,
+void MidiManagerWin::OnReceiveMidiData(uint32_t port_index,
+                                       const std::vector<uint8_t>& data,
                                        base::TimeTicks time) {
   ReceiveMidiData(port_index, &data[0], data.size(), time);
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerWin();
 }
 
 }  // namespace midi
 }  // namespace media