Audio dbus API integration with chrome.

There is only one audio dbus API left out, GetNodes, since the protocol buffer for output data is not implemented by the audio team yet. I will added this one in once the protocol buffer is implemented.

BUG=160311


Review URL: https://chromiumcodereview.appspot.com/12681012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@191115 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 601 insertions, 0 deletions

diff --git a/chromeos/chromeos.gyp b/chromeos/chromeos.gyp
index 127d6eb..78eee8b 100644
--- a/chromeos/chromeos.gyp
+++ b/chromeos/chromeos.gyp
@@ -55,6 +55,8 @@
         'dbus/bluetooth_out_of_band_client.h',
         'dbus/bluetooth_property.cc',
         'dbus/bluetooth_property.h',
+        'dbus/cras_audio_client.cc',
+        'dbus/cras_audio_client.h',
         'dbus/cros_disks_client.cc',
         'dbus/cros_disks_client.h',
         'dbus/cryptohome_client.cc',
@@ -146,6 +148,8 @@
         'dbus/system_clock_client.h',
         'dbus/update_engine_client.cc',
         'dbus/update_engine_client.h',
+        'dbus/volume_state.cc',
+        'dbus/volume_state.h',
         'disks/disk_mount_manager.cc',
         'disks/disk_mount_manager.h',
         'display/output_configurator.cc',
@@ -277,6 +281,8 @@
         'dbus/mock_bluetooth_node_client.h',
         'dbus/mock_bluetooth_out_of_band_client.cc',
         'dbus/mock_bluetooth_out_of_band_client.h',
+        'dbus/mock_cras_audio_client.cc',
+        'dbus/mock_cras_audio_client.h',
         'dbus/mock_cros_disks_client.cc',
         'dbus/mock_cros_disks_client.h',
         'dbus/mock_cryptohome_client.cc',
diff --git a/chromeos/dbus/cras_audio_client.cc b/chromeos/dbus/cras_audio_client.cc
new file mode 100644
index 0000000..9e39fef
--- /dev/null
+++ b/chromeos/dbus/cras_audio_client.cc
@@ -0,0 +1,360 @@
+// 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 "base/bind.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 {
+}  // namespace
+
+namespace chromeos {
+
+// The CrasAudioClient implementation used in production.
+class CrasAudioClientImpl : public CrasAudioClient {
+ public:
+  explicit CrasAudioClientImpl(dbus::Bus* bus)
+      : cras_proxy_(NULL),
+        weak_ptr_factory_(this) {
+    cras_proxy_ = bus->GetObjectProxy(
+        cras::kCrasServiceName,
+        dbus::ObjectPath(cras::kCrasServicePath));
+
+    // Monitor the D-Bus signal for output volume change.
+    cras_proxy_->ConnectToSignal(
+        cras::kCrasControlInterface,
+        cras::kOutputVolumeChanged,
+        base::Bind(&CrasAudioClientImpl::OutputVolumeChangedReceived,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&CrasAudioClientImpl::SignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
+
+    // Monitor the D-Bus signal for output mute change.
+    cras_proxy_->ConnectToSignal(
+        cras::kCrasControlInterface,
+        cras::kOutputMuteChanged,
+        base::Bind(&CrasAudioClientImpl::OutputMuteChangedReceived,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&CrasAudioClientImpl::SignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
+
+    // Monitor the D-Bus signal for input gain change.
+    cras_proxy_->ConnectToSignal(
+        cras::kCrasControlInterface,
+        cras::kInputGainChanged,
+        base::Bind(&CrasAudioClientImpl::InputGainChangedReceived,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&CrasAudioClientImpl::SignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
+
+    // Monitor the D-Bus signal for input mute change.
+    cras_proxy_->ConnectToSignal(
+        cras::kCrasControlInterface,
+        cras::kInputMuteChanged,
+        base::Bind(&CrasAudioClientImpl::InputMuteChangedReceived,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&CrasAudioClientImpl::SignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
+
+    // Monitor the D-Bus signal for nodes change.
+    cras_proxy_->ConnectToSignal(
+        cras::kCrasControlInterface,
+        cras::kNodesChanged,
+        base::Bind(&CrasAudioClientImpl::NodesChangedReceived,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&CrasAudioClientImpl::SignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
+
+    // Monitor the D-Bus signal for active output node change.
+    cras_proxy_->ConnectToSignal(
+        cras::kCrasControlInterface,
+        cras::kActiveOutputNodeChanged,
+        base::Bind(&CrasAudioClientImpl::ActiveOutputNodeChangedReceived,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&CrasAudioClientImpl::SignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
+
+    // Monitor the D-Bus signal for active input node change.
+    cras_proxy_->ConnectToSignal(
+        cras::kCrasControlInterface,
+        cras::kActiveInputNodeChanged,
+        base::Bind(&CrasAudioClientImpl::ActiveInputNodeChangedReceived,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&CrasAudioClientImpl::SignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  virtual ~CrasAudioClientImpl() {
+  }
+
+  // CrasAudioClient overrides:
+  virtual void AddObserver(Observer* observer) OVERRIDE {
+    observers_.AddObserver(observer);
+  }
+
+  virtual void RemoveObserver(Observer* observer) OVERRIDE {
+    observers_.RemoveObserver(observer);
+  }
+
+  virtual bool HasObserver(Observer* observer) OVERRIDE {
+    return observers_.HasObserver(observer);
+  }
+
+  virtual void GetVolumeState(const GetVolumeStateCallback& callback) OVERRIDE {
+    dbus::MethodCall method_call(cras::kCrasControlInterface,
+                                 cras::kGetVolumeState);
+    cras_proxy_->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&CrasAudioClientImpl::OnGetVolumeState,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
+  }
+
+  virtual void SetOutputVolume(int32 volume) OVERRIDE {
+    dbus::MethodCall method_call(cras::kCrasControlInterface,
+                                 cras::kSetOutputVolume);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendInt32(volume);
+    cras_proxy_->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        dbus::ObjectProxy::EmptyResponseCallback());
+  }
+
+  virtual void SetOutputMute(bool mute_on) OVERRIDE {
+    dbus::MethodCall method_call(cras::kCrasControlInterface,
+                                 cras::kSetOutputMute);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendBool(mute_on);
+    cras_proxy_->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        dbus::ObjectProxy::EmptyResponseCallback());
+  }
+
+  virtual void SetInputGain(int32 input_gain) OVERRIDE {
+    dbus::MethodCall method_call(cras::kCrasControlInterface,
+                                 cras::kSetInputGain);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendInt32(input_gain);
+    cras_proxy_->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        dbus::ObjectProxy::EmptyResponseCallback());
+  }
+
+  virtual 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());
+  }
+
+  virtual void SetActiveOutputNode(uint64 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());
+  }
+
+  virtual void SetActiveInputNode(uint64 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());
+  }
+
+ private:
+  // Called when the cras signal is initially connected.
+  void SignalConnected(const std::string& interface_name,
+                       const std::string& signal_name,
+                       bool success) {
+    LOG_IF(ERROR, !success)
+        << "Failed to connect to cras signal:" << signal_name;
+  }
+
+  // Called when a OutputVolumeChanged signal is received.
+  void OutputVolumeChangedReceived(dbus::Signal* signal) {
+    dbus::MessageReader reader(signal);
+    int32 volume;
+    if (!reader.PopInt32(&volume)) {
+      LOG(ERROR) << "Error reading signal from cras:"
+                 << signal->ToString();
+    }
+    FOR_EACH_OBSERVER(Observer, observers_, OutputVolumeChanged(volume));
+  }
+
+  // Called when a OutputMuteChanged signal is received.
+  void OutputMuteChangedReceived(dbus::Signal* signal) {
+    dbus::MessageReader reader(signal);
+    bool mute;
+    if (!reader.PopBool(&mute)) {
+      LOG(ERROR) << "Error reading signal from cras:"
+                 << signal->ToString();
+    }
+    FOR_EACH_OBSERVER(Observer, observers_, OutputMuteChanged(mute));
+  }
+
+  // Called when a InputGainChanged signal is received.
+  void InputGainChangedReceived(dbus::Signal* signal) {
+    dbus::MessageReader reader(signal);
+    int32 gain;
+    if (!reader.PopInt32(&gain)) {
+      LOG(ERROR) << "Error reading signal from cras:"
+                 << signal->ToString();
+    }
+    FOR_EACH_OBSERVER(Observer, observers_, InputGainChanged(gain));
+  }
+
+  // Called when a InputMuteChanged signal is received.
+  void InputMuteChangedReceived(dbus::Signal* signal) {
+    dbus::MessageReader reader(signal);
+    bool mute;
+    if (!reader.PopBool(&mute)) {
+      LOG(ERROR) << "Error reading signal from cras:"
+                 << signal->ToString();
+    }
+    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;
+    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;
+    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) {
+    if (!response) {
+      LOG(ERROR) << "Error calling " << cras::kGetVolumeState;
+      return;
+    }
+
+    dbus::MessageReader reader(response);
+    VolumeState volume_state;
+    if (!reader.PopInt32(&volume_state.output_volume) ||
+        !reader.PopBool(&volume_state.output_mute) ||
+        !reader.PopInt32(&volume_state.input_gain) ||
+        !reader.PopBool(&volume_state.input_mute)) {
+      LOG(ERROR) << "Error reading response from cras: "
+                 << response->ToString();
+    }
+    callback.Run(volume_state);
+  }
+
+  dbus::ObjectProxy* cras_proxy_;
+  ObserverList<Observer> observers_;
+
+  // Note: This should remain the last member so it'll be destroyed and
+  // invalidate its weak pointers before any other members are destroyed.
+  base::WeakPtrFactory<CrasAudioClientImpl> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CrasAudioClientImpl);
+};
+
+// The CrasAudioClient implementation used on Linux desktop,
+// which does nothing.
+class CrasAudioClientStubImpl : public CrasAudioClient {
+ public:
+  CrasAudioClientStubImpl() {
+    LOG(ERROR) << "CrasAudioClientStubImpl is created";
+  }
+  ~CrasAudioClientStubImpl() {}
+
+  // CrasAudioClient overrides:
+  // TODO(jennyz): Implement the observers and callbacks in the stub for UI
+  // testing.
+  virtual void AddObserver(Observer* observer) OVERRIDE {}
+  virtual void RemoveObserver(Observer* observer) OVERRIDE {}
+  virtual bool HasObserver(Observer* observer) OVERRIDE { return false; }
+  virtual void GetVolumeState(const GetVolumeStateCallback& callback) OVERRIDE {
+  }
+  virtual void SetOutputVolume(int32 volume) OVERRIDE {}
+  virtual void SetOutputMute(bool mute_on) OVERRIDE {}
+  virtual void SetInputGain(int32 input_gain) OVERRIDE {}
+  virtual void SetInputMute(bool mute_on) OVERRIDE {}
+  virtual void SetActiveOutputNode(uint64 node_id) OVERRIDE {}
+  virtual void SetActiveInputNode(uint64 node_id) OVERRIDE {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CrasAudioClientStubImpl);
+};
+
+CrasAudioClient::Observer::~Observer() {
+}
+
+void CrasAudioClient::Observer::OutputVolumeChanged(int32 volume) {
+}
+
+void CrasAudioClient::Observer::OutputMuteChanged(bool mute_on) {
+}
+
+void CrasAudioClient::Observer::InputGainChanged(int gain) {
+}
+
+void CrasAudioClient::Observer::InputMuteChanged(bool mute_on) {
+}
+
+void CrasAudioClient::Observer::NodesChanged() {
+}
+
+void CrasAudioClient::Observer::ActiveOutputNodeChanged(uint64 node_id){
+}
+
+void CrasAudioClient::Observer::ActiveInputNodeChanged(uint64 node_id) {
+}
+
+CrasAudioClient::CrasAudioClient() {
+}
+
+CrasAudioClient::~CrasAudioClient() {
+}
+
+// static
+CrasAudioClient* CrasAudioClient::Create(
+    DBusClientImplementationType type,
+    dbus::Bus* bus) {
+  if (type == REAL_DBUS_CLIENT_IMPLEMENTATION) {
+    return new CrasAudioClientImpl(bus);
+  }
+  DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
+  return new CrasAudioClientStubImpl();
+}
+
+}  // namespace chromeos
diff --git a/chromeos/dbus/cras_audio_client.h b/chromeos/dbus/cras_audio_client.h
new file mode 100644
index 0000000..969bfb0
--- /dev/null
+++ b/chromeos/dbus/cras_audio_client.h
@@ -0,0 +1,88 @@
+// 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.
+
+#ifndef CHROMEOS_DBUS_CRAS_AUDIO_CLIENT_H_
+#define CHROMEOS_DBUS_CRAS_AUDIO_CLIENT_H_
+
+#include "base/callback.h"
+#include "base/observer_list.h"
+#include "chromeos/chromeos_export.h"
+#include "chromeos/dbus/dbus_client_implementation_type.h"
+#include "chromeos/dbus/volume_state.h"
+
+namespace dbus {
+class Bus;
+}  // namespace
+
+namespace chromeos {
+
+// CrasAudioClient is used to communicate with the cras audio dbus interface.
+class CHROMEOS_EXPORT CrasAudioClient {
+ public:
+  // Interface for observing changes from the cras audio changes.
+  class Observer {
+   public:
+    // Called when audio output device volume changed.
+    virtual void OutputVolumeChanged(int volume);
+    virtual void OutputMuteChanged(bool mute_on);
+    virtual void InputGainChanged(int gain);
+    virtual void InputMuteChanged(bool mute_on);
+    virtual void NodesChanged();
+    virtual void ActiveOutputNodeChanged(uint64 node_id);
+    virtual void ActiveInputNodeChanged(uint64 node_id);
+
+   protected:
+    virtual ~Observer();
+  };
+
+  virtual ~CrasAudioClient();
+
+  // Adds and removes the observer.
+  virtual void AddObserver(Observer* observer) = 0;
+  virtual void RemoveObserver(Observer* observer) = 0;
+  // Returns true if this object has the given observer.
+  virtual bool HasObserver(Observer* observer) = 0;
+
+  // GetVolumeStateCallback is used for GetVolumeState method. It receives
+  // 1 argument, |volume_state| which containing both input and  output volume
+  // state data.
+  typedef base::Callback<void(const VolumeState&)> GetVolumeStateCallback;
+
+  // Gets the volume state, asynchronously.
+  virtual void GetVolumeState(const GetVolumeStateCallback& callback) = 0;
+
+  // Sets output volume to |volume|, in the range of [0, 100].
+  virtual void  SetOutputVolume(int32 volume) = 0;
+
+  // Sets output mute state to |mute_on| value.
+  virtual void SetOutputMute(bool mute_on) = 0;
+
+  // Sets input gain to |input_gain|. |input_gain| is specified in dBFS * 100.
+  virtual void SetInputGain(int32 input_gain) = 0;
+
+  // Sets input mute state to |mute_on| value.
+  virtual void SetInputMute(bool mute_on) = 0;
+
+  // Sets the active output noe to |node_id|.
+  virtual void SetActiveOutputNode(uint64 node_id) = 0;
+
+  // Sets the active input noe to |node_id|.
+  virtual void SetActiveInputNode(uint64 node_id) = 0;
+
+  // Creates the instance.
+  static CrasAudioClient* Create(DBusClientImplementationType type,
+                                 dbus::Bus* bus);
+
+ protected:
+  // Create() should be used instead.
+  CrasAudioClient();
+
+ private:
+
+  DISALLOW_COPY_AND_ASSIGN(CrasAudioClient);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_DBUS_CRAS_AUDIO_CLIENT_H_
diff --git a/chromeos/dbus/dbus_thread_manager.cc b/chromeos/dbus/dbus_thread_manager.cc
index 4325505..cc286b5 100644
--- a/chromeos/dbus/dbus_thread_manager.cc
+++ b/chromeos/dbus/dbus_thread_manager.cc
@@ -17,6 +17,7 @@
 #include "chromeos/dbus/bluetooth_manager_client.h"
 #include "chromeos/dbus/bluetooth_node_client.h"
 #include "chromeos/dbus/bluetooth_out_of_band_client.h"
+#include "chromeos/dbus/cras_audio_client.h"
 #include "chromeos/dbus/cros_disks_client.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_client_implementation_type.h"
@@ -99,6 +100,8 @@ class DBusThreadManagerImpl : public DBusThreadManager {
         client_type_, system_bus_.get(), bluetooth_device_client_.get()));
     bluetooth_out_of_band_client_.reset(BluetoothOutOfBandClient::Create(
         client_type_, system_bus_.get()));
+    cras_audio_client_.reset(CrasAudioClient::Create(
+        client_type_, system_bus_.get()));
     cros_disks_client_.reset(
         CrosDisksClient::Create(client_type_, system_bus_.get()));
     cryptohome_client_.reset(
@@ -262,6 +265,10 @@ class DBusThreadManagerImpl : public DBusThreadManager {
     return bluetooth_out_of_band_client_.get();
   }
 
+  virtual CrasAudioClient* GetCrasAudioClient() OVERRIDE {
+    return cras_audio_client_.get();
+  }
+
   virtual CrosDisksClient* GetCrosDisksClient() OVERRIDE {
     return cros_disks_client_.get();
   }
@@ -419,6 +426,7 @@ class DBusThreadManagerImpl : public DBusThreadManager {
   scoped_ptr<BluetoothManagerClient> bluetooth_manager_client_;
   scoped_ptr<BluetoothNodeClient> bluetooth_node_client_;
   scoped_ptr<BluetoothOutOfBandClient> bluetooth_out_of_band_client_;
+  scoped_ptr<CrasAudioClient> cras_audio_client_;
   scoped_ptr<CrosDisksClient> cros_disks_client_;
   scoped_ptr<CryptohomeClient> cryptohome_client_;
   scoped_ptr<DebugDaemonClient> debug_daemon_client_;
diff --git a/chromeos/dbus/dbus_thread_manager.h b/chromeos/dbus/dbus_thread_manager.h
index e34a234..0002ebb 100644
--- a/chromeos/dbus/dbus_thread_manager.h
+++ b/chromeos/dbus/dbus_thread_manager.h
@@ -32,6 +32,7 @@ class BluetoothInputClient;
 class BluetoothManagerClient;
 class BluetoothNodeClient;
 class BluetoothOutOfBandClient;
+class CrasAudioClient;
 class CrosDisksClient;
 class CryptohomeClient;
 class DebugDaemonClient;
@@ -130,6 +131,7 @@ class CHROMEOS_EXPORT DBusThreadManager {
   virtual BluetoothManagerClient* GetBluetoothManagerClient() = 0;
   virtual BluetoothNodeClient* GetBluetoothNodeClient() = 0;
   virtual BluetoothOutOfBandClient* GetBluetoothOutOfBandClient() = 0;
+  virtual CrasAudioClient* GetCrasAudioClient() = 0;
   virtual CrosDisksClient* GetCrosDisksClient() = 0;
   virtual CryptohomeClient* GetCryptohomeClient() = 0;
   virtual DebugDaemonClient* GetDebugDaemonClient() = 0;
diff --git a/chromeos/dbus/mock_cras_audio_client.cc b/chromeos/dbus/mock_cras_audio_client.cc
new file mode 100644
index 0000000..31f21e5
--- /dev/null
+++ b/chromeos/dbus/mock_cras_audio_client.cc
@@ -0,0 +1,13 @@
+// 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/mock_cras_audio_client.h"
+
+
+namespace chromeos {
+
+MockCrasAudioClient::MockCrasAudioClient() {}
+MockCrasAudioClient::~MockCrasAudioClient() {}
+
+}  // namespace chromeos
diff --git a/chromeos/dbus/mock_cras_audio_client.h b/chromeos/dbus/mock_cras_audio_client.h
new file mode 100644
index 0000000..25e6a24
--- /dev/null
+++ b/chromeos/dbus/mock_cras_audio_client.h
@@ -0,0 +1,35 @@
+// 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.
+
+#ifndef CHROMEOS_DBUS_MOCK_CRAS_AUDIO_CLIENT_H_
+#define CHROMEOS_DBUS_MOCK_CRAS_AUDIO_CLIENT_H_
+
+#include "chromeos/dbus/cras_audio_client.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace chromeos {
+
+class MockCrasAudioClient : public CrasAudioClient {
+ public:
+  MockCrasAudioClient();
+  virtual ~MockCrasAudioClient();
+
+  MOCK_METHOD1(AddObserver, void(Observer*));
+  MOCK_METHOD1(RemoveObserver, void(Observer*));
+  MOCK_METHOD1(HasObserver, bool(Observer*));
+  MOCK_METHOD1(GetVolumeState, void(const GetVolumeStateCallback&));
+  MOCK_METHOD1(SetOutputVolume, void(int32));
+  MOCK_METHOD1(SetOutputMute, void(bool));
+  MOCK_METHOD1(SetInputGain, void(int32));
+  MOCK_METHOD1(SetInputMute, void(bool));
+  MOCK_METHOD1(SetActiveOutputNode, void(uint64));
+  MOCK_METHOD1(SetActiveInputNode, void(uint64));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockCrasAudioClient);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_DBUS_MOCK_CRAS_AUDIO_CLIENT_H_
diff --git a/chromeos/dbus/mock_dbus_thread_manager.cc b/chromeos/dbus/mock_dbus_thread_manager.cc
index a9cfc63..f3dbdc6 100644
--- a/chromeos/dbus/mock_dbus_thread_manager.cc
+++ b/chromeos/dbus/mock_dbus_thread_manager.cc
@@ -11,6 +11,7 @@
 #include "chromeos/dbus/mock_bluetooth_manager_client.h"
 #include "chromeos/dbus/mock_bluetooth_node_client.h"
 #include "chromeos/dbus/mock_bluetooth_out_of_band_client.h"
+#include "chromeos/dbus/mock_cras_audio_client.h"
 #include "chromeos/dbus/mock_cros_disks_client.h"
 #include "chromeos/dbus/mock_cryptohome_client.h"
 #include "chromeos/dbus/mock_debug_daemon_client.h"
@@ -49,6 +50,7 @@ MockDBusThreadManager::MockDBusThreadManager()
       mock_bluetooth_manager_client_(new MockBluetoothManagerClient),
       mock_bluetooth_node_client_(new MockBluetoothNodeClient),
       mock_bluetooth_out_of_band_client_(new MockBluetoothOutOfBandClient),
+      mock_cras_audio_client_(new MockCrasAudioClient),
       mock_cros_disks_client_(new MockCrosDisksClient),
       mock_cryptohome_client_(new MockCryptohomeClient),
       mock_debugdaemon_client_(new MockDebugDaemonClient),
@@ -87,6 +89,8 @@ MockDBusThreadManager::MockDBusThreadManager()
       .WillRepeatedly(Return(mock_bluetooth_node_client_.get()));
   EXPECT_CALL(*this, GetBluetoothOutOfBandClient())
       .WillRepeatedly(Return(mock_bluetooth_out_of_band_client_.get()));
+  EXPECT_CALL(*this, GetCrasAudioClient())
+      .WillRepeatedly(Return(mock_cras_audio_client()));
   EXPECT_CALL(*this, GetCrosDisksClient())
       .WillRepeatedly(Return(mock_cros_disks_client()));
   EXPECT_CALL(*this, GetCryptohomeClient())
@@ -159,6 +163,12 @@ MockDBusThreadManager::MockDBusThreadManager()
       .WillRepeatedly(Return(power_policy_controller_.get()));
 
   // These observers calls are used in ChromeBrowserMainPartsChromeos.
+  EXPECT_CALL(*mock_cras_audio_client_.get(), AddObserver(_))
+      .Times(AnyNumber());
+  EXPECT_CALL(*mock_cras_audio_client_.get(), RemoveObserver(_))
+      .Times(AnyNumber());
+  EXPECT_CALL(*mock_cras_audio_client_.get(), HasObserver(_))
+      .Times(AnyNumber());
   EXPECT_CALL(*mock_session_manager_client_.get(), AddObserver(_))
       .Times(AnyNumber());
   EXPECT_CALL(*mock_session_manager_client_.get(), RemoveObserver(_))
diff --git a/chromeos/dbus/mock_dbus_thread_manager.h b/chromeos/dbus/mock_dbus_thread_manager.h
index 12a4906e..ef60c8a 100644
--- a/chromeos/dbus/mock_dbus_thread_manager.h
+++ b/chromeos/dbus/mock_dbus_thread_manager.h
@@ -26,6 +26,7 @@ class MockBluetoothInputClient;
 class MockBluetoothManagerClient;
 class MockBluetoothNodeClient;
 class MockBluetoothOutOfBandClient;
+class MockCrasAudioClient;
 class MockCrosDisksClient;
 class MockCryptohomeClient;
 class MockDebugDaemonClient;
@@ -70,6 +71,7 @@ class MockDBusThreadManager : public DBusThreadManager {
   MOCK_METHOD0(GetBluetoothManagerClient, BluetoothManagerClient*(void));
   MOCK_METHOD0(GetBluetoothNodeClient, BluetoothNodeClient*(void));
   MOCK_METHOD0(GetBluetoothOutOfBandClient, BluetoothOutOfBandClient*(void));
+  MOCK_METHOD0(GetCrasAudioClient, CrasAudioClient*(void));
   MOCK_METHOD0(GetCrosDisksClient, CrosDisksClient*(void));
   MOCK_METHOD0(GetCryptohomeClient, CryptohomeClient*(void));
   MOCK_METHOD0(GetDebugDaemonClient, DebugDaemonClient*(void));
@@ -125,6 +127,9 @@ class MockDBusThreadManager : public DBusThreadManager {
   MockBluetoothOutOfBandClient* mock_bluetooth_out_of_band_client() {
     return mock_bluetooth_out_of_band_client_.get();
   }
+  MockCrasAudioClient* mock_cras_audio_client() {
+    return mock_cras_audio_client_.get();
+  }
   MockCrosDisksClient* mock_cros_disks_client() {
     return mock_cros_disks_client_.get();
   }
@@ -207,6 +212,7 @@ class MockDBusThreadManager : public DBusThreadManager {
   scoped_ptr<MockBluetoothManagerClient> mock_bluetooth_manager_client_;
   scoped_ptr<MockBluetoothNodeClient> mock_bluetooth_node_client_;
   scoped_ptr<MockBluetoothOutOfBandClient> mock_bluetooth_out_of_band_client_;
+  scoped_ptr<MockCrasAudioClient> mock_cras_audio_client_;
   scoped_ptr<MockCrosDisksClient> mock_cros_disks_client_;
   scoped_ptr<MockCryptohomeClient> mock_cryptohome_client_;
   scoped_ptr<MockDebugDaemonClient> mock_debugdaemon_client_;
diff --git a/chromeos/dbus/mock_dbus_thread_manager_without_gmock.cc b/chromeos/dbus/mock_dbus_thread_manager_without_gmock.cc
index 5e9b866..49c5bbe 100644
--- a/chromeos/dbus/mock_dbus_thread_manager_without_gmock.cc
+++ b/chromeos/dbus/mock_dbus_thread_manager_without_gmock.cc
@@ -82,6 +82,11 @@ BluetoothNodeClient*
   return NULL;
 }
 
+CrasAudioClient* MockDBusThreadManagerWithoutGMock::GetCrasAudioClient() {
+  NOTIMPLEMENTED();
+  return NULL;
+}
+
 CrosDisksClient* MockDBusThreadManagerWithoutGMock::GetCrosDisksClient() {
   NOTIMPLEMENTED();
   return NULL;
diff --git a/chromeos/dbus/mock_dbus_thread_manager_without_gmock.h b/chromeos/dbus/mock_dbus_thread_manager_without_gmock.h
index 70530bb..04853ed 100644
--- a/chromeos/dbus/mock_dbus_thread_manager_without_gmock.h
+++ b/chromeos/dbus/mock_dbus_thread_manager_without_gmock.h
@@ -46,6 +46,7 @@ class MockDBusThreadManagerWithoutGMock : public DBusThreadManager {
   virtual BluetoothInputClient* GetBluetoothInputClient() OVERRIDE;
   virtual BluetoothManagerClient* GetBluetoothManagerClient() OVERRIDE;
   virtual BluetoothNodeClient* GetBluetoothNodeClient() OVERRIDE;
+  virtual CrasAudioClient* GetCrasAudioClient() OVERRIDE;
   virtual CrosDisksClient* GetCrosDisksClient() OVERRIDE;
   virtual CryptohomeClient* GetCryptohomeClient() OVERRIDE;
   virtual DebugDaemonClient* GetDebugDaemonClient() OVERRIDE;
diff --git a/chromeos/dbus/volume_state.cc b/chromeos/dbus/volume_state.cc
new file mode 100644
index 0000000..da0ff13
--- /dev/null
+++ b/chromeos/dbus/volume_state.cc
@@ -0,0 +1,40 @@
+// 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/volume_state.h"
+
+#include "base/format_macros.h"
+#include "base/stringprintf.h"
+
+namespace chromeos {
+
+VolumeState::VolumeState()
+    : output_volume(0),
+      output_mute(false),
+      input_gain(0),
+      input_mute(false) {
+}
+
+std::string VolumeState::ToString() const {
+  std::string result;
+  base::StringAppendF(&result,
+                      "output_volume = %d ",
+                      output_volume);
+  base::StringAppendF(&result,
+                      "output_mute = %s ",
+                      output_mute ? "true" : "false");
+  base::StringAppendF(&result,
+                      "output_mute = %s ",
+                      output_mute ? "true" : "false");
+  base::StringAppendF(&result,
+                      "input_gain = %d ",
+                      input_gain);
+  base::StringAppendF(&result,
+                      "input_mute = %s ",
+                      input_mute ? "true" : "false");
+
+  return result;
+}
+
+}  // namespace chromeos
diff --git a/chromeos/dbus/volume_state.h b/chromeos/dbus/volume_state.h
new file mode 100644
index 0000000..7fafd6e
--- /dev/null
+++ b/chromeos/dbus/volume_state.h
@@ -0,0 +1,27 @@
+// 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.
+
+#ifndef CHROMEOS_DBUS_VOLUME_STATE_H_
+#define CHROMEOS_DBUS_VOLUME_STATE_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "chromeos/chromeos_export.h"
+
+namespace chromeos {
+
+struct CHROMEOS_EXPORT VolumeState {
+  int32 output_volume;
+  bool output_mute;
+  int32 input_gain;
+  bool input_mute;
+
+  VolumeState();
+  std::string ToString() const;
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_DBUS_VOLUME_STATE_H_