Add DBus bindings for amplifier and DSP components.

BUG=470919

Review URL: https://codereview.chromium.org/993253004

Cr-Commit-Position: refs/heads/master@{#323047}

13 files changed, 1163 insertions, 15 deletions

diff --git a/chromeos/chromeos.gyp b/chromeos/chromeos.gyp
index 07d6536..1cf4e8e 100644
--- a/chromeos/chromeos.gyp
+++ b/chromeos/chromeos.gyp
@@ -49,8 +49,12 @@
       'cryptohome/homedir_methods.h',
       'cryptohome/system_salt_getter.cc',
       'cryptohome/system_salt_getter.h',
+      'dbus/amplifier_client.cc',
+      'dbus/amplifier_client.h',
       'dbus/ap_manager_client.cc',
       'dbus/ap_manager_client.h',
+      'dbus/audio_dsp_client.cc',
+      'dbus/audio_dsp_client.h',
       'dbus/audio_node.cc',
       'dbus/audio_node.h',
       'dbus/blocking_method_caller.cc',
@@ -106,8 +110,12 @@
       'dbus/debug_daemon_client.h',
       'dbus/easy_unlock_client.cc',
       'dbus/easy_unlock_client.h',
+      'dbus/fake_amplifier_client.cc',
+      'dbus/fake_amplifier_client.h',
       'dbus/fake_ap_manager_client.cc',
       'dbus/fake_ap_manager_client.h',
+      'dbus/fake_audio_dsp_client.cc',
+      'dbus/fake_audio_dsp_client.h',
       'dbus/fake_bluetooth_adapter_client.cc',
       'dbus/fake_bluetooth_adapter_client.h',
       'dbus/fake_bluetooth_agent_manager_client.cc',
diff --git a/chromeos/dbus/amplifier_client.cc b/chromeos/dbus/amplifier_client.cc
new file mode 100644
index 0000000..d1af700
--- /dev/null
+++ b/chromeos/dbus/amplifier_client.cc
@@ -0,0 +1,185 @@
+// 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/amplifier_client.h"
+
+#include "base/bind.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 {
+
+// TODO(benchan): Move these DBus constants to system_api.
+namespace amplifier {
+
+const char kAmplifierInterface[] = "org.chromium.Amplifier";
+const char kAmplifierServiceName[] = "org.chromium.Amplifier";
+const char kAmplifierServicePath[] = "/org/chromium/Amplifier";
+const char kInitializeMethod[] = "Initialize";
+const char kSetStandbyModeMethod[] = "SetStandbyMode";
+const char kSetVolumeMethod[] = "SetVolume";
+const char kErrorSignal[] = "Error";
+
+}  // namespace amplifier
+
+void OnBoolDBusMethod(const BoolDBusMethodCallback& callback,
+                      dbus::Response* response) {
+  if (!response) {
+    callback.Run(DBUS_METHOD_CALL_FAILURE, false);
+    return;
+  }
+
+  dbus::MessageReader reader(response);
+  bool result;
+  if (!reader.PopBool(&result)) {
+    callback.Run(DBUS_METHOD_CALL_FAILURE, false);
+    return;
+  }
+
+  callback.Run(DBUS_METHOD_CALL_SUCCESS, result);
+}
+
+void OnVoidDBusMethod(const VoidDBusMethodCallback& callback,
+                      dbus::Response* response) {
+  callback.Run(response ? DBUS_METHOD_CALL_SUCCESS : DBUS_METHOD_CALL_FAILURE);
+}
+
+// The AmplifierClient implementation.
+class AmplifierClientImpl : public AmplifierClient {
+ public:
+  AmplifierClientImpl()
+      : proxy_(nullptr), signal_connected_(false), weak_ptr_factory_(this) {}
+
+  ~AmplifierClientImpl() override {}
+
+  // DBusClient overrides:
+  void Init(dbus::Bus* bus) override;
+
+  // AmplifierClient overrides:
+  void AddObserver(Observer* observer) override;
+  void RemoveObserver(Observer* observer) override;
+  void Initialize(const BoolDBusMethodCallback& callback) override;
+  void SetStandbyMode(bool standby,
+                      const VoidDBusMethodCallback& callback) override;
+  void SetVolume(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,
+                         const std::string& signal,
+                         bool succeeded);
+
+  dbus::ObjectProxy* proxy_;
+
+  // True when |proxy_| has been connected to the Error signal.
+  bool signal_connected_;
+
+  // List of observers interested in event notifications from us.
+  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<AmplifierClientImpl> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(AmplifierClientImpl);
+};
+
+void AmplifierClientImpl::Init(dbus::Bus* bus) {
+  proxy_ =
+      bus->GetObjectProxy(amplifier::kAmplifierServiceName,
+                          dbus::ObjectPath(amplifier::kAmplifierServicePath));
+  DCHECK(proxy_);
+}
+
+void AmplifierClientImpl::AddObserver(Observer* observer) {
+  DCHECK(observer);
+  if (!signal_connected_ && proxy_) {
+    signal_connected_ = true;
+    proxy_->ConnectToSignal(amplifier::kAmplifierInterface,
+                            amplifier::kErrorSignal,
+                            base::Bind(&AmplifierClientImpl::OnError,
+                                       weak_ptr_factory_.GetWeakPtr()),
+                            base::Bind(&AmplifierClientImpl::OnSignalConnected,
+                                       weak_ptr_factory_.GetWeakPtr()));
+  }
+  observers_.AddObserver(observer);
+}
+
+void AmplifierClientImpl::RemoveObserver(Observer* observer) {
+  DCHECK(observer);
+  observers_.RemoveObserver(observer);
+}
+
+void AmplifierClientImpl::Initialize(const BoolDBusMethodCallback& callback) {
+  dbus::MethodCall method_call(amplifier::kAmplifierInterface,
+                               amplifier::kInitializeMethod);
+  DCHECK(proxy_);
+  proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                     base::Bind(&OnBoolDBusMethod, callback));
+}
+
+void AmplifierClientImpl::SetStandbyMode(
+    bool standby,
+    const VoidDBusMethodCallback& callback) {
+  dbus::MethodCall method_call(amplifier::kAmplifierInterface,
+                               amplifier::kSetStandbyModeMethod);
+  dbus::MessageWriter writer(&method_call);
+  writer.AppendBool(standby);
+  DCHECK(proxy_);
+  proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                     base::Bind(&OnVoidDBusMethod, callback));
+}
+
+void AmplifierClientImpl::SetVolume(double db_spl,
+                                    const VoidDBusMethodCallback& callback) {
+  dbus::MethodCall method_call(amplifier::kAmplifierInterface,
+                               amplifier::kSetVolumeMethod);
+  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 AmplifierClientImpl::OnError(dbus::Signal* signal) {
+  dbus::MessageReader reader(signal);
+  int32 error_code = 0;
+  if (!reader.PopInt32(&error_code)) {
+    LOG(ERROR) << "Invalid signal: " << signal->ToString();
+    return;
+  }
+  FOR_EACH_OBSERVER(Observer, observers_, OnError(error_code));
+}
+
+void AmplifierClientImpl::OnSignalConnected(const std::string& interface,
+                                            const std::string& signal,
+                                            bool succeeded) {
+  LOG_IF(ERROR, !succeeded) << "Connect to " << interface << " " << signal
+                            << " failed.";
+}
+
+}  // anonymous namespace
+
+AmplifierClient::AmplifierClient() {
+}
+
+AmplifierClient::~AmplifierClient() {
+}
+
+// static
+AmplifierClient* AmplifierClient::Create() {
+  return new AmplifierClientImpl();
+}
+
+}  // namespace chromeos
diff --git a/chromeos/dbus/amplifier_client.h b/chromeos/dbus/amplifier_client.h
new file mode 100644
index 0000000..c63a286
--- /dev/null
+++ b/chromeos/dbus/amplifier_client.h
@@ -0,0 +1,64 @@
+// 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.
+
+#ifndef CHROMEOS_DBUS_AMPLIFIER_CLIENT_H_
+#define CHROMEOS_DBUS_AMPLIFIER_CLIENT_H_
+
+#include "base/basictypes.h"
+#include "chromeos/chromeos_export.h"
+#include "chromeos/dbus/dbus_client.h"
+#include "chromeos/dbus/dbus_method_call_status.h"
+
+namespace chromeos {
+
+// A DBus client class for the org.chromium.Amplifier service.
+class CHROMEOS_EXPORT AmplifierClient : public DBusClient {
+ public:
+  // Interface for observing amplifier events from an amplifier client.
+  class Observer {
+   public:
+    virtual ~Observer() {}
+    // Called when the Error signal is received.
+    virtual void OnError(int32 error_code) = 0;
+  };
+
+  ~AmplifierClient() override;
+
+  // Adds and removes observers for amplifier events.
+  virtual void AddObserver(Observer* observer) = 0;
+  virtual void RemoveObserver(Observer* observer) = 0;
+
+  // Factory function; creates a new instance which is owned by the caller.
+  // For normal usage, access the singleton via DBusThreadManager::Get().
+  static AmplifierClient* Create();
+
+  // Calls Initialize method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded, and a bool that is the return value from
+  // the DBus method.
+  virtual void Initialize(const BoolDBusMethodCallback& callback) = 0;
+
+  // Calls SetStandbyMode method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded.
+  virtual void SetStandbyMode(bool standby,
+                              const VoidDBusMethodCallback& callback) = 0;
+
+  // Calls SetVolume method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded.
+  virtual void SetVolume(double db_spl,
+                         const VoidDBusMethodCallback& callback) = 0;
+
+ protected:
+  // Create() should be used instead.
+  AmplifierClient();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AmplifierClient);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_DBUS_AMPLIFIER_CLIENT_H_
diff --git a/chromeos/dbus/audio_dsp_client.cc b/chromeos/dbus/audio_dsp_client.cc
new file mode 100644
index 0000000..19fce6b
--- /dev/null
+++ b/chromeos/dbus/audio_dsp_client.cc
@@ -0,0 +1,384 @@
+// 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 "base/bind.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 {
+
+// TODO(benchan): Move these DBus constants to system_api.
+namespace audio_dsp {
+
+const char kAudioDspInterface[] = "org.chromium.AudioDsp";
+const char kAudioDspServiceName[] = "org.chromium.AudioDsp";
+const char kAudioDspServicePath[] = "/org/chromium/AudioDsp";
+const char kInitializeMethod[] = "Initialize";
+const char kSetStandbyModeMethod[] = "SetStandbyMode";
+const char kSetNightModeMethod[] = "SetNightMode";
+const char kSetTrebleMethod[] = "SetTreble";
+const char kSetBassMethod[] = "SetBass";
+const char kGetNightModeMethod[] = "GetNightMode";
+const char kGetTrebleMethod[] = "GetTreble";
+const char kGetBassMethod[] = "GetBass";
+const char kGetCapabilitiesOEMMethod[] = "GetCapabilitiesOEM";
+const char kSetCapabilitiesOEMMethod[] = "SetCapabilitiesOEM";
+const char kGetFilterConfigOEMMethod[] = "GetFilterConfigOEM";
+const char kSetFilterConfigOEMMethod[] = "SetFilterConfigOEM";
+const char kSetSourceTypeMethod[] = "SetSourceType";
+const char kAmplifierVolumeChangedMethod[] = "AmplifierVolumeChanged";
+const char kErrorSignal[] = "Error";
+
+}  // namespace audio_dsp
+
+void OnVoidDBusMethod(const VoidDBusMethodCallback& callback,
+                      dbus::Response* response) {
+  callback.Run(response ? DBUS_METHOD_CALL_SUCCESS : DBUS_METHOD_CALL_FAILURE);
+}
+
+void OnBoolDBusMethod(const BoolDBusMethodCallback& callback,
+                      dbus::Response* response) {
+  if (!response) {
+    callback.Run(DBUS_METHOD_CALL_FAILURE, false);
+    return;
+  }
+
+  dbus::MessageReader reader(response);
+  bool result;
+  if (!reader.PopBool(&result)) {
+    callback.Run(DBUS_METHOD_CALL_FAILURE, false);
+    return;
+  }
+
+  callback.Run(DBUS_METHOD_CALL_SUCCESS, result);
+}
+
+void OnDoubleDBusMethod(
+    const AudioDspClient::DoubleDBusMethodCallback& callback,
+    dbus::Response* response) {
+  bool ok = false;
+  double result = 0.0;
+  if (response) {
+    dbus::MessageReader reader(response);
+    ok = reader.PopDouble(&result);
+  }
+  callback.Run(ok ? DBUS_METHOD_CALL_SUCCESS : DBUS_METHOD_CALL_FAILURE,
+               result);
+}
+
+void OnTwoStringDBusMethod(
+    const AudioDspClient::TwoStringDBusMethodCallback& callback,
+    dbus::Response* response) {
+  std::string result1;
+  std::string result2;
+  bool ok = false;
+  if (response) {
+    dbus::MessageReader reader(response);
+    ok = reader.PopString(&result1) && reader.PopString(&result2);
+  }
+  callback.Run(ok ? DBUS_METHOD_CALL_SUCCESS : DBUS_METHOD_CALL_FAILURE,
+               result1, result2);
+}
+
+void OnThreeStringDBusMethod(
+    const AudioDspClient::ThreeStringDBusMethodCallback& callback,
+    dbus::Response* response) {
+  std::string result1;
+  std::string result2;
+  std::string result3;
+  bool ok = false;
+  if (response) {
+    dbus::MessageReader reader(response);
+    ok = reader.PopString(&result1) && reader.PopString(&result2) &&
+         reader.PopString(&result3);
+  }
+  callback.Run(ok ? DBUS_METHOD_CALL_SUCCESS : DBUS_METHOD_CALL_FAILURE,
+               result1, result2, result3);
+}
+
+// The AudioDspClient implementation.
+class AudioDspClientImpl : public AudioDspClient {
+ public:
+  AudioDspClientImpl()
+      : proxy_(nullptr), signal_connected_(false), weak_ptr_factory_(this) {}
+
+  ~AudioDspClientImpl() override {}
+
+  // DBusClient overrides:
+  void Init(dbus::Bus* bus) override;
+
+  // AudioDspClient overrides:
+  void AddObserver(Observer* observer) override;
+  void RemoveObserver(Observer* observer) override;
+  void Initialize(const BoolDBusMethodCallback& callback) override;
+  void SetStandbyMode(bool standby,
+                      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,
+                          const std::string& speaker_capabilities,
+                          const std::string& driver_capabilities,
+                          const VoidDBusMethodCallback& callback) override;
+  void GetFilterConfigOEM(uint32 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,
+                     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,
+                         const std::string& signal,
+                         bool succeeded);
+
+  dbus::ObjectProxy* proxy_;
+
+  // True when |proxy_| has been connected to the Error signal.
+  bool signal_connected_;
+
+  // List of observers interested in event notifications from us.
+  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<AudioDspClientImpl> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(AudioDspClientImpl);
+};
+
+void AudioDspClientImpl::Init(dbus::Bus* bus) {
+  proxy_ =
+      bus->GetObjectProxy(audio_dsp::kAudioDspServiceName,
+                          dbus::ObjectPath(audio_dsp::kAudioDspServicePath));
+  DCHECK(proxy_);
+}
+
+void AudioDspClientImpl::AddObserver(Observer* observer) {
+  DCHECK(observer);
+  if (!signal_connected_) {
+    signal_connected_ = true;
+    DCHECK(proxy_);
+    proxy_->ConnectToSignal(audio_dsp::kAudioDspInterface,
+                            audio_dsp::kErrorSignal,
+                            base::Bind(&AudioDspClientImpl::OnError,
+                                       weak_ptr_factory_.GetWeakPtr()),
+                            base::Bind(&AudioDspClientImpl::OnSignalConnected,
+                                       weak_ptr_factory_.GetWeakPtr()));
+  }
+  observers_.AddObserver(observer);
+}
+
+void AudioDspClientImpl::RemoveObserver(Observer* observer) {
+  DCHECK(observer);
+  observers_.RemoveObserver(observer);
+}
+
+void AudioDspClientImpl::Initialize(const BoolDBusMethodCallback& callback) {
+  dbus::MethodCall method_call(audio_dsp::kAudioDspInterface,
+                               audio_dsp::kInitializeMethod);
+  DCHECK(proxy_);
+  proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                     base::Bind(&OnBoolDBusMethod, callback));
+}
+
+void AudioDspClientImpl::SetStandbyMode(
+    bool standby,
+    const VoidDBusMethodCallback& callback) {
+  dbus::MethodCall method_call(audio_dsp::kAudioDspInterface,
+                               audio_dsp::kSetStandbyModeMethod);
+  dbus::MessageWriter writer(&method_call);
+  writer.AppendBool(standby);
+  DCHECK(proxy_);
+  proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                     base::Bind(&OnVoidDBusMethod, callback));
+}
+
+void AudioDspClientImpl::SetNightMode(bool night_mode,
+                                      const VoidDBusMethodCallback& callback) {
+  dbus::MethodCall method_call(audio_dsp::kAudioDspInterface,
+                               audio_dsp::kSetNightModeMethod);
+  dbus::MessageWriter writer(&method_call);
+  writer.AppendBool(night_mode);
+  DCHECK(proxy_);
+  proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                     base::Bind(&OnVoidDBusMethod, callback));
+}
+
+void AudioDspClientImpl::GetNightMode(const BoolDBusMethodCallback& callback) {
+  dbus::MethodCall method_call(audio_dsp::kAudioDspInterface,
+                               audio_dsp::kGetNightModeMethod);
+  dbus::MessageWriter writer(&method_call);
+  DCHECK(proxy_);
+  proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                     base::Bind(&OnBoolDBusMethod, callback));
+}
+
+void AudioDspClientImpl::SetTreble(double db_fs,
+                                   const VoidDBusMethodCallback& callback) {
+  dbus::MethodCall method_call(audio_dsp::kAudioDspInterface,
+                               audio_dsp::kSetTrebleMethod);
+  dbus::MessageWriter writer(&method_call);
+  writer.AppendDouble(db_fs);
+  DCHECK(proxy_);
+  proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                     base::Bind(&OnVoidDBusMethod, callback));
+}
+
+void AudioDspClientImpl::GetTreble(const DoubleDBusMethodCallback& callback) {
+  dbus::MethodCall method_call(audio_dsp::kAudioDspInterface,
+                               audio_dsp::kGetTrebleMethod);
+  dbus::MessageWriter writer(&method_call);
+  DCHECK(proxy_);
+  proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                     base::Bind(&OnDoubleDBusMethod, callback));
+}
+
+void AudioDspClientImpl::SetBass(double db_fs,
+                                 const VoidDBusMethodCallback& callback) {
+  dbus::MethodCall method_call(audio_dsp::kAudioDspInterface,
+                               audio_dsp::kSetBassMethod);
+  dbus::MessageWriter writer(&method_call);
+  writer.AppendDouble(db_fs);
+  DCHECK(proxy_);
+  proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                     base::Bind(&OnVoidDBusMethod, callback));
+}
+
+void AudioDspClientImpl::GetBass(const DoubleDBusMethodCallback& callback) {
+  dbus::MethodCall method_call(audio_dsp::kAudioDspInterface,
+                               audio_dsp::kGetBassMethod);
+  dbus::MessageWriter writer(&method_call);
+  DCHECK(proxy_);
+  proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                     base::Bind(&OnDoubleDBusMethod, callback));
+}
+
+void AudioDspClientImpl::GetCapabilitiesOEM(
+    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,
+    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,
+    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,
+                                       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;
+  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
diff --git a/chromeos/dbus/audio_dsp_client.h b/chromeos/dbus/audio_dsp_client.h
new file mode 100644
index 0000000..a1aa2c4
--- /dev/null
+++ b/chromeos/dbus/audio_dsp_client.h
@@ -0,0 +1,155 @@
+// 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.
+
+#ifndef CHROMEOS_DBUS_AUDIO_DSP_CLIENT_H_
+#define CHROMEOS_DBUS_AUDIO_DSP_CLIENT_H_
+
+#include "base/basictypes.h"
+#include "chromeos/chromeos_export.h"
+#include "chromeos/dbus/dbus_client.h"
+#include "chromeos/dbus/dbus_method_call_status.h"
+
+namespace chromeos {
+
+// A DBus client class for the org.chromium.AudioDsp service.
+class CHROMEOS_EXPORT AudioDspClient : public DBusClient {
+ public:
+  // A callback to handle responses of methods returning a double value.
+  typedef base::Callback<void(DBusMethodCallStatus call_status, double result)>
+      DoubleDBusMethodCallback;
+
+  // A callback to handle responses of methods returning two string values.
+  typedef base::Callback<void(DBusMethodCallStatus call_status,
+                              const std::string& result1,
+                              const std::string& result2)>
+      TwoStringDBusMethodCallback;
+
+  // A callback to handle responses of methods returning three string values.
+  typedef base::Callback<void(DBusMethodCallStatus call_status,
+                              const std::string& result1,
+                              const std::string& result2,
+                              const std::string& result3)>
+      ThreeStringDBusMethodCallback;
+
+  // Interface for observing DSP events from a DSP client.
+  class Observer {
+   public:
+    virtual ~Observer() {}
+
+    // Called when the Error signal is received.
+    virtual void OnError(int32 error_code) = 0;
+  };
+
+  ~AudioDspClient() override;
+
+  // Adds and removes observers for AUDIO_DSP events.
+  virtual void AddObserver(Observer* observer) = 0;
+  virtual void RemoveObserver(Observer* observer) = 0;
+
+  // Factory function; creates a new instance which is owned by the caller.
+  // For normal usage, access the singleton via DBusThreadManager::Get().
+  static AudioDspClient* Create();
+
+  // Calls Initialize method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded, and a bool that is the return value from
+  // the DBus method.
+  virtual void Initialize(const BoolDBusMethodCallback& callback) = 0;
+
+  // Calls SetStandbyMode method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded.
+  virtual void SetStandbyMode(bool standby,
+                              const VoidDBusMethodCallback& callback) = 0;
+
+  // Calls SetNightMode method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded.
+  virtual void SetNightMode(bool night_mode,
+                            const VoidDBusMethodCallback& callback) = 0;
+
+  // Calls GetNightMode method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded, and a bool that is the return value from
+  // the DBus method.
+  virtual void GetNightMode(const BoolDBusMethodCallback& callback) = 0;
+
+  // Calls SetTreble method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded.
+  virtual void SetTreble(double db_fs,
+                         const VoidDBusMethodCallback& callback) = 0;
+
+  // Calls GetTreble method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded, and a double that is the return value from
+  // the DBus method.
+  virtual void GetTreble(const DoubleDBusMethodCallback& callback) = 0;
+
+  // Calls SetBass method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded.
+  virtual void SetBass(double db_fs,
+                       const VoidDBusMethodCallback& callback) = 0;
+
+  // Calls SetBass method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded, and a double that is the return value from
+  // the DBus method.
+  virtual void GetBass(const DoubleDBusMethodCallback& callback) = 0;
+
+  // Calls GetCapabilitiesOEM method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded, and three std::strings that constitute
+  // the return value from the DBus method.
+  virtual void GetCapabilitiesOEM(
+      const ThreeStringDBusMethodCallback& callback) = 0;
+
+  // Calls SetCapabilitiesOEM method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded.
+  virtual void SetCapabilitiesOEM(uint32 speaker_id,
+                                  const std::string& speaker_capabilities,
+                                  const std::string& driver_capabilities,
+                                  const VoidDBusMethodCallback& callback) = 0;
+
+  // Calls GetFilterConfigOEM method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded, and two std::strings that constitute
+  // the return value from the DBus method.
+  virtual void GetFilterConfigOEM(
+      uint32 speaker_id,
+      const TwoStringDBusMethodCallback& callback) = 0;
+
+  // Calls SetFilterConfigOEM method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded.
+  virtual void SetFilterConfigOEM(const std::string& speaker_config,
+                                  const std::string& driver_config,
+                                  const VoidDBusMethodCallback& callback) = 0;
+
+  // Calls SetSourceType method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded.
+  virtual void SetSourceType(uint16 source_type,
+                             const VoidDBusMethodCallback& callback) = 0;
+
+  // Calls AmplifierVolumeChanged method.
+  // |callback| will be called with a DBusMethodCallStatus indicating whether
+  // the DBus method call succeeded.
+  virtual void AmplifierVolumeChanged(
+      double db_spl,
+      const VoidDBusMethodCallback& callback) = 0;
+
+ protected:
+  // Create() should be used instead.
+  AudioDspClient();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AudioDspClient);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_DBUS_AUDIO_DSP_CLIENT_H_
diff --git a/chromeos/dbus/dbus_client_bundle.cc b/chromeos/dbus/dbus_client_bundle.cc
index 710ec95..608f2e3 100644
--- a/chromeos/dbus/dbus_client_bundle.cc
+++ b/chromeos/dbus/dbus_client_bundle.cc
@@ -10,7 +10,9 @@
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "chromeos/chromeos_switches.h"
+#include "chromeos/dbus/amplifier_client.h"
 #include "chromeos/dbus/ap_manager_client.h"
+#include "chromeos/dbus/audio_dsp_client.h"
 #include "chromeos/dbus/bluetooth_adapter_client.h"
 #include "chromeos/dbus/bluetooth_agent_manager_client.h"
 #include "chromeos/dbus/bluetooth_device_client.h"
@@ -27,7 +29,9 @@
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/debug_daemon_client.h"
 #include "chromeos/dbus/easy_unlock_client.h"
+#include "chromeos/dbus/fake_amplifier_client.h"
 #include "chromeos/dbus/fake_ap_manager_client.h"
+#include "chromeos/dbus/fake_audio_dsp_client.h"
 #include "chromeos/dbus/fake_bluetooth_adapter_client.h"
 #include "chromeos/dbus/fake_bluetooth_agent_manager_client.h"
 #include "chromeos/dbus/fake_bluetooth_device_client.h"
@@ -102,7 +106,9 @@ const struct {
   const char* param_name;
   DBusClientBundle::DBusClientType client_type;
 } client_type_map[] = {
+    { "amplifier",  DBusClientBundle::AMPLIFIER },
     { "ap",  DBusClientBundle::AP_MANAGER },
+    { "audio_dsp",  DBusClientBundle::AUDIO_DSP },
     { "bluetooth",  DBusClientBundle::BLUETOOTH },
     { "cras",  DBusClientBundle::CRAS },
     { "cros_disks",  DBusClientBundle::CROS_DISKS },
@@ -143,6 +149,16 @@ DBusClientBundle::DBusClientType GetDBusClientType(
 
 DBusClientBundle::DBusClientBundle(DBusClientTypeMask unstub_client_mask)
     : unstub_client_mask_(unstub_client_mask) {
+  if (!IsUsingStub(AMPLIFIER))
+    amplifier_client_.reset(AmplifierClient::Create());
+  else
+    amplifier_client_.reset(new FakeAmplifierClient);
+
+  if (!IsUsingStub(AUDIO_DSP))
+    audio_dsp_client_.reset(AudioDspClient::Create());
+  else
+    audio_dsp_client_.reset(new FakeAudioDspClient);
+
   if (!IsUsingStub(BLUETOOTH)) {
     bluetooth_adapter_client_.reset(BluetoothAdapterClient::Create());
     bluetooth_agent_manager_client_.reset(
diff --git a/chromeos/dbus/dbus_client_bundle.h b/chromeos/dbus/dbus_client_bundle.h
index e7aa8b6..2801b4f 100644
--- a/chromeos/dbus/dbus_client_bundle.h
+++ b/chromeos/dbus/dbus_client_bundle.h
@@ -12,7 +12,9 @@
 
 namespace chromeos {
 
+class AmplifierClient;
 class ApManagerClient;
+class AudioDspClient;
 class BluetoothAdapterClient;
 class BluetoothAgentManagerClient;
 class BluetoothDeviceClient;
@@ -29,31 +31,31 @@ class CrosDisksClient;
 class CryptohomeClient;
 class DebugDaemonClient;
 class EasyUnlockClient;
-class LeadershipDaemonManagerClient;
-class LorgnetteManagerClient;
-class MetronomeClient;
-class ShillDeviceClient;
-class ShillIPConfigClient;
-class ShillManagerClient;
-class ShillServiceClient;
-class ShillProfileClient;
-class ShillThirdPartyVpnDriverClient;
 class GsmSMSClient;
 class ImageBurnerClient;
 class IntrospectableClient;
+class LeadershipDaemonManagerClient;
+class LorgnetteManagerClient;
+class MetronomeClient;
 class ModemMessagingClient;
-class NfcManagerClient;
 class NfcAdapterClient;
 class NfcDeviceClient;
-class NfcTagClient;
+class NfcManagerClient;
 class NfcRecordClient;
+class NfcTagClient;
 class PeerDaemonManagerClient;
 class PermissionBrokerClient;
-class PrivetDaemonManagerClient;
-class SystemClockClient;
 class PowerManagerClient;
-class SessionManagerClient;
+class PrivetDaemonManagerClient;
 class SMSClient;
+class SessionManagerClient;
+class ShillDeviceClient;
+class ShillIPConfigClient;
+class ShillManagerClient;
+class ShillProfileClient;
+class ShillServiceClient;
+class ShillThirdPartyVpnDriverClient;
+class SystemClockClient;
 class UpdateEngineClient;
 
 // The bundle of all D-Bus clients used in DBusThreadManager. The bundle
@@ -91,6 +93,8 @@ class CHROMEOS_EXPORT DBusClientBundle {
     METRONOME =            1 << 21,
     AP_MANAGER =           1 << 22,
     PRIVET_DAEMON =        1 << 23,
+    AMPLIFIER =            1 << 24,
+    AUDIO_DSP =            1 << 25,
   };
 
   explicit DBusClientBundle(DBusClientTypeMask unstub_client_mask);
@@ -109,8 +113,12 @@ class CHROMEOS_EXPORT DBusClientBundle {
   // un-stubbed.
   static DBusClientTypeMask ParseUnstubList(const std::string& unstub_list);
 
+  AmplifierClient* amplifier_client() { return amplifier_client_.get(); }
+
   ApManagerClient* ap_manager_client() { return ap_manager_client_.get(); }
 
+  AudioDspClient* audio_dsp_client() { return audio_dsp_client_.get(); }
+
   BluetoothAdapterClient* bluetooth_adapter_client() {
     return bluetooth_adapter_client_.get();
   }
@@ -284,7 +292,9 @@ class CHROMEOS_EXPORT DBusClientBundle {
   // are defined within DBusClientType enum.
   DBusClientTypeMask unstub_client_mask_;
 
+  scoped_ptr<AmplifierClient> amplifier_client_;
   scoped_ptr<ApManagerClient> ap_manager_client_;
+  scoped_ptr<AudioDspClient> audio_dsp_client_;
   scoped_ptr<BluetoothAdapterClient> bluetooth_adapter_client_;
   scoped_ptr<BluetoothAgentManagerClient> bluetooth_agent_manager_client_;
   scoped_ptr<BluetoothDeviceClient> bluetooth_device_client_;
diff --git a/chromeos/dbus/dbus_thread_manager.cc b/chromeos/dbus/dbus_thread_manager.cc
index c4741e5..6db36c2 100644
--- a/chromeos/dbus/dbus_thread_manager.cc
+++ b/chromeos/dbus/dbus_thread_manager.cc
@@ -8,7 +8,9 @@
 #include "base/sys_info.h"
 #include "base/threading/thread.h"
 #include "chromeos/chromeos_switches.h"
+#include "chromeos/dbus/amplifier_client.h"
 #include "chromeos/dbus/ap_manager_client.h"
+#include "chromeos/dbus/audio_dsp_client.h"
 #include "chromeos/dbus/bluetooth_adapter_client.h"
 #include "chromeos/dbus/bluetooth_agent_manager_client.h"
 #include "chromeos/dbus/bluetooth_device_client.h"
@@ -114,10 +116,18 @@ dbus::Bus* DBusThreadManager::GetSystemBus() {
   return system_bus_.get();
 }
 
+AmplifierClient* DBusThreadManager::GetAmplifierClient() {
+  return client_bundle_->amplifier_client();
+}
+
 ApManagerClient* DBusThreadManager::GetApManagerClient() {
   return client_bundle_->ap_manager_client();
 }
 
+AudioDspClient* DBusThreadManager::GetAudioDspClient() {
+  return client_bundle_->audio_dsp_client();
+}
+
 BluetoothAdapterClient* DBusThreadManager::GetBluetoothAdapterClient() {
   return client_bundle_->bluetooth_adapter_client();
 }
@@ -302,7 +312,9 @@ UpdateEngineClient* DBusThreadManager::GetUpdateEngineClient() {
 }
 
 void DBusThreadManager::InitializeClients() {
+  GetAmplifierClient()->Init(GetSystemBus());
   GetApManagerClient()->Init(GetSystemBus());
+  GetAudioDspClient()->Init(GetSystemBus());
   GetBluetoothAdapterClient()->Init(GetSystemBus());
   GetBluetoothAgentManagerClient()->Init(GetSystemBus());
   GetBluetoothDeviceClient()->Init(GetSystemBus());
@@ -460,6 +472,16 @@ DBusThreadManagerSetter::DBusThreadManagerSetter() {
 DBusThreadManagerSetter::~DBusThreadManagerSetter() {
 }
 
+void DBusThreadManagerSetter::SetAmplifierClient(
+    scoped_ptr<AmplifierClient> client) {
+  DBusThreadManager::Get()->client_bundle_->amplifier_client_ = client.Pass();
+}
+
+void DBusThreadManagerSetter::SetAudioDspClient(
+    scoped_ptr<AudioDspClient> client) {
+  DBusThreadManager::Get()->client_bundle_->audio_dsp_client_ = client.Pass();
+}
+
 void DBusThreadManagerSetter::SetBluetoothAdapterClient(
     scoped_ptr<BluetoothAdapterClient> client) {
   DBusThreadManager::Get()->client_bundle_->bluetooth_adapter_client_ =
diff --git a/chromeos/dbus/dbus_thread_manager.h b/chromeos/dbus/dbus_thread_manager.h
index 08e91e4..26d5f86 100644
--- a/chromeos/dbus/dbus_thread_manager.h
+++ b/chromeos/dbus/dbus_thread_manager.h
@@ -25,7 +25,9 @@ class ObjectPath;
 namespace chromeos {
 
 // Style Note: Clients are sorted by names.
+class AmplifierClient;
 class ApManagerClient;
+class AudioDspClient;
 class BluetoothAdapterClient;
 class BluetoothAgentManagerClient;
 class BluetoothDeviceClient;
@@ -59,6 +61,7 @@ class PeerDaemonManagerClient;
 class PermissionBrokerClient;
 class PowerManagerClient;
 class PrivetDaemonManagerClient;
+class SMSClient;
 class SessionManagerClient;
 class ShillDeviceClient;
 class ShillIPConfigClient;
@@ -66,7 +69,6 @@ class ShillManagerClient;
 class ShillProfileClient;
 class ShillServiceClient;
 class ShillThirdPartyVpnDriverClient;
-class SMSClient;
 class SystemClockClient;
 class UpdateEngineClient;
 
@@ -120,7 +122,9 @@ class CHROMEOS_EXPORT DBusThreadManager {
 
   // All returned objects are owned by DBusThreadManager.  Do not use these
   // pointers after DBusThreadManager has been shut down.
+  AmplifierClient* GetAmplifierClient();
   ApManagerClient* GetApManagerClient();
+  AudioDspClient* GetAudioDspClient();
   BluetoothAdapterClient* GetBluetoothAdapterClient();
   BluetoothAgentManagerClient* GetBluetoothAgentManagerClient();
   BluetoothDeviceClient* GetBluetoothDeviceClient();
@@ -206,6 +210,8 @@ class CHROMEOS_EXPORT DBusThreadManagerSetter {
  public:
   ~DBusThreadManagerSetter();
 
+  void SetAmplifierClient(scoped_ptr<AmplifierClient> client);
+  void SetAudioDspClient(scoped_ptr<AudioDspClient> client);
   void SetBluetoothAdapterClient(scoped_ptr<BluetoothAdapterClient> client);
   void SetBluetoothAgentManagerClient(
       scoped_ptr<BluetoothAgentManagerClient> client);
diff --git a/chromeos/dbus/fake_amplifier_client.cc b/chromeos/dbus/fake_amplifier_client.cc
new file mode 100644
index 0000000..ab8129d
--- /dev/null
+++ b/chromeos/dbus/fake_amplifier_client.cc
@@ -0,0 +1,57 @@
+// 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/fake_amplifier_client.h"
+
+#include "base/bind.h"
+#include "base/message_loop/message_loop.h"
+
+namespace chromeos {
+
+namespace {
+
+void OnBoolDBusMethod(const BoolDBusMethodCallback& callback) {
+  callback.Run(DBUS_METHOD_CALL_SUCCESS, true);
+}
+
+void OnVoidDBusMethod(const VoidDBusMethodCallback& callback) {
+  callback.Run(DBUS_METHOD_CALL_SUCCESS);
+}
+
+}  // anonymous namespace
+
+FakeAmplifierClient::FakeAmplifierClient() {
+}
+
+FakeAmplifierClient::~FakeAmplifierClient() {
+}
+
+void FakeAmplifierClient::Init(dbus::Bus* bus) {
+}
+
+void FakeAmplifierClient::AddObserver(Observer* observer) {
+}
+
+void FakeAmplifierClient::RemoveObserver(Observer* observer) {
+}
+
+void FakeAmplifierClient::Initialize(const BoolDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnBoolDBusMethod, callback));
+}
+
+void FakeAmplifierClient::SetStandbyMode(
+    bool standby,
+    const VoidDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnVoidDBusMethod, callback));
+}
+
+void FakeAmplifierClient::SetVolume(double db_spl,
+                                    const VoidDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnVoidDBusMethod, callback));
+}
+
+}  // namespace chromeos
diff --git a/chromeos/dbus/fake_amplifier_client.h b/chromeos/dbus/fake_amplifier_client.h
new file mode 100644
index 0000000..48d1bb6
--- /dev/null
+++ b/chromeos/dbus/fake_amplifier_client.h
@@ -0,0 +1,39 @@
+// 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.
+
+#ifndef CHROMEOS_DBUS_FAKE_AMPLIFIER_CLIENT_H_
+#define CHROMEOS_DBUS_FAKE_AMPLIFIER_CLIENT_H_
+
+#include "base/basictypes.h"
+#include "chromeos/chromeos_export.h"
+#include "chromeos/dbus/amplifier_client.h"
+#include "chromeos/dbus/dbus_client.h"
+
+namespace chromeos {
+
+// A fake implementation of AmplifierClient. Invokes callbacks immediately.
+class CHROMEOS_EXPORT FakeAmplifierClient : public AmplifierClient {
+ public:
+  FakeAmplifierClient();
+  ~FakeAmplifierClient() override;
+
+  // DBusClient overrides:
+  void Init(dbus::Bus* bus) override;
+
+  // AmplifierClient overrides:
+  void AddObserver(Observer* observer) override;
+  void RemoveObserver(Observer* observer) override;
+  void Initialize(const BoolDBusMethodCallback& callback) override;
+  void SetStandbyMode(bool standby,
+                      const VoidDBusMethodCallback& callback) override;
+  void SetVolume(double db_spl,
+                 const VoidDBusMethodCallback& callback) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(FakeAmplifierClient);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_DBUS_FAKE_AMPLIFIER_CLIENT_H_
diff --git a/chromeos/dbus/fake_audio_dsp_client.cc b/chromeos/dbus/fake_audio_dsp_client.cc
new file mode 100644
index 0000000..ec9fbf0
--- /dev/null
+++ b/chromeos/dbus/fake_audio_dsp_client.cc
@@ -0,0 +1,143 @@
+// 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/fake_audio_dsp_client.h"
+
+#include "base/bind.h"
+#include "base/message_loop/message_loop.h"
+
+namespace chromeos {
+
+namespace {
+
+void OnVoidDBusMethod(const VoidDBusMethodCallback& callback) {
+  callback.Run(DBUS_METHOD_CALL_SUCCESS);
+}
+
+void OnBoolDBusMethod(const BoolDBusMethodCallback& callback) {
+  callback.Run(DBUS_METHOD_CALL_SUCCESS, true);
+}
+
+void OnDoubleDBusMethod(
+    const AudioDspClient::DoubleDBusMethodCallback& callback) {
+  callback.Run(DBUS_METHOD_CALL_SUCCESS, 0.0);
+}
+
+void OnTwoStringDBusMethod(
+    const AudioDspClient::TwoStringDBusMethodCallback& callback) {
+  callback.Run(DBUS_METHOD_CALL_SUCCESS, std::string(), std::string());
+}
+
+void OnThreeStringDBusMethod(
+    const AudioDspClient::ThreeStringDBusMethodCallback& callback) {
+  callback.Run(DBUS_METHOD_CALL_SUCCESS, std::string(), std::string(),
+               std::string());
+}
+
+}  // anonymous namespace
+
+FakeAudioDspClient::FakeAudioDspClient() {
+}
+
+FakeAudioDspClient::~FakeAudioDspClient() {
+}
+
+void FakeAudioDspClient::Init(dbus::Bus* bus) {
+}
+
+void FakeAudioDspClient::AddObserver(Observer* observer) {
+}
+
+void FakeAudioDspClient::RemoveObserver(Observer* observer) {
+}
+
+void FakeAudioDspClient::Initialize(const BoolDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnBoolDBusMethod, callback));
+}
+
+void FakeAudioDspClient::SetStandbyMode(
+    bool standby,
+    const VoidDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnVoidDBusMethod, callback));
+}
+
+void FakeAudioDspClient::SetNightMode(bool standby,
+                                      const VoidDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnVoidDBusMethod, callback));
+}
+
+void FakeAudioDspClient::GetNightMode(const BoolDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnBoolDBusMethod, callback));
+}
+
+void FakeAudioDspClient::SetTreble(double db_fs,
+                                   const VoidDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnVoidDBusMethod, callback));
+}
+
+void FakeAudioDspClient::GetTreble(const DoubleDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnDoubleDBusMethod, callback));
+}
+
+void FakeAudioDspClient::SetBass(double db_fs,
+                                 const VoidDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnVoidDBusMethod, callback));
+}
+
+void FakeAudioDspClient::GetBass(const DoubleDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnDoubleDBusMethod, callback));
+}
+
+void FakeAudioDspClient::GetCapabilitiesOEM(
+    const ThreeStringDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnThreeStringDBusMethod, callback));
+}
+
+void FakeAudioDspClient::SetCapabilitiesOEM(
+    uint32 speaker_id,
+    const std::string& speaker_capabilities,
+    const std::string& driver_capabilities,
+    const VoidDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnVoidDBusMethod, callback));
+}
+
+void FakeAudioDspClient::GetFilterConfigOEM(
+    uint32 speaker_id,
+    const TwoStringDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnTwoStringDBusMethod, callback));
+}
+
+void FakeAudioDspClient::SetFilterConfigOEM(
+    const std::string& speaker_config,
+    const std::string& driver_config,
+    const VoidDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnVoidDBusMethod, callback));
+}
+
+void FakeAudioDspClient::SetSourceType(uint16 source_type,
+                                       const VoidDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnVoidDBusMethod, callback));
+}
+
+void FakeAudioDspClient::AmplifierVolumeChanged(
+    double db_spl,
+    const VoidDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OnVoidDBusMethod, callback));
+}
+
+}  // namespace chromeos
diff --git a/chromeos/dbus/fake_audio_dsp_client.h b/chromeos/dbus/fake_audio_dsp_client.h
new file mode 100644
index 0000000..05181ca
--- /dev/null
+++ b/chromeos/dbus/fake_audio_dsp_client.h
@@ -0,0 +1,59 @@
+// 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.
+
+#ifndef CHROMEOS_DBUS_FAKE_AUDIO_DSP_CLIENT_H_
+#define CHROMEOS_DBUS_FAKE_AUDIO_DSP_CLIENT_H_
+
+#include "base/basictypes.h"
+#include "chromeos/chromeos_export.h"
+#include "chromeos/dbus/audio_dsp_client.h"
+#include "chromeos/dbus/dbus_client.h"
+
+namespace chromeos {
+
+// A fake implementation of AudioDspClient. Invokes callbacks immediately.
+class CHROMEOS_EXPORT FakeAudioDspClient : public AudioDspClient {
+ public:
+  FakeAudioDspClient();
+  ~FakeAudioDspClient() override;
+
+  // DBusClient overrides:
+  void Init(dbus::Bus* bus) override;
+
+  // AudioDspClient overrides:
+  void AddObserver(Observer* observer) override;
+  void RemoveObserver(Observer* observer) override;
+  void Initialize(const BoolDBusMethodCallback& callback) override;
+  void SetStandbyMode(bool standby,
+                      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,
+                          const std::string& speaker_capabilities,
+                          const std::string& driver_capabilities,
+                          const VoidDBusMethodCallback& callback) override;
+  void GetFilterConfigOEM(uint32 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,
+                     const VoidDBusMethodCallback& callback) override;
+  void AmplifierVolumeChanged(double db_spl,
+                              const VoidDBusMethodCallback& callback) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(FakeAudioDspClient);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_DBUS_FAKE_AUDIO_DSP_CLIENT_H_