Switch to standard integer types in media/.

media/midi/midi_manager_alsa.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_alsa.h"
 
 #include <errno.h>
 #include <poll.h>
 #include <stdlib.h>
 #include <algorithm>
@@ skipping 260 matching lines @@
   // Close the out client. This will trigger the event thread to stop,
   // because of SND_SEQ_EVENT_CLIENT_EXIT.
   if (out_client_.get())
     snd_seq_close(out_client_.release());
 
   // Wait for the event thread to stop.
   event_thread_.Stop();
 }
 
 void MidiManagerAlsa::DispatchSendMidiData(MidiManagerClient* client,
-                                           uint32 port_index,
-                                           const std::vector<uint8>& data,
+                                           uint32_t port_index,
+                                           const std::vector<uint8_t>& data,
                                            double timestamp) {
   if (!send_thread_.IsRunning())
     send_thread_.Start();
 
   base::TimeDelta delay;
   if (timestamp != 0.0) {
     base::TimeTicks time_to_send =
         base::TimeTicks() + base::TimeDelta::FromMicroseconds(
                                 timestamp * base::Time::kMicrosecondsPerSecond);
     delay = std::max(time_to_send - base::TimeTicks::Now(), base::TimeDelta());
@@ skipping 99 matching lines @@
   std::string json;
   JSONStringValueSerializer serializer(&json);
   serializer.Serialize(*Value().get());
   return json;
 }
 
 // TODO(agoode): Do not use SHA256 here. Instead store a persistent
 //               mapping and just use a UUID or other random string.
 //               http://crbug.com/465320
 std::string MidiManagerAlsa::MidiPort::OpaqueKey() const {
-  uint8 hash[crypto::kSHA256Length];
+  uint8_t hash[crypto::kSHA256Length];
   crypto::SHA256HashString(JSONValue(), &hash, sizeof(hash));
   return base::HexEncode(&hash, sizeof(hash));
 }
 
 bool MidiManagerAlsa::MidiPort::MatchConnected(const MidiPort& query) const {
   // Matches on:
   // connected == true
   // type
   // path
   // id
@@ skipping 144 matching lines @@
   }
 
   // No match.
   return ports_.end();
 }
 
 MidiManagerAlsa::MidiPortStateBase::MidiPortStateBase() = default;
 
 MidiManagerAlsa::MidiPortState::MidiPortState() = default;
 
-uint32 MidiManagerAlsa::MidiPortState::push_back(scoped_ptr<MidiPort> port) {
+uint32_t MidiManagerAlsa::MidiPortState::push_back(scoped_ptr<MidiPort> port) {
   // Add the web midi index.
-  uint32 web_port_index = 0;
+  uint32_t web_port_index = 0;
   switch (port->type()) {
     case MidiPort::Type::kInput:
       web_port_index = num_input_ports_++;
       break;
     case MidiPort::Type::kOutput:
       web_port_index = num_output_ports_++;
       break;
   }
   port->set_web_port_index(web_port_index);
   MidiPortStateBase::push_back(port.Pass());
@@ skipping 223 matching lines @@
   if (at_index && at_index != std::string::npos) {
     size_t name_index = alsa_longname.rfind(alsa_name, at_index - 1);
     if (name_index && name_index != std::string::npos)
       return alsa_longname.substr(0, name_index - 1);
   }
 
   // Failure.
   return "";
 }
 
-void MidiManagerAlsa::SendMidiData(uint32 port_index,
-                                   const std::vector<uint8>& data) {
+void MidiManagerAlsa::SendMidiData(uint32_t port_index,
+                                   const std::vector<uint8_t>& data) {
   DCHECK(send_thread_.task_runner()->BelongsToCurrentThread());
 
   snd_midi_event_t* encoder;
   snd_midi_event_new(kSendBufferSize, &encoder);
   for (const auto datum : data) {
     snd_seq_event_t event;
     int result = snd_midi_event_encode_byte(encoder, datum, &event);
     if (result == 1) {
       // Full event, send it.
       base::AutoLock lock(out_ports_lock_);
@@ skipping 96 matching lines @@
   // Do again.
   if (loop_again)
     ScheduleEventLoop();
 }
 
 void MidiManagerAlsa::ProcessSingleEvent(snd_seq_event_t* event,
                                          double timestamp) {
   auto source_it =
       source_map_.find(AddrToInt(event->source.client, event->source.port));
   if (source_it != source_map_.end()) {
-    uint32 source = source_it->second;
+    uint32_t source = source_it->second;
     if (event->type == SND_SEQ_EVENT_SYSEX) {
       // Special! Variable-length sysex.
-      ReceiveMidiData(source, static_cast<const uint8*>(event->data.ext.ptr),
+      ReceiveMidiData(source, static_cast<const uint8_t*>(event->data.ext.ptr),
                       event->data.ext.len, timestamp);
     } else {
       // Otherwise, decode this and send that on.
       unsigned char buf[12];
       long count =
           snd_midi_event_decode(decoder_.get(), buf, sizeof(buf), event);
       if (count <= 0) {
         if (count != -ENOENT) {
           // ENOENT means that it's not a MIDI message, which is not an
           // error, but other negative values are errors for us.
@@ skipping 192 matching lines @@
     return;
 
   // Generate new port state.
   auto new_port_state = alsa_seq_state_.ToMidiPortState(alsa_cards_);
 
   // Disconnect any connected old ports that are now missing.
   for (auto& old_port : port_state_) {
     if (old_port->connected() &&
         (new_port_state->FindConnected(*old_port) == new_port_state->end())) {
       old_port->set_connected(false);
-      uint32 web_port_index = old_port->web_port_index();
+      uint32_t web_port_index = old_port->web_port_index();
       switch (old_port->type()) {
         case MidiPort::Type::kInput:
           source_map_.erase(
               AddrToInt(old_port->client_id(), old_port->port_id()));
           SetInputPortState(web_port_index, MIDI_PORT_DISCONNECTED);
           break;
         case MidiPort::Type::kOutput:
           DeleteAlsaOutputPort(web_port_index);
           SetOutputPortState(web_port_index, MIDI_PORT_DISCONNECTED);
           break;
       }
     }
   }
 
   // Reconnect or add new ports.
   auto it = new_port_state->begin();
   while (it != new_port_state->end()) {
     auto& new_port = *it;
     auto old_port = port_state_.Find(*new_port);
     if (old_port == port_state_.end()) {
       // Add new port.
       const auto& opaque_key = new_port->OpaqueKey();
       const auto& manufacturer = new_port->manufacturer();
       const auto& port_name = new_port->port_name();
       const auto& version = new_port->version();
       const auto& type = new_port->type();
       const auto& client_id = new_port->client_id();
       const auto& port_id = new_port->port_id();
 
-      uint32 web_port_index = port_state_.push_back(new_port.Pass());
+      uint32_t web_port_index = port_state_.push_back(new_port.Pass());
       it = new_port_state->erase(it);
 
       MidiPortInfo info(opaque_key, manufacturer, port_name, version,
                         MIDI_PORT_OPENED);
       switch (type) {
         case MidiPort::Type::kInput:
           if (Subscribe(web_port_index, client_id, port_id))
             AddInputPort(info);
           break;
         case MidiPort::Type::kOutput:
           if (CreateAlsaOutputPort(web_port_index, client_id, port_id))
             AddOutputPort(info);
           break;
       }
     } else if (!(*old_port)->connected()) {
       // Reconnect.
-      uint32 web_port_index = (*old_port)->web_port_index();
+      uint32_t web_port_index = (*old_port)->web_port_index();
       (*old_port)->Update(new_port->path(), new_port->client_id(),
                           new_port->port_id(), new_port->client_name(),
                           new_port->port_name(), new_port->manufacturer(),
                           new_port->version());
       switch ((*old_port)->type()) {
         case MidiPort::Type::kInput:
           if (Subscribe(web_port_index, (*old_port)->client_id(),
                         (*old_port)->port_id()))
             SetInputPortState(web_port_index, MIDI_PORT_OPENED);
           break;
@@ skipping 65 matching lines @@
     const char* path = device::udev_list_entry_get_name(list_entry);
     device::ScopedUdevDevicePtr dev(
         device::udev_device_new_from_syspath(udev_.get(), path));
     if (dev.get())
       ProcessUdevEvent(dev.get());
   }
 
   return true;
 }
 
-bool MidiManagerAlsa::CreateAlsaOutputPort(uint32 port_index,
+bool MidiManagerAlsa::CreateAlsaOutputPort(uint32_t port_index,
                                            int client_id,
                                            int port_id) {
   // Create the port.
   int out_port = snd_seq_create_simple_port(
       out_client_.get(), NULL, kCreateOutputPortCaps, kCreatePortType);
   if (out_port < 0) {
     VLOG(1) << "snd_seq_create_simple_port fails: " << snd_strerror(out_port);
     return false;
   }
   // Activate port subscription.
@@ skipping 13 matching lines @@
     snd_seq_delete_simple_port(out_client_.get(), out_port);
     return false;
   }
 
   // Update our map.
   base::AutoLock lock(out_ports_lock_);
   out_ports_[port_index] = out_port;
   return true;
 }
 
-void MidiManagerAlsa::DeleteAlsaOutputPort(uint32 port_index) {
+void MidiManagerAlsa::DeleteAlsaOutputPort(uint32_t port_index) {
   base::AutoLock lock(out_ports_lock_);
   auto it = out_ports_.find(port_index);
   if (it == out_ports_.end())
     return;
 
   int alsa_port = it->second;
   snd_seq_delete_simple_port(out_client_.get(), alsa_port);
   out_ports_.erase(it);
 }
 
-bool MidiManagerAlsa::Subscribe(uint32 port_index, int client_id, int port_id) {
+bool MidiManagerAlsa::Subscribe(uint32_t port_index,
+                                int client_id,
+                                int port_id) {
   // Activate port subscription.
   snd_seq_port_subscribe_t* subs;
   snd_seq_port_subscribe_alloca(&subs);
   snd_seq_addr_t sender;
   sender.client = client_id;
   sender.port = port_id;
   snd_seq_port_subscribe_set_sender(subs, &sender);
   snd_seq_addr_t dest;
   dest.client = in_client_id_;
   dest.port = in_port_id_;
   snd_seq_port_subscribe_set_dest(subs, &dest);
   int err = snd_seq_subscribe_port(in_client_.get(), subs);
   if (err != 0) {
     VLOG(1) << "snd_seq_subscribe_port fails: " << snd_strerror(err);
     return false;
   }
 
   // Update our map.
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace midi
 }  // namespace media