Switch to standard integer types in chromeos/.

chromeos/dbus/audio_dsp_client.cc

 // Copyright 2015 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 "chromeos/dbus/audio_dsp_client.h"
 
+#include <stdint.h>
+
 #include "base/bind.h"
+#include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/observer_list.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 
 namespace chromeos {
 namespace {
@@ skipping 106 matching lines @@
                       const VoidDBusMethodCallback& callback) override;
   void SetNightMode(bool standby,
                     const VoidDBusMethodCallback& callback) override;
   void GetNightMode(const BoolDBusMethodCallback& callback) override;
   void SetTreble(double db_fs, const VoidDBusMethodCallback& callback) override;
   void GetTreble(const DoubleDBusMethodCallback& callback) override;
   void SetBass(double db_fs, const VoidDBusMethodCallback& callback) override;
   void GetBass(const DoubleDBusMethodCallback& callback) override;
   void GetCapabilitiesOEM(
       const ThreeStringDBusMethodCallback& callback) override;
-  void SetCapabilitiesOEM(uint32 speaker_id,
+  void SetCapabilitiesOEM(uint32_t speaker_id,
                           const std::string& speaker_capabilities,
                           const std::string& driver_capabilities,
                           const VoidDBusMethodCallback& callback) override;
-  void GetFilterConfigOEM(uint32 speaker_id,
+  void GetFilterConfigOEM(uint32_t speaker_id,
                           const TwoStringDBusMethodCallback& callback) override;
   void SetFilterConfigOEM(const std::string& speaker_config,
                           const std::string& driver_config,
                           const VoidDBusMethodCallback& callback) override;
-  void SetSourceType(uint16 source_type,
+  void SetSourceType(uint16_t source_type,
                      const VoidDBusMethodCallback& callback) override;
   void AmplifierVolumeChanged(double db_spl,
                               const VoidDBusMethodCallback& callback) override;
 
  private:
   // Handles Error signal and notifies |observers_|.
   void OnError(dbus::Signal* signal);
 
   // Handles the result of signal connection setup.
   void OnSignalConnected(const std::string& interface,
@@ skipping 126 matching lines @@
     const ThreeStringDBusMethodCallback& callback) {
   dbus::MethodCall method_call(audio_dsp::kAudioDspInterface,
                                audio_dsp::kGetCapabilitiesOEMMethod);
   dbus::MessageWriter writer(&method_call);
   DCHECK(proxy_);
   proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                      base::Bind(&OnThreeStringDBusMethod, callback));
 }
 
 void AudioDspClientImpl::SetCapabilitiesOEM(
-    uint32 speaker_id,
+    uint32_t speaker_id,
     const std::string& speaker_capabilities,
     const std::string& driver_capabilities,
     const VoidDBusMethodCallback& callback) {
   dbus::MethodCall method_call(audio_dsp::kAudioDspInterface,
                                audio_dsp::kSetCapabilitiesOEMMethod);
   dbus::MessageWriter writer(&method_call);
   writer.AppendInt32(speaker_id);
   writer.AppendString(speaker_capabilities);
   writer.AppendString(driver_capabilities);
   DCHECK(proxy_);
   proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                      base::Bind(&OnVoidDBusMethod, callback));
 }
 
 void AudioDspClientImpl::GetFilterConfigOEM(
-    uint32 speaker_id,
+    uint32_t speaker_id,
     const TwoStringDBusMethodCallback& callback) {
   dbus::MethodCall method_call(audio_dsp::kAudioDspInterface,
                                audio_dsp::kGetFilterConfigOEMMethod);
   dbus::MessageWriter writer(&method_call);
   writer.AppendInt32(speaker_id);
   DCHECK(proxy_);
   proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                      base::Bind(&OnTwoStringDBusMethod, callback));
 }
 
 void AudioDspClientImpl::SetFilterConfigOEM(
     const std::string& speaker_config,
     const std::string& driver_config,
     const VoidDBusMethodCallback& callback) {
   dbus::MethodCall method_call(audio_dsp::kAudioDspInterface,
                                audio_dsp::kSetFilterConfigOEMMethod);
   dbus::MessageWriter writer(&method_call);
   writer.AppendString(speaker_config);
   writer.AppendString(driver_config);
   DCHECK(proxy_);
   proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                      base::Bind(&OnVoidDBusMethod, callback));
 }
 
-void AudioDspClientImpl::SetSourceType(uint16 source_type,
+void AudioDspClientImpl::SetSourceType(uint16_t source_type,
                                        const VoidDBusMethodCallback& callback) {
   dbus::MethodCall method_call(audio_dsp::kAudioDspInterface,
                                audio_dsp::kSetSourceTypeMethod);
   dbus::MessageWriter writer(&method_call);
   writer.AppendUint16(source_type);
   DCHECK(proxy_);
   proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                      base::Bind(&OnVoidDBusMethod, callback));
 }
 
 void AudioDspClientImpl::AmplifierVolumeChanged(
     double db_spl,
     const VoidDBusMethodCallback& callback) {
   dbus::MethodCall method_call(audio_dsp::kAudioDspInterface,
                                audio_dsp::kAmplifierVolumeChangedMethod);
   dbus::MessageWriter writer(&method_call);
   writer.AppendDouble(db_spl);
   DCHECK(proxy_);
   proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                      base::Bind(&OnVoidDBusMethod, callback));
 }
 
 void AudioDspClientImpl::OnError(dbus::Signal* signal) {
   dbus::MessageReader reader(signal);
-  int32 error_code = 0;
+  int32_t error_code = 0;
   if (!reader.PopInt32(&error_code)) {
     LOG(ERROR) << "Invalid signal: " << signal->ToString();
     return;
   }
   FOR_EACH_OBSERVER(Observer, observers_, OnError(error_code));
 }
 
 void AudioDspClientImpl::OnSignalConnected(const std::string& interface,
                                            const std::string& signal,
                                            bool succeeded) {
   LOG_IF(ERROR, !succeeded) << "Connect to " << interface << " " << signal
                             << " failed.";
 }
 
 }  // anonymous namespace
 
 AudioDspClient::AudioDspClient() {
 }
 
 AudioDspClient::~AudioDspClient() {
 }
 
 // static
 AudioDspClient* AudioDspClient::Create() {
   return new AudioDspClientImpl();
 }
 
 }  // namespace chromeos