Switch to standard integer types in media/.

media/midi/midi_manager_usb.cc

 // Copyright 2014 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_usb.h"
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "media/midi/midi_scheduler.h"
@@ skipping 19 matching lines @@
   scheduler_.reset(new MidiScheduler(this));
   // This is safe because EnumerateDevices cancels the operation on destruction.
   device_factory_->EnumerateDevices(
       this,
       base::Bind(&MidiManagerUsb::OnEnumerateDevicesDone,
                  base::Unretained(this)));
 }
 
 void MidiManagerUsb::DispatchSendMidiData(MidiManagerClient* client,
                                           uint32_t port_index,
-                                          const std::vector<uint8>& data,
+                                          const std::vector<uint8_t>& data,
                                           double timestamp) {
   if (port_index >= output_streams_.size()) {
     // |port_index| is provided by a renderer so we can't believe that it is
     // in the valid range.
     return;
   }
   // output_streams_[port_index] is alive unless MidiManagerUsb is deleted.
   // The task posted to the MidiScheduler will be disposed safely on deleting
   // the scheduler.
   scheduler_->PostSendDataTask(
       client, data.size(), timestamp,
       base::Bind(&UsbMidiOutputStream::Send,
                  base::Unretained(output_streams_[port_index]), data));
 }
 
 void MidiManagerUsb::ReceiveUsbMidiData(UsbMidiDevice* device,
                                         int endpoint_number,
-                                        const uint8* data,
+                                        const uint8_t* data,
                                         size_t size,
                                         base::TimeTicks time) {
   if (!input_stream_)
     return;
   input_stream_->OnReceivedData(device,
                                 endpoint_number,
                                 data,
                                 size,
                                 time);
 }
 
 void MidiManagerUsb::OnDeviceAttached(scoped_ptr<UsbMidiDevice> device) {
   int device_id = static_cast<int>(devices_.size());
   devices_.push_back(device.Pass());
   AddPorts(devices_.back(), device_id);
 }
 
 void MidiManagerUsb::OnDeviceDetached(size_t index) {
   if (index >= devices_.size()) {
     return;
   }
   UsbMidiDevice* device = devices_[index];
   for (size_t i = 0; i < output_streams_.size(); ++i) {
     if (output_streams_[i]->jack().device == device) {
-      SetOutputPortState(static_cast<uint32>(i), MIDI_PORT_DISCONNECTED);
+      SetOutputPortState(static_cast<uint32_t>(i), MIDI_PORT_DISCONNECTED);
     }
   }
   const std::vector<UsbMidiJack>& input_jacks = input_stream_->jacks();
   for (size_t i = 0; i < input_jacks.size(); ++i) {
     if (input_jacks[i].device == device) {
-      SetInputPortState(static_cast<uint32>(i), MIDI_PORT_DISCONNECTED);
+      SetInputPortState(static_cast<uint32_t>(i), MIDI_PORT_DISCONNECTED);
     }
   }
 }
 
 void MidiManagerUsb::OnReceivedData(size_t jack_index,
-                                    const uint8* data,
+                                    const uint8_t* data,
                                     size_t size,
                                     base::TimeTicks time) {
-  ReceiveMidiData(static_cast<uint32>(jack_index), data, size, time);
+  ReceiveMidiData(static_cast<uint32_t>(jack_index), data, size, time);
 }
 
 
 void MidiManagerUsb::OnEnumerateDevicesDone(bool result,
                                             UsbMidiDevice::Devices* devices) {
   if (!result) {
     initialize_callback_.Run(Result::INITIALIZATION_ERROR);
     return;
   }
   input_stream_.reset(new UsbMidiInputStream(this));
   devices->swap(devices_);
   for (size_t i = 0; i < devices_.size(); ++i) {
     if (!AddPorts(devices_[i], static_cast<int>(i))) {
       initialize_callback_.Run(Result::INITIALIZATION_ERROR);
       return;
     }
   }
   initialize_callback_.Run(Result::OK);
 }
 
 bool MidiManagerUsb::AddPorts(UsbMidiDevice* device, int device_id) {
   UsbMidiDescriptorParser parser;
-  std::vector<uint8> descriptor = device->GetDescriptors();
-  const uint8* data = descriptor.size() > 0 ? &descriptor[0] : NULL;
+  std::vector<uint8_t> descriptor = device->GetDescriptors();
+  const uint8_t* data = descriptor.size() > 0 ? &descriptor[0] : NULL;
   std::vector<UsbMidiJack> jacks;
   bool parse_result = parser.Parse(device,
                                    data,
                                    descriptor.size(),
                                    &jacks);
   if (!parse_result)
     return false;
 
   std::string manufacturer(device->GetManufacturer());
   std::string product_name(device->GetProductName());
@@ skipping 14 matching lines @@
       input_stream_->Add(jacks[j]);
       AddInputPort(MidiPortInfo(id, manufacturer, product_name, version,
                                 MIDI_PORT_OPENED));
     }
   }
   return true;
 }
 
 }  // namespace midi
 }  // namespace media