Switch to standard integer types in media/.

media/midi/midi_manager_alsa.h

 // 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.
 
 #ifndef MEDIA_MIDI_MIDI_MANAGER_ALSA_H_
 #define MEDIA_MIDI_MIDI_MANAGER_ALSA_H_
 
 #include <alsa/asoundlib.h>
 #include <map>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
 #include "device/udev_linux/scoped_udev.h"
 #include "media/midi/midi_export.h"
 #include "media/midi/midi_manager.h"
 
 namespace media {
 namespace midi {
 
 class MIDI_EXPORT MidiManagerAlsa final : public MidiManager {
  public:
   MidiManagerAlsa();
   ~MidiManagerAlsa() override;
 
   // MidiManager implementation.
   void StartInitialization() override;
   void Finalize() override;
   void DispatchSendMidiData(MidiManagerClient* client,
-                            uint32 port_index,
-                            const std::vector<uint8>& data,
+                            uint32_t port_index,
+                            const std::vector<uint8_t>& data,
                             double timestamp) override;
 
  private:
   friend class MidiManagerAlsaTest;
   FRIEND_TEST_ALL_PREFIXES(MidiManagerAlsaTest, ExtractManufacturer);
   FRIEND_TEST_ALL_PREFIXES(MidiManagerAlsaTest, ToMidiPortState);
 
   class AlsaCard;
   using AlsaCardMap = std::map<int, scoped_ptr<AlsaCard>>;
 
@@ skipping 71 matching lines @@
     std::string path() const { return path_; }
     Id id() const { return id_; }
     std::string client_name() const { return client_name_; }
     std::string port_name() const { return port_name_; }
     std::string manufacturer() const { return manufacturer_; }
     std::string version() const { return version_; }
     int client_id() const { return client_id_; }
     int port_id() const { return port_id_; }
     int midi_device() const { return midi_device_; }
     Type type() const { return type_; }
-    uint32 web_port_index() const { return web_port_index_; }
+    uint32_t web_port_index() const { return web_port_index_; }
     bool connected() const { return connected_; }
 
     // mutators
-    void set_web_port_index(uint32 web_port_index) {
+    void set_web_port_index(uint32_t web_port_index) {
       web_port_index_ = web_port_index;
     }
     void set_connected(bool connected) { connected_ = connected; }
     void Update(const std::string& path,
                 int client_id,
                 int port_id,
                 const std::string& client_name,
                 const std::string& port_name,
                 const std::string& manufacturer,
                 const std::string& version) {
@@ skipping 17 matching lines @@
     // drivers change.
     std::string path_;
     int client_id_;
     int port_id_;
     std::string client_name_;
     std::string port_name_;
     std::string manufacturer_;
     std::string version_;
 
     // Index for MidiManager.
-    uint32 web_port_index_ = 0;
+    uint32_t web_port_index_ = 0;
 
     // Port is present in the ALSA system.
     bool connected_ = true;
 
     DISALLOW_COPY_AND_ASSIGN(MidiPort);
   };
 
   class MidiPortStateBase {
    public:
     typedef std::vector<scoped_ptr<MidiPort>>::iterator iterator;
@@ skipping 31 matching lines @@
     void push_back(scoped_ptr<MidiPort> port) {
       MidiPortStateBase::push_back(port.Pass());
     }
   };
 
   class MidiPortState final : public MidiPortStateBase {
    public:
     MidiPortState();
 
     // Inserts a port at the end. Returns web_port_index.
-    uint32 push_back(scoped_ptr<MidiPort> port);
+    uint32_t push_back(scoped_ptr<MidiPort> port);
 
    private:
-    uint32 num_input_ports_ = 0;
-    uint32 num_output_ports_ = 0;
+    uint32_t num_input_ports_ = 0;
+    uint32_t num_output_ports_ = 0;
   };
 
   class AlsaSeqState {
    public:
     enum class PortDirection { kInput, kOutput, kDuplex };
 
     AlsaSeqState();
     ~AlsaSeqState();
 
     void ClientStart(int client_id,
@@ skipping 114 matching lines @@
   struct SndSeqDeleter {
     void operator()(snd_seq_t* seq) const { snd_seq_close(seq); }
   };
 
   struct SndMidiEventDeleter {
     void operator()(snd_midi_event_t* coder) const {
       snd_midi_event_free(coder);
     };
   };
 
-  typedef base::hash_map<int, uint32> SourceMap;
-  typedef base::hash_map<uint32, int> OutPortMap;
+  typedef base::hash_map<int, uint32_t> SourceMap;
+  typedef base::hash_map<uint32_t, int> OutPortMap;
 
   // An internal callback that runs on MidiSendThread.
-  void SendMidiData(uint32 port_index, const std::vector<uint8>& data);
+  void SendMidiData(uint32_t port_index, const std::vector<uint8_t>& data);
 
   void ScheduleEventLoop();
   void EventLoop();
   void ProcessSingleEvent(snd_seq_event_t* event, double timestamp);
   void ProcessClientStartEvent(int client_id);
   void ProcessPortStartEvent(const snd_seq_addr_t& addr);
   void ProcessClientExitEvent(const snd_seq_addr_t& addr);
   void ProcessPortExitEvent(const snd_seq_addr_t& addr);
   void ProcessUdevEvent(udev_device* dev);
   void AddCard(udev_device* dev);
   void RemoveCard(int number);
 
   // Updates port_state_ and Web MIDI state from alsa_seq_state_.
   void UpdatePortStateAndGenerateEvents();
 
   // Enumerates ports. Call once after subscribing to the announce port.
   void EnumerateAlsaPorts();
   // Enumerates udev cards. Call once after initializing the udev monitor.
   bool EnumerateUdevCards();
   // Returns true if successful.
-  bool CreateAlsaOutputPort(uint32 port_index, int client_id, int port_id);
-  void DeleteAlsaOutputPort(uint32 port_index);
+  bool CreateAlsaOutputPort(uint32_t port_index, int client_id, int port_id);
+  void DeleteAlsaOutputPort(uint32_t port_index);
   // Returns true if successful.
-  bool Subscribe(uint32 port_index, int client_id, int port_id);
+  bool Subscribe(uint32_t port_index, int client_id, int port_id);
 
   AlsaSeqState alsa_seq_state_;
   MidiPortState port_state_;
 
   // ALSA seq handles.
   scoped_ptr<snd_seq_t, SndSeqDeleter> in_client_;
   int in_client_id_ = -1;
   scoped_ptr<snd_seq_t, SndSeqDeleter> out_client_;
   int out_client_id_ = -1;
 
@@ skipping 27 matching lines @@
   bool event_thread_shutdown_ = false;  // guarded by shutdown_lock_
   base::Lock shutdown_lock_;            // guards event_thread_shutdown_
 
   DISALLOW_COPY_AND_ASSIGN(MidiManagerAlsa);
 };
 
 }  // namespace midi
 }  // namespace media
 
 #endif  // MEDIA_MIDI_MIDI_MANAGER_ALSA_H_