Switch to standard integer types in media/.

media/midi/midi_manager_android.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_android.h"
 
 #include "base/android/build_info.h"
 #include "base/android/context_utils.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 28 matching lines @@
   JNIEnv* env = base::android::AttachCurrentThread();
 
   uintptr_t pointer = reinterpret_cast<uintptr_t>(this);
   raw_manager_.Reset(Java_MidiManagerAndroid_create(
       env, base::android::GetApplicationContext(), pointer));
   scheduler_.reset(new MidiScheduler(this));
   Java_MidiManagerAndroid_initialize(env, raw_manager_.obj());
 }
 
 void MidiManagerAndroid::DispatchSendMidiData(MidiManagerClient* client,
-                                              uint32 port_index,
-                                              const std::vector<uint8>& data,
+                                              uint32_t port_index,
+                                              const std::vector<uint8_t>& data,
                                               double timestamp) {
   if (port_index >= all_output_ports_.size()) {
     // |port_index| is provided by a renderer so we can't believe that it is
     // in the valid range.
     return;
   }
   DCHECK_EQ(output_ports().size(), all_output_ports_.size());
   if (output_ports()[port_index].state == MIDI_PORT_CONNECTED) {
     // We treat send call as implicit open.
     // TODO(yhirano): Implement explicit open operation from the renderer.
     if (all_output_ports_[port_index]->Open()) {
       SetOutputPortState(port_index, MIDI_PORT_OPENED);
     } else {
       // We cannot open the port. It's useless to send data to such a port.
       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(&MidiOutputPortAndroid::Send,
                  base::Unretained(all_output_ports_[port_index]), data));
 }
 
 void MidiManagerAndroid::OnReceivedData(MidiInputPortAndroid* port,
-                                        const uint8* data,
+                                        const uint8_t* data,
                                         size_t size,
                                         base::TimeTicks timestamp) {
   const auto i = input_port_to_index_.find(port);
   DCHECK(input_port_to_index_.end() != i);
   ReceiveMidiData(i->second, data, size, timestamp);
 }
 
 void MidiManagerAndroid::OnInitialized(
     JNIEnv* env,
     const JavaParamRef<jobject>& caller,
@@ skipping 69 matching lines @@
   }
   devices_.push_back(device.release());
 }
 
 bool MidiManagerAndroid::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace midi
 }  // namespace media