Switch to standard integer types in chromeos/.

chromeos/dbus/cras_audio_client.cc

 // Copyright (c) 2013 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/cras_audio_client.h"
 
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/format_macros.h"
+#include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 // Error name if cras dbus call fails with empty ErrorResponse.
@@ skipping 36 matching lines @@
                                  cras::kGetNodes);
     cras_proxy_->CallMethodWithErrorCallback(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&CrasAudioClientImpl::OnGetNodes,
                    weak_ptr_factory_.GetWeakPtr(), callback),
         base::Bind(&CrasAudioClientImpl::OnError,
                    weak_ptr_factory_.GetWeakPtr(), error_callback));
   }
 
-  void SetOutputNodeVolume(uint64 node_id, int32 volume) override {
+  void SetOutputNodeVolume(uint64_t node_id, int32_t volume) override {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kSetOutputNodeVolume);
     dbus::MessageWriter writer(&method_call);
     writer.AppendUint64(node_id);
     writer.AppendInt32(volume);
     cras_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
   void SetOutputUserMute(bool mute_on) override {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kSetOutputUserMute);
     dbus::MessageWriter writer(&method_call);
     writer.AppendBool(mute_on);
     cras_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
-  void SetInputNodeGain(uint64 node_id, int32 input_gain) override {
+  void SetInputNodeGain(uint64_t node_id, int32_t input_gain) override {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kSetInputNodeGain);
     dbus::MessageWriter writer(&method_call);
     writer.AppendUint64(node_id);
     writer.AppendInt32(input_gain);
     cras_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
   void SetInputMute(bool mute_on) override {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kSetInputMute);
     dbus::MessageWriter writer(&method_call);
     writer.AppendBool(mute_on);
     cras_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
-  void SetActiveOutputNode(uint64 node_id) override {
+  void SetActiveOutputNode(uint64_t node_id) override {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kSetActiveOutputNode);
     dbus::MessageWriter writer(&method_call);
     writer.AppendUint64(node_id);
     cras_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
-  void SetActiveInputNode(uint64 node_id) override {
+  void SetActiveInputNode(uint64_t node_id) override {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kSetActiveInputNode);
     dbus::MessageWriter writer(&method_call);
     writer.AppendUint64(node_id);
     cras_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
-  void AddActiveInputNode(uint64 node_id) override {
+  void AddActiveInputNode(uint64_t node_id) override {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kAddActiveInputNode);
     dbus::MessageWriter writer(&method_call);
     writer.AppendUint64(node_id);
     cras_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
-  void RemoveActiveInputNode(uint64 node_id) override {
+  void RemoveActiveInputNode(uint64_t node_id) override {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kRemoveActiveInputNode);
     dbus::MessageWriter writer(&method_call);
     writer.AppendUint64(node_id);
     cras_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
-  void AddActiveOutputNode(uint64 node_id) override {
+  void AddActiveOutputNode(uint64_t node_id) override {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kAddActiveOutputNode);
     dbus::MessageWriter writer(&method_call);
     writer.AppendUint64(node_id);
     cras_proxy_->CallMethod(&method_call,
                             dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                             dbus::ObjectProxy::EmptyResponseCallback());
   }
 
-  void RemoveActiveOutputNode(uint64 node_id) override {
+  void RemoveActiveOutputNode(uint64_t node_id) override {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kRemoveActiveOutputNode);
     dbus::MessageWriter writer(&method_call);
     writer.AppendUint64(node_id);
     cras_proxy_->CallMethod(&method_call,
                             dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                             dbus::ObjectProxy::EmptyResponseCallback());
   }
 
-  void SwapLeftRight(uint64 node_id, bool swap) override {
+  void SwapLeftRight(uint64_t node_id, bool swap) override {
     dbus::MethodCall method_call(cras::kCrasControlInterface,
                                  cras::kSwapLeftRight);
     dbus::MessageWriter writer(&method_call);
     writer.AppendUint64(node_id);
     writer.AppendBool(swap);
     cras_proxy_->CallMethod(&method_call,
                             dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                             dbus::ObjectProxy::EmptyResponseCallback());
   }
 
@@ skipping 90 matching lines @@
     }
     FOR_EACH_OBSERVER(Observer, observers_, InputMuteChanged(mute));
   }
 
   void NodesChangedReceived(dbus::Signal* signal) {
     FOR_EACH_OBSERVER(Observer, observers_, NodesChanged());
   }
 
   void ActiveOutputNodeChangedReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
-    uint64 node_id;
+    uint64_t node_id;
     if (!reader.PopUint64(&node_id)) {
       LOG(ERROR) << "Error reading signal from cras:"
                  << signal->ToString();
     }
     FOR_EACH_OBSERVER(Observer, observers_, ActiveOutputNodeChanged(node_id));
   }
 
   void ActiveInputNodeChangedReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
-    uint64 node_id;
+    uint64_t node_id;
     if (!reader.PopUint64(&node_id)) {
       LOG(ERROR) << "Error reading signal from cras:"
                  << signal->ToString();
     }
     FOR_EACH_OBSERVER(Observer, observers_, ActiveInputNodeChanged(node_id));
   }
 
   void OnGetVolumeState(const GetVolumeStateCallback& callback,
                         dbus::Response* response) {
     bool success = true;
@@ skipping 128 matching lines @@
 
 void CrasAudioClient::Observer::OutputMuteChanged(bool mute_on) {
 }
 
 void CrasAudioClient::Observer::InputMuteChanged(bool mute_on) {
 }
 
 void CrasAudioClient::Observer::NodesChanged() {
 }
 
-void CrasAudioClient::Observer::ActiveOutputNodeChanged(uint64 node_id){
-}
+void CrasAudioClient::Observer::ActiveOutputNodeChanged(uint64_t node_id) {}
 
-void CrasAudioClient::Observer::ActiveInputNodeChanged(uint64 node_id) {
-}
+void CrasAudioClient::Observer::ActiveInputNodeChanged(uint64_t node_id) {}
 
 CrasAudioClient::CrasAudioClient() {
 }
 
 CrasAudioClient::~CrasAudioClient() {
 }
 
 // static
 CrasAudioClient* CrasAudioClient::Create() {
   return new CrasAudioClientImpl();
 }
 
 }  // namespace chromeos