bluetooth: Modify DCHECK to conditionals in several BluetoothAdapterChromeOS methods.

device/bluetooth/bluetooth_chromeos_unittest.cc

 // Copyright 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 "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/dbus/dbus_thread_manager.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"
 #include "chromeos/dbus/fake_bluetooth_gatt_service_client.h"
 #include "chromeos/dbus/fake_bluetooth_input_client.h"
 #include "dbus/object_path.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_chromeos.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_device_chromeos.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_pairing_chromeos.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothAdapterFactory;
+using device::BluetoothAudioSink;
 using device::BluetoothDevice;
 using device::BluetoothDiscoverySession;
 using device::BluetoothUUID;
 
 namespace chromeos {
 
 namespace {
 
 class TestObserver : public BluetoothAdapter::Observer {
  public:
@@ skipping 102 matching lines @@
   scoped_refptr<BluetoothAdapter> adapter_;
 };
 
 // Callback for BluetoothDevice::GetConnectionInfo() that simply saves the
 // connection info to the bound argument.
 void SaveConnectionInfo(BluetoothDevice::ConnectionInfo* out,
                         const BluetoothDevice::ConnectionInfo& conn_info) {
   *out = conn_info;
 };
 
+class FakeBluetoothProfileServiceProviderDelegate
+    : public chromeos::BluetoothProfileServiceProvider::Delegate {
+ public:
+  FakeBluetoothProfileServiceProviderDelegate() {}
+
+  // BluetoothProfileServiceProvider::Delegate:
+  void Released() override {}
+
+  void NewConnection(const dbus::ObjectPath&,
+                     scoped_ptr<dbus::FileDescriptor>,
+                     const BluetoothProfileServiceProvider::Delegate::Options&,
+                     const ConfirmationCallback&) override {}
+
+  void RequestDisconnection(const dbus::ObjectPath&,
+                            const ConfirmationCallback&) override {}
+
+  void Cancel() override {}
+};
+
 }  // namespace
 
 class TestPairingDelegate : public BluetoothDevice::PairingDelegate {
  public:
   TestPairingDelegate()
       : call_count_(0),
         request_pincode_count_(0),
         request_passkey_count_(0),
         display_pincode_count_(0),
         display_passkey_count_(0),
@@ skipping 106 matching lines @@
 
   void TearDown() override {
     for (ScopedVector<BluetoothDiscoverySession>::iterator iter =
             discovery_sessions_.begin();
          iter != discovery_sessions_.end();
          ++iter) {
       BluetoothDiscoverySession* session = *iter;
       if (!session->IsActive())
         continue;
       callback_count_ = 0;
-      session->Stop(
-          base::Bind(&BluetoothChromeOSTest::Callback,
-                     base::Unretained(this)),
-          base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                     base::Unretained(this)));
+      session->Stop(GetCallback(), GetErrorCallback());
       message_loop_.Run();
       ASSERT_EQ(1, callback_count_);
     }
     discovery_sessions_.clear();
     adapter_ = NULL;
     DBusThreadManager::Shutdown();
   }
 
   // Generic callbacks
   void Callback() {
     ++callback_count_;
     QuitMessageLoop();
   }
 
+  base::Closure GetCallback() {
+    return base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this));
+  }
+
   void DiscoverySessionCallback(
       scoped_ptr<BluetoothDiscoverySession> discovery_session) {
     ++callback_count_;
     discovery_sessions_.push_back(discovery_session.release());
     QuitMessageLoop();
   }
 
+  void AudioSinkAcquiredCallback(scoped_refptr<BluetoothAudioSink>) {
+    ++callback_count_;
+    QuitMessageLoop();
+  }
+
+  void ProfileRegisteredCallback(BluetoothAdapterProfileChromeOS*) {
+    ++callback_count_;
+    QuitMessageLoop();
+  }
+
   void ErrorCallback() {
     ++error_callback_count_;
     QuitMessageLoop();
   }
 
+  base::Closure GetErrorCallback() {
+    return base::Bind(&BluetoothChromeOSTest::ErrorCallback,
+                      base::Unretained(this));
+  }
+
   void DBusErrorCallback(const std::string& error_name,
                          const std::string& error_message) {
     ++error_callback_count_;
     last_client_error_ = error_name;
     QuitMessageLoop();
   }
 
   void ConnectErrorCallback(BluetoothDevice::ConnectErrorCode error) {
     ++error_callback_count_;
     last_connect_error_ = error;
   }
 
+  void AudioSinkErrorCallback(BluetoothAudioSink::ErrorCode) {
+    ++error_callback_count_;
+    QuitMessageLoop();
+  }
+
+  void ErrorCompletionCallback(const std::string& error_message) {
+    ++error_callback_count_;
+    QuitMessageLoop();
+  }
+
   // Call to fill the adapter_ member with a BluetoothAdapter instance.
   void GetAdapter() {
     adapter_ = new BluetoothAdapterChromeOS();
     ASSERT_TRUE(adapter_.get() != NULL);
     ASSERT_TRUE(adapter_->IsInitialized());
   }
 
   // Run a discovery phase until the named device is detected, or if the named
   // device is not created, the discovery process ends without finding it.
   //
   // The correct behavior of discovery is tested by the "Discovery" test case
   // without using this function.
   void DiscoverDevice(const std::string& address) {
     ASSERT_TRUE(adapter_.get() != NULL);
     ASSERT_TRUE(base::MessageLoop::current() != NULL);
     fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
     TestObserver observer(adapter_);
 
-    adapter_->SetPowered(
-        true,
-        base::Bind(&BluetoothChromeOSTest::Callback,
-                   base::Unretained(this)),
-        base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                   base::Unretained(this)));
+    adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
     adapter_->StartDiscoverySession(
         base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
                    base::Unretained(this)),
-        base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                   base::Unretained(this)));
+        GetErrorCallback());
     base::MessageLoop::current()->Run();
     ASSERT_EQ(2, callback_count_);
     ASSERT_EQ(0, error_callback_count_);
     ASSERT_EQ((size_t)1, discovery_sessions_.size());
     ASSERT_TRUE(discovery_sessions_[0]->IsActive());
     callback_count_ = 0;
 
     ASSERT_TRUE(adapter_->IsPowered());
     ASSERT_TRUE(adapter_->IsDiscovering());
 
     while (!observer.device_removed_count_ &&
            observer.last_device_address_ != address)
       base::MessageLoop::current()->Run();
 
-    discovery_sessions_[0]->Stop(
-        base::Bind(&BluetoothChromeOSTest::Callback,
-                   base::Unretained(this)),
-        base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                   base::Unretained(this)));
+    discovery_sessions_[0]->Stop(GetCallback(), GetErrorCallback());
     base::MessageLoop::current()->Run();
     ASSERT_EQ(1, callback_count_);
     ASSERT_EQ(0, error_callback_count_);
     callback_count_ = 0;
 
     ASSERT_FALSE(adapter_->IsDiscovering());
   }
 
   // Run a discovery phase so we have devices that can be paired with.
   void DiscoverDevices() {
@@ skipping 146 matching lines @@
 }
 
 TEST_F(BluetoothChromeOSTest, BecomePowered) {
   GetAdapter();
   ASSERT_FALSE(adapter_->IsPowered());
 
   // Install an observer; expect the AdapterPoweredChanged to be called
   // with true, and IsPowered() to return true.
   TestObserver observer(adapter_);
 
-  adapter_->SetPowered(
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.powered_changed_count_);
   EXPECT_TRUE(observer.last_powered_);
 
   EXPECT_TRUE(adapter_->IsPowered());
 }
 
 TEST_F(BluetoothChromeOSTest, BecomeNotPowered) {
   GetAdapter();
-  adapter_->SetPowered(
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsPowered());
 
   // Install an observer; expect the AdapterPoweredChanged to be called
   // with false, and IsPowered() to return false.
   TestObserver observer(adapter_);
 
-  adapter_->SetPowered(
-      false,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetPowered(false, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.powered_changed_count_);
   EXPECT_FALSE(observer.last_powered_);
 
   EXPECT_FALSE(adapter_->IsPowered());
 }
 
 TEST_F(BluetoothChromeOSTest, SetPoweredWhenNotPresent) {
   GetAdapter();
   ASSERT_TRUE(adapter_->IsPresent());
 
   // Install an observer; expect the AdapterPresentChanged to be called
   // with false, and IsPresent() to return false.
   TestObserver observer(adapter_);
 
   fake_bluetooth_adapter_client_->SetVisible(false);
 
   EXPECT_EQ(1, observer.present_changed_count_);
   EXPECT_FALSE(observer.last_present_);
 
   EXPECT_FALSE(adapter_->IsPresent());
   EXPECT_FALSE(adapter_->IsPowered());
 
-  adapter_->SetPowered(
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
 
   EXPECT_EQ(0, observer.powered_changed_count_);
   EXPECT_FALSE(observer.last_powered_);
 
   EXPECT_FALSE(adapter_->IsPowered());
 }
 
 TEST_F(BluetoothChromeOSTest, ChangeAdapterName) {
   GetAdapter();
 
   static const std::string new_name(".__.");
 
-  adapter_->SetName(
-      new_name,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetName(new_name, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(new_name, adapter_->GetName());
 }
 
 TEST_F(BluetoothChromeOSTest, ChangeAdapterNameWhenNotPresent) {
   GetAdapter();
   ASSERT_TRUE(adapter_->IsPresent());
 
   // Install an observer; expect the AdapterPresentChanged to be called
   // with false, and IsPresent() to return false.
   TestObserver observer(adapter_);
 
   fake_bluetooth_adapter_client_->SetVisible(false);
 
   EXPECT_EQ(1, observer.present_changed_count_);
   EXPECT_FALSE(observer.last_present_);
 
   EXPECT_FALSE(adapter_->IsPresent());
   EXPECT_FALSE(adapter_->IsPowered());
 
-  adapter_->SetName(
-      "^o^",
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetName("^o^", GetCallback(), GetErrorCallback());
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
 
   EXPECT_EQ("", adapter_->GetName());
 }
 
 TEST_F(BluetoothChromeOSTest, BecomeDiscoverable) {
   GetAdapter();
   ASSERT_FALSE(adapter_->IsDiscoverable());
 
   // Install an observer; expect the AdapterDiscoverableChanged to be called
   // with true, and IsDiscoverable() to return true.
   TestObserver observer(adapter_);
 
-  adapter_->SetDiscoverable(
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetDiscoverable(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.discoverable_changed_count_);
 
   EXPECT_TRUE(adapter_->IsDiscoverable());
 }
 
 TEST_F(BluetoothChromeOSTest, BecomeNotDiscoverable) {
   GetAdapter();
-  adapter_->SetDiscoverable(
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetDiscoverable(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsDiscoverable());
 
   // Install an observer; expect the AdapterDiscoverableChanged to be called
   // with false, and IsDiscoverable() to return false.
   TestObserver observer(adapter_);
 
-  adapter_->SetDiscoverable(
-      false,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetDiscoverable(false, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.discoverable_changed_count_);
 
   EXPECT_FALSE(adapter_->IsDiscoverable());
 }
 
 TEST_F(BluetoothChromeOSTest, SetDiscoverableWhenNotPresent) {
   GetAdapter();
   ASSERT_TRUE(adapter_->IsPresent());
   ASSERT_FALSE(adapter_->IsDiscoverable());
 
   // Install an observer; expect the AdapterDiscoverableChanged to be called
   // with true, and IsDiscoverable() to return true.
   TestObserver observer(adapter_);
 
   fake_bluetooth_adapter_client_->SetVisible(false);
 
   EXPECT_EQ(1, observer.present_changed_count_);
   EXPECT_FALSE(observer.last_present_);
 
   EXPECT_FALSE(adapter_->IsPresent());
   EXPECT_FALSE(adapter_->IsDiscoverable());
 
-  adapter_->SetDiscoverable(
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetDiscoverable(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
 
   EXPECT_EQ(0, observer.discoverable_changed_count_);
 
   EXPECT_FALSE(adapter_->IsDiscoverable());
 }
 
 TEST_F(BluetoothChromeOSTest, StopDiscovery) {
   GetAdapter();
 
-  adapter_->SetPowered(
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   adapter_->StartDiscoverySession(
       base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   ASSERT_TRUE(discovery_sessions_[0]->IsActive());
 
   // Install an observer; aside from the callback, expect the
   // AdapterDiscoveringChanged method to be called and no longer to be
   // discovering,
   TestObserver observer(adapter_);
 
-  discovery_sessions_[0]->Stop(
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  discovery_sessions_[0]->Stop(GetCallback(), GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_FALSE(observer.last_discovering_);
 
   EXPECT_FALSE(adapter_->IsDiscovering());
 }
 
 TEST_F(BluetoothChromeOSTest, Discovery) {
   // Test a simulated discovery session.
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
   GetAdapter();
 
   TestObserver observer(adapter_);
 
-  adapter_->SetPowered(
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   adapter_->StartDiscoverySession(
       base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   ASSERT_TRUE(discovery_sessions_[0]->IsActive());
 
@@ skipping 12 matching lines @@
   while (!observer.device_removed_count_)
     message_loop_.Run();
 
   EXPECT_EQ(1, observer.device_removed_count_);
   EXPECT_EQ(FakeBluetoothDeviceClient::kVanishingDeviceAddress,
             observer.last_device_address_);
 }
 
 TEST_F(BluetoothChromeOSTest, PoweredAndDiscovering) {
   GetAdapter();
-  adapter_->SetPowered(
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   adapter_->StartDiscoverySession(
       base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   ASSERT_TRUE(discovery_sessions_[0]->IsActive());
 
   // Stop the timers that the simulation uses
   fake_bluetooth_device_client_->EndDiscoverySimulation(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
@@ skipping 43 matching lines @@
 
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_FALSE(observer.last_discovering_);
   EXPECT_FALSE(adapter_->IsDiscovering());
 }
 
 // This unit test asserts that the basic reference counting logic works
 // correctly for discovery requests done via the BluetoothAdapter.
 TEST_F(BluetoothChromeOSTest, MultipleDiscoverySessions) {
   GetAdapter();
-  adapter_->SetPowered(
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(adapter_->IsPowered());
   callback_count_ = 0;
 
   TestObserver observer(adapter_);
 
   EXPECT_EQ(0, observer.discovering_changed_count_);
   EXPECT_FALSE(observer.last_discovering_);
   EXPECT_FALSE(adapter_->IsDiscovering());
 
   // Request device discovery 3 times.
   for (int i = 0; i < 3; i++) {
     adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+        base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+                   base::Unretained(this)),
+        GetErrorCallback());
   }
   // Run only once, as there should have been one D-Bus call.
   message_loop_.Run();
 
   // The observer should have received the discovering changed event exactly
   // once, the success callback should have been called 3 times and the adapter
   // should be discovering.
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_EQ(3, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)3, discovery_sessions_.size());
 
   // Request to stop discovery twice.
   for (int i = 0; i < 2; i++) {
-    discovery_sessions_[i]->Stop(
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+    discovery_sessions_[i]->Stop(GetCallback(), GetErrorCallback());
   }
 
   // The observer should have received no additional discovering changed events,
   // the success callback should have been called 2 times and the adapter should
   // still be discovering.
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_EQ(5, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_FALSE(discovery_sessions_[0]->IsActive());
   EXPECT_FALSE(discovery_sessions_[1]->IsActive());
   EXPECT_TRUE(discovery_sessions_[2]->IsActive());
 
   // Request device discovery 3 times.
   for (int i = 0; i < 3; i++) {
     adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+        base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+                   base::Unretained(this)),
+        GetErrorCallback());
   }
 
   // The observer should have received no additional discovering changed events,
   // the success callback should have been called 3 times and the adapter should
   // still be discovering.
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_EQ(8, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)6, discovery_sessions_.size());
 
   // Request to stop discovery 4 times.
   for (int i = 2; i < 6; i++) {
-    discovery_sessions_[i]->Stop(
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+    discovery_sessions_[i]->Stop(GetCallback(), GetErrorCallback());
   }
   // Run only once, as there should have been one D-Bus call.
   message_loop_.Run();
 
   // The observer should have received the discovering changed event exactly
   // once, the success callback should have been called 4 times and the adapter
   // should no longer be discovering.
   EXPECT_EQ(2, observer.discovering_changed_count_);
   EXPECT_EQ(12, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(observer.last_discovering_);
   EXPECT_FALSE(adapter_->IsDiscovering());
 
   // All discovery sessions should be inactive.
   for (int i = 0; i < 6; i++)
     EXPECT_FALSE(discovery_sessions_[i]->IsActive());
 
   // Request to stop discovery on of the inactive sessions.
-  discovery_sessions_[0]->Stop(
-    base::Bind(&BluetoothChromeOSTest::Callback,
-               base::Unretained(this)),
-    base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-               base::Unretained(this)));
+  discovery_sessions_[0]->Stop(GetCallback(), GetErrorCallback());
 
   // The call should have failed.
   EXPECT_EQ(2, observer.discovering_changed_count_);
   EXPECT_EQ(12, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_FALSE(observer.last_discovering_);
   EXPECT_FALSE(adapter_->IsDiscovering());
 }
 
 // This unit test asserts that the reference counting logic works correctly in
 // the cases when the adapter gets reset and D-Bus calls are made outside of
 // the BluetoothAdapter.
 TEST_F(BluetoothChromeOSTest,
        UnexpectedChangesDuringMultipleDiscoverySessions) {
   GetAdapter();
-  adapter_->SetPowered(
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(adapter_->IsPowered());
   callback_count_ = 0;
 
   TestObserver observer(adapter_);
 
   EXPECT_EQ(0, observer.discovering_changed_count_);
   EXPECT_FALSE(observer.last_discovering_);
   EXPECT_FALSE(adapter_->IsDiscovering());
 
   // Request device discovery 3 times.
   for (int i = 0; i < 3; i++) {
     adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+        base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+                   base::Unretained(this)),
+        GetErrorCallback());
   }
   // Run only once, as there should have been one D-Bus call.
   message_loop_.Run();
 
   // The observer should have received the discovering changed event exactly
   // once, the success callback should have been called 3 times and the adapter
   // should be discovering.
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_EQ(3, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
@@ skipping 11 matching lines @@
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_TRUE(adapter_->IsDiscovering());
 
   // Stop device discovery behind the adapter. The adapter and the observer
   // should be notified of the change and the reference count should be reset.
   // Even though FakeBluetoothAdapterClient does its own reference counting and
   // we called 3 BluetoothAdapter::StartDiscoverySession 3 times, the
   // FakeBluetoothAdapterClient's count should be only 1 and a single call to
   // FakeBluetoothAdapterClient::StopDiscovery should work.
   fake_bluetooth_adapter_client_->StopDiscovery(
-      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
+      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), GetCallback(),
       base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                  base::Unretained(this)));
   message_loop_.Run();
   EXPECT_EQ(2, observer.discovering_changed_count_);
   EXPECT_EQ(4, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(observer.last_discovering_);
   EXPECT_FALSE(adapter_->IsDiscovering());
 
   // All discovery session instances should have been updated.
   for (int i = 0; i < 3; i++)
     EXPECT_FALSE(discovery_sessions_[i]->IsActive());
   discovery_sessions_.clear();
 
   // It should be possible to successfully start discovery.
   for (int i = 0; i < 2; i++) {
     adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+        base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+                   base::Unretained(this)),
+        GetErrorCallback());
   }
   // Run only once, as there should have been one D-Bus call.
   message_loop_.Run();
   EXPECT_EQ(3, observer.discovering_changed_count_);
   EXPECT_EQ(6, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)2, discovery_sessions_.size());
 
@@ skipping 24 matching lines @@
   EXPECT_EQ(6, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
 
   // Start and stop discovery. At this point, FakeBluetoothAdapterClient has
   // a reference count that is equal to 1. Pretend that this was done by an
   // application other than us. Starting and stopping discovery will succeed
   // but it won't cause the discovery state to change.
   adapter_->StartDiscoverySession(
-    base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
-               base::Unretained(this)),
-    base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-               base::Unretained(this)));
+      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+                 base::Unretained(this)),
+      GetErrorCallback());
   message_loop_.Run();  // Run the loop, as there should have been a D-Bus call.
   EXPECT_EQ(5, observer.discovering_changed_count_);
   EXPECT_EQ(7, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   EXPECT_TRUE(discovery_sessions_[0]->IsActive());
 
-  discovery_sessions_[0]->Stop(
-    base::Bind(&BluetoothChromeOSTest::Callback,
-               base::Unretained(this)),
-    base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-               base::Unretained(this)));
+  discovery_sessions_[0]->Stop(GetCallback(), GetErrorCallback());
   message_loop_.Run();  // Run the loop, as there should have been a D-Bus call.
   EXPECT_EQ(5, observer.discovering_changed_count_);
   EXPECT_EQ(8, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_FALSE(discovery_sessions_[0]->IsActive());
   discovery_sessions_.clear();
 
   // Start discovery again.
   adapter_->StartDiscoverySession(
-    base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
-               base::Unretained(this)),
-    base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-               base::Unretained(this)));
+      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+                 base::Unretained(this)),
+      GetErrorCallback());
   message_loop_.Run();  // Run the loop, as there should have been a D-Bus call.
   EXPECT_EQ(5, observer.discovering_changed_count_);
   EXPECT_EQ(9, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   EXPECT_TRUE(discovery_sessions_[0]->IsActive());
 
   // Stop discovery via D-Bus. The fake client's reference count will drop but
   // the discovery state won't change since our BluetoothAdapter also just
   // requested it via D-Bus.
   fake_bluetooth_adapter_client_->StopDiscovery(
-      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
+      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), GetCallback(),
       base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                  base::Unretained(this)));
   message_loop_.Run();
   EXPECT_EQ(5, observer.discovering_changed_count_);
   EXPECT_EQ(10, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
 
   // Now end the discovery session. This should change the adapter's discovery
   // state.
-  discovery_sessions_[0]->Stop(
-    base::Bind(&BluetoothChromeOSTest::Callback,
-               base::Unretained(this)),
-    base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-               base::Unretained(this)));
+  discovery_sessions_[0]->Stop(GetCallback(), GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(6, observer.discovering_changed_count_);
   EXPECT_EQ(11, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(observer.last_discovering_);
   EXPECT_FALSE(adapter_->IsDiscovering());
   EXPECT_FALSE(discovery_sessions_[0]->IsActive());
 }
 
 TEST_F(BluetoothChromeOSTest, InvalidatedDiscoverySessions) {
   GetAdapter();
-  adapter_->SetPowered(
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(adapter_->IsPowered());
   callback_count_ = 0;
 
   TestObserver observer(adapter_);
 
   EXPECT_EQ(0, observer.discovering_changed_count_);
   EXPECT_FALSE(observer.last_discovering_);
   EXPECT_FALSE(adapter_->IsDiscovering());
 
   // Request device discovery 3 times.
   for (int i = 0; i < 3; i++) {
     adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+        base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+                   base::Unretained(this)),
+        GetErrorCallback());
   }
   // Run only once, as there should have been one D-Bus call.
   message_loop_.Run();
 
   // The observer should have received the discovering changed event exactly
   // once, the success callback should have been called 3 times and the adapter
   // should be discovering.
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_EQ(3, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
@@ skipping 16 matching lines @@
   discovery_sessions_.pop_back();
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   EXPECT_TRUE(discovery_sessions_[0]->IsActive());
   EXPECT_TRUE(adapter_->IsDiscovering());
 
   // Stop device discovery behind the adapter. The one active discovery session
   // should become inactive, but more importantly, we shouldn't run into any
   // memory errors as the sessions that we explicitly deleted should get
   // cleaned up.
   fake_bluetooth_adapter_client_->StopDiscovery(
-      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
+      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), GetCallback(),
       base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                  base::Unretained(this)));
   message_loop_.Run();
   EXPECT_EQ(2, observer.discovering_changed_count_);
   EXPECT_EQ(4, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(observer.last_discovering_);
   EXPECT_FALSE(adapter_->IsDiscovering());
   EXPECT_FALSE(discovery_sessions_[0]->IsActive());
 }
 
 TEST_F(BluetoothChromeOSTest, QueuedDiscoveryRequests) {
   GetAdapter();
 
-  adapter_->SetPowered(
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(adapter_->IsPowered());
   callback_count_ = 0;
 
   TestObserver observer(adapter_);
 
   EXPECT_EQ(0, observer.discovering_changed_count_);
   EXPECT_FALSE(observer.last_discovering_);
   EXPECT_FALSE(adapter_->IsDiscovering());
 
   // Request to start discovery. The call should be pending.
   adapter_->StartDiscoverySession(
-    base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
-               base::Unretained(this)),
-    base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-               base::Unretained(this)));
+      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+                 base::Unretained(this)),
+      GetErrorCallback());
   EXPECT_EQ(0, callback_count_);
 
   fake_bluetooth_device_client_->EndDiscoverySimulation(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
 
   // The underlying adapter has started discovery, but our call hasn't returned
   // yet.
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_TRUE(discovery_sessions_.empty());
 
   // Request to start discovery twice. These should get queued and there should
   // be no change in state.
   for (int i = 0; i < 2; i++) {
     adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+        base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+                   base::Unretained(this)),
+        GetErrorCallback());
   }
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_TRUE(discovery_sessions_.empty());
 
   // Process the pending call. The queued calls should execute and the discovery
   // session reference count should increase.
   message_loop_.Run();
   EXPECT_EQ(3, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)3, discovery_sessions_.size());
 
   // Verify the reference count by removing sessions 3 times. The last request
   // should remain pending.
   for (int i = 0; i < 3; i++) {
-    discovery_sessions_[i]->Stop(
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+    discovery_sessions_[i]->Stop(GetCallback(), GetErrorCallback());
   }
   EXPECT_EQ(5, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(2, observer.discovering_changed_count_);
   EXPECT_FALSE(observer.last_discovering_);
   EXPECT_FALSE(adapter_->IsDiscovering());
   EXPECT_FALSE(discovery_sessions_[0]->IsActive());
   EXPECT_FALSE(discovery_sessions_[1]->IsActive());
   EXPECT_TRUE(discovery_sessions_[2]->IsActive());
 
   // Request to stop the session whose call is pending should fail.
-  discovery_sessions_[2]->Stop(
-    base::Bind(&BluetoothChromeOSTest::Callback,
-               base::Unretained(this)),
-    base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-               base::Unretained(this)));
+  discovery_sessions_[2]->Stop(GetCallback(), GetErrorCallback());
   EXPECT_EQ(5, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(2, observer.discovering_changed_count_);
   EXPECT_FALSE(observer.last_discovering_);
   EXPECT_FALSE(adapter_->IsDiscovering());
   EXPECT_TRUE(discovery_sessions_[2]->IsActive());
 
   // Request to start should get queued.
   adapter_->StartDiscoverySession(
-    base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
-               base::Unretained(this)),
-    base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-               base::Unretained(this)));
+      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+                 base::Unretained(this)),
+      GetErrorCallback());
   EXPECT_EQ(5, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(2, observer.discovering_changed_count_);
   EXPECT_FALSE(observer.last_discovering_);
   EXPECT_FALSE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)3, discovery_sessions_.size());
 
   // Run the pending request.
   message_loop_.Run();
   EXPECT_EQ(6, callback_count_);
@@ skipping 12 matching lines @@
   EXPECT_EQ(3, observer.discovering_changed_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)4, discovery_sessions_.size());
   EXPECT_TRUE(discovery_sessions_[3]->IsActive());
 }
 
 TEST_F(BluetoothChromeOSTest, StartDiscoverySession) {
   GetAdapter();
 
-  adapter_->SetPowered(
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(adapter_->IsPowered());
   callback_count_ = 0;
 
   TestObserver observer(adapter_);
 
   EXPECT_EQ(0, observer.discovering_changed_count_);
   EXPECT_FALSE(observer.last_discovering_);
   EXPECT_FALSE(adapter_->IsDiscovering());
   EXPECT_TRUE(discovery_sessions_.empty());
 
   // Request a new discovery session.
   adapter_->StartDiscoverySession(
       base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   EXPECT_TRUE(discovery_sessions_[0]->IsActive());
 
   // Start another session. A new one should be returned in the callback, which
   // in turn will destroy the previous session. Adapter should still be
   // discovering and the reference count should be 1.
   adapter_->StartDiscoverySession(
       base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)2, discovery_sessions_.size());
   EXPECT_TRUE(discovery_sessions_[0]->IsActive());
 
   // Request a new session.
   adapter_->StartDiscoverySession(
       base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_EQ(3, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)3, discovery_sessions_.size());
   EXPECT_TRUE(discovery_sessions_[1]->IsActive());
   EXPECT_NE(discovery_sessions_[0], discovery_sessions_[1]);
 
   // Stop the previous discovery session. The session should end but discovery
   // should continue.
-  discovery_sessions_[0]->Stop(
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  discovery_sessions_[0]->Stop(GetCallback(), GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(1, observer.discovering_changed_count_);
   EXPECT_EQ(4, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)3, discovery_sessions_.size());
   EXPECT_FALSE(discovery_sessions_[0]->IsActive());
   EXPECT_TRUE(discovery_sessions_[1]->IsActive());
 
@@ skipping 145 matching lines @@
   ASSERT_EQ(2U, devices.size());
   ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
             devices[0]->GetAddress());
 
   std::string address = devices[0]->GetAddress();
 
   // Install an observer; expect the DeviceRemoved method to be called
   // with the device we remove.
   TestObserver observer(adapter_);
 
-  devices[0]->Forget(
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  devices[0]->Forget(GetErrorCallback());
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.device_removed_count_);
   EXPECT_EQ(address, observer.last_device_address_);
 
   // GetDevices shouldn't return the device either.
   devices = adapter_->GetDevices();
   ASSERT_EQ(1U, devices.size());
 }
 
 TEST_F(BluetoothChromeOSTest, ForgetUnpairedDevice) {
   GetAdapter();
   DiscoverDevices();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConnectUnpairableAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   // Connect the device so it becomes trusted and remembered.
-  device->Connect(
-      NULL,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(NULL, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   ASSERT_EQ(1, callback_count_);
   ASSERT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(device->IsConnected());
   ASSERT_FALSE(device->IsConnecting());
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kConnectUnpairablePath));
   ASSERT_TRUE(properties->trusted.value());
 
   // Install an observer; expect the DeviceRemoved method to be called
   // with the device we remove.
   TestObserver observer(adapter_);
 
-  device->Forget(
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  device->Forget(GetErrorCallback());
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.device_removed_count_);
   EXPECT_EQ(FakeBluetoothDeviceClient::kConnectUnpairableAddress,
             observer.last_device_address_);
 
   // GetDevices shouldn't return the device either.
   device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConnectUnpairableAddress);
   EXPECT_FALSE(device != NULL);
 }
 
 TEST_F(BluetoothChromeOSTest, ConnectPairedDevice) {
   GetAdapter();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_TRUE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   // Connect without a pairing delegate; since the device is already Paired
   // this should succeed and the device should become connected.
-  device->Connect(
-      NULL,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(NULL, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // Two changes for connecting, one for connected and one for for trusted
   // after connecting.
   EXPECT_EQ(4, observer.device_changed_count_);
   EXPECT_EQ(device, observer.last_device_);
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 }
 
 TEST_F(BluetoothChromeOSTest, ConnectUnpairableDevice) {
   GetAdapter();
   DiscoverDevices();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConnectUnpairableAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   // Connect without a pairing delegate; since the device does not require
   // pairing, this should succeed and the device should become connected.
-  device->Connect(
-      NULL,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(NULL, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // Two changes for connecting, one for connected, one for for trusted after
   // connection, and one for the reconnect mode (IsConnectable).
   EXPECT_EQ(5, observer.device_changed_count_);
   EXPECT_EQ(device, observer.last_device_);
 
   EXPECT_TRUE(device->IsConnected());
@@ skipping 13 matching lines @@
 }
 
 TEST_F(BluetoothChromeOSTest, ConnectConnectedDevice) {
   GetAdapter();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_TRUE(device->IsPaired());
 
-  device->Connect(
-      NULL,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(NULL, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   ASSERT_EQ(1, callback_count_);
   ASSERT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(device->IsConnected());
 
   // Connect again; since the device is already Connected, this shouldn't do
   // anything to initiate the connection.
   TestObserver observer(adapter_);
 
-  device->Connect(
-      NULL,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(NULL, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // The observer will be called because Connecting will toggle true and false,
   // and the trusted property will be updated to true.
   EXPECT_EQ(3, observer.device_changed_count_);
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 }
 
 TEST_F(BluetoothChromeOSTest, ConnectDeviceFails) {
   GetAdapter();
   DiscoverDevices();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kLegacyAutopairAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   // Connect without a pairing delegate; since the device requires pairing,
   // this should fail with an error.
-  device->Connect(
-      NULL,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(NULL, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothDevice::ERROR_FAILED, last_connect_error_);
 
   EXPECT_EQ(2, observer.device_changed_count_);
 
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 }
 
 TEST_F(BluetoothChromeOSTest, DisconnectDevice) {
   GetAdapter();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_TRUE(device->IsPaired());
 
-  device->Connect(
-      NULL,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(NULL, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   ASSERT_EQ(1, callback_count_);
   ASSERT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(device->IsConnected());
   ASSERT_FALSE(device->IsConnecting());
 
   // Disconnect the device, we should see the observer method fire and the
   // device get dropped.
   TestObserver observer(adapter_);
 
-  device->Disconnect(
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  device->Disconnect(GetCallback(), GetErrorCallback());
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.device_changed_count_);
   EXPECT_EQ(device, observer.last_device_);
 
   EXPECT_FALSE(device->IsConnected());
 }
 
 TEST_F(BluetoothChromeOSTest, DisconnectUnconnectedDevice) {
   GetAdapter();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_TRUE(device->IsPaired());
   ASSERT_FALSE(device->IsConnected());
 
   // Disconnect the device, we should see the observer method fire and the
   // device get dropped.
   TestObserver observer(adapter_);
 
-  device->Disconnect(
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  device->Disconnect(GetCallback(), GetErrorCallback());
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
 
   EXPECT_EQ(0, observer.device_changed_count_);
 
   EXPECT_FALSE(device->IsConnected());
 }
 
 TEST_F(BluetoothChromeOSTest, PairLegacyAutopair) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // The Legacy Autopair device requires no PIN or Passkey to pair because
   // the daemon provides 0000 to the device for us.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kLegacyAutopairAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // Two changes for connecting, one change for connected, one for paired,
@@ skipping 28 matching lines @@
 
   // Requires that we display a randomly generated PIN on the screen.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kDisplayPinCodeAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.display_pincode_count_);
   EXPECT_EQ("123456", pairing_delegate.last_pincode_);
   EXPECT_TRUE(device->IsConnecting());
 
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
@@ skipping 31 matching lines @@
   // Requires that we display a randomly generated Passkey on the screen,
   // and notifies us as it's typed in.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kDisplayPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   // One call for DisplayPasskey() and one for KeysEntered().
   EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.display_passkey_count_);
   EXPECT_EQ(123456U, pairing_delegate.last_passkey_);
   EXPECT_EQ(1, pairing_delegate.keys_entered_count_);
   EXPECT_EQ(0U, pairing_delegate.last_entered_);
 
   EXPECT_TRUE(device->IsConnecting());
 
@@ skipping 51 matching lines @@
 
   // Requires that the user enters a PIN for them.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPinCodeAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_pincode_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Set the PIN.
   device->SetPinCode("1234");
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
@@ skipping 31 matching lines @@
 
   // Requests that we confirm a displayed passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.confirm_passkey_count_);
   EXPECT_EQ(123456U, pairing_delegate.last_passkey_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Confirm the passkey.
   device->ConfirmPairing();
   message_loop_.Run();
 
@@ skipping 29 matching lines @@
   // Requires that the user enters a Passkey, this would be some kind of
   // device that has a display, but doesn't use "just works" - maybe a car?
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_passkey_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Set the Passkey.
   device->SetPasskey(1234);
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
@@ skipping 28 matching lines @@
   // Uses just-works pairing, since this is an outgoing pairing, no delegate
   // interaction is required.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kJustWorksAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
 
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // Two changes for connecting, one change for connected, one for paired and
   // two for trusted (after pairing and connection).
@@ skipping 22 matching lines @@
   DiscoverDevice(FakeBluetoothDeviceClient::kUnconnectableDeviceAddress);
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kUnpairableDeviceAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Run the loop to get the error..
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
 
@@ skipping 12 matching lines @@
 
   // The vanishing device times out during pairing
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kVanishingDeviceAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Run the loop to get the error..
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
 
@@ skipping 13 matching lines @@
   // Everything seems to go according to plan with the unconnectable device;
   // it pairs, but then you can't make connections to it after.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kUnconnectableDeviceAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothDevice::ERROR_FAILED, last_connect_error_);
 
@@ skipping 24 matching lines @@
 
   // Reject the pairing after we receive a request for the PIN code.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPinCodeAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_pincode_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Reject the pairing.
   device->RejectPairing();
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
@@ skipping 15 matching lines @@
 
   // Cancel the pairing after we receive a request for the PIN code.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPinCodeAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_pincode_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Cancel the pairing.
   device->CancelPairing();
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
@@ skipping 15 matching lines @@
 
   // Reject the pairing after we receive a request for the passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_passkey_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Reject the pairing.
   device->RejectPairing();
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
@@ skipping 15 matching lines @@
 
   // Cancel the pairing after we receive a request for the passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_passkey_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Cancel the pairing.
   device->CancelPairing();
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
@@ skipping 15 matching lines @@
 
   // Reject the pairing after we receive a request for passkey confirmation.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.confirm_passkey_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Reject the pairing.
   device->RejectPairing();
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
@@ skipping 15 matching lines @@
 
   // Cancel the pairing after we receive a request for the passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.confirm_passkey_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Cancel the pairing.
   device->CancelPairing();
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
@@ skipping 15 matching lines @@
 
   // Cancel the pairing while we're waiting for the remote host.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kLegacyAutopairAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
-  device->Connect(
-      &pairing_delegate,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(&pairing_delegate, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Cancel the pairing.
   device->CancelPairing();
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
@@ skipping 21 matching lines @@
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPinCodeAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath),
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
-                 base::Unretained(this)));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath), true,
+      GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+                                base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_pincode_count_);
 
   // Set the PIN.
   device->SetPinCode("1234");
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
@@ skipping 31 matching lines @@
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath),
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
-                 base::Unretained(this)));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath), true,
+      GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+                                base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.confirm_passkey_count_);
   EXPECT_EQ(123456U, pairing_delegate.last_passkey_);
 
   // Confirm the passkey.
   device->ConfirmPairing();
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
@@ skipping 32 matching lines @@
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath),
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
-                 base::Unretained(this)));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath), true,
+      GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+                                base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_passkey_count_);
 
   // Set the Passkey.
   device->SetPasskey(1234);
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
@@ skipping 32 matching lines @@
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kJustWorksAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath),
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
-                 base::Unretained(this)));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath), true,
+      GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+                                base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.authorize_pairing_count_);
 
   // Confirm the pairing.
   device->ConfirmPairing();
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
@@ skipping 27 matching lines @@
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPinCodeAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath),
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
-                 base::Unretained(this)));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath), true,
+      GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+                                base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_);
 
   // No changes should be observer.
   EXPECT_EQ(0, observer.device_changed_count_);
 
@@ skipping 16 matching lines @@
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath),
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
-                 base::Unretained(this)));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath), true,
+      GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+                                base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_);
 
   // No changes should be observer.
   EXPECT_EQ(0, observer.device_changed_count_);
 
@@ skipping 16 matching lines @@
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath),
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
-                 base::Unretained(this)));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath), true,
+      GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+                                base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_);
 
   // No changes should be observer.
   EXPECT_EQ(0, observer.device_changed_count_);
 
@@ skipping 16 matching lines @@
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kJustWorksAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath),
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
-                 base::Unretained(this)));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath), true,
+      GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+                                base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_);
 
   // No changes should be observer.
   EXPECT_EQ(0, observer.device_changed_count_);
 
@@ skipping 20 matching lines @@
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath),
-      true,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
-                 base::Unretained(this)));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath), true,
+      GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+                                base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_passkey_count_);
 
   // A pairing context should now be set on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
   ASSERT_TRUE(device_chromeos->GetPairing() != NULL);
 
   // Removing the pairing delegate should remove that pairing context.
@@ skipping 81 matching lines @@
   EXPECT_EQ(unknown_power, conn_info.rssi);
   EXPECT_EQ(unknown_power, conn_info.transmit_power);
   EXPECT_EQ(unknown_power, conn_info.max_transmit_power);
 }
 
 TEST_F(BluetoothChromeOSTest, GetConnectionInfoForConnectedDevice) {
   GetAdapter();
   BluetoothDevice* device =
       adapter_->GetDevice(FakeBluetoothDeviceClient::kPairedDeviceAddress);
 
-  device->Connect(
-      NULL,
-      base::Bind(&BluetoothChromeOSTest::Callback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
-                 base::Unretained(this)));
+  device->Connect(NULL, GetCallback(),
+                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                             base::Unretained(this)));
   EXPECT_TRUE(device->IsConnected());
 
   // Calling GetConnectionInfo for a connected device should return valid
   // results.
   fake_bluetooth_device_client_->UpdateConnectionInfo(-10, 3, 4);
   BluetoothDevice::ConnectionInfo conn_info;
   device->GetConnectionInfo(base::Bind(&SaveConnectionInfo, &conn_info));
   EXPECT_EQ(-10, conn_info.rssi);
   EXPECT_EQ(3, conn_info.transmit_power);
   EXPECT_EQ(4, conn_info.max_transmit_power);
 }
 
 // Verifies Shutdown shuts down the adapter as expected.
 TEST_F(BluetoothChromeOSTest, Shutdown) {
-  // Set up and adapter, power, discoverable, start discovery.
+  // Set up adapter. Set powered & discoverable, start discovery.
   GetAdapter();
-  adapter_->SetPowered(true, base::Bind(&BluetoothChromeOSTest::Callback,
-                                        base::Unretained(this)),
-                       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                                  base::Unretained(this)));
-  adapter_->SetDiscoverable(true, base::Bind(&BluetoothChromeOSTest::Callback,
-                                             base::Unretained(this)),
-                            base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                                       base::Unretained(this)));
+  adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
+  adapter_->SetDiscoverable(true, GetCallback(), GetErrorCallback());
   adapter_->StartDiscoverySession(
       base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      GetErrorCallback());
   base::MessageLoop::current()->Run();
   ASSERT_EQ(3, callback_count_);
   ASSERT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
+  TestPairingDelegate pairing_delegate;
+  adapter_->AddPairingDelegate(
+      &pairing_delegate, BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
+
   // Validate running adapter state.
   EXPECT_NE("", adapter_->GetAddress());
   EXPECT_NE("", adapter_->GetName());
   EXPECT_TRUE(adapter_->IsInitialized());
   EXPECT_TRUE(adapter_->IsPresent());
   EXPECT_TRUE(adapter_->IsPowered());
   EXPECT_TRUE(adapter_->IsDiscoverable());
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_EQ(2U, adapter_->GetDevices().size());
   EXPECT_NE(nullptr, adapter_->GetDevice(
                          FakeBluetoothDeviceClient::kPairedDeviceAddress));
   EXPECT_NE(dbus::ObjectPath(""), static_cast<BluetoothAdapterChromeOS*>(
                                       adapter_.get())->object_path());
 
   // Shutdown
-  static_cast<BluetoothAdapterChromeOS*>(adapter_.get())->Shutdown();
-
-  // Validate post shutdown state.
+  adapter_->Shutdown();
+
+  // Validate post shutdown state by calling all BluetoothAdapterChromeOS
+  // members, in declaration order:
+
+  adapter_->Shutdown();
+  // DeleteOnCorrectThread omitted as we don't want to delete in this test.
+  {
+    TestObserver observer(adapter_);  // Calls AddObserver
+  }  // TestObserver::~TestObserver calls RemoveObserver.
   EXPECT_EQ("", adapter_->GetAddress());
   EXPECT_EQ("", adapter_->GetName());
+
+  adapter_->SetName("", GetCallback(), GetErrorCallback());
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(1, error_callback_count_--) << "SetName error";
+
   EXPECT_TRUE(adapter_->IsInitialized());
   EXPECT_FALSE(adapter_->IsPresent());
   EXPECT_FALSE(adapter_->IsPowered());
+
+  adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(1, error_callback_count_--) << "SetPowered error";
+
   EXPECT_FALSE(adapter_->IsDiscoverable());
+
+  adapter_->SetDiscoverable(true, GetCallback(), GetErrorCallback());
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(1, error_callback_count_--) << "SetDiscoverable error";
+
   EXPECT_FALSE(adapter_->IsDiscovering());
+  // CreateRfcommService will DCHECK after Shutdown().
+  // CreateL2capService will DCHECK after Shutdown().
+
+  BluetoothAudioSink::Options audio_sink_options;
+  adapter_->RegisterAudioSink(
+      audio_sink_options,
+      base::Bind(&BluetoothChromeOSTest::AudioSinkAcquiredCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothChromeOSTest::AudioSinkErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(1, error_callback_count_--) << "RegisterAudioSink error";
+
+  BluetoothAdapterChromeOS* adapter_chrome_os =
+      static_cast<BluetoothAdapterChromeOS*>(adapter_.get());
+  EXPECT_EQ(NULL, adapter_chrome_os->GetDeviceWithPath(dbus::ObjectPath("")));
+
+  // Notify methods presume objects exist that are owned by the adapter and
+  // destroyed in Shutdown(). Mocks are not attempted here that won't exist,
+  // as verified below by EXPECT_EQ(0U, adapter_->GetDevices().size());
+  // NotifyDeviceChanged
+  // NotifyGattServiceAdded
+  // NotifyGattServiceRemoved
+  // NotifyGattServiceChanged
+  // NotifyGattDiscoveryComplete
+  // NotifyGattCharacteristicAdded
+  // NotifyGattCharacteristicRemoved
+  // NotifyGattDescriptorAdded
+  // NotifyGattDescriptorRemoved
+  // NotifyGattCharacteristicValueChanged
+  // NotifyGattDescriptorValueChanged
+
+  EXPECT_EQ(dbus::ObjectPath(""), adapter_chrome_os->object_path());
+
+  FakeBluetoothProfileServiceProviderDelegate profile_delegate;
+  adapter_chrome_os->UseProfile(
+      BluetoothUUID(), dbus::ObjectPath(""),
+      BluetoothProfileManagerClient::Options(), &profile_delegate,
+      base::Bind(&BluetoothChromeOSTest::ProfileRegisteredCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothChromeOSTest::ErrorCompletionCallback,
+                 base::Unretained(this)));
+  base::MessageLoop::current()->Run();
+  EXPECT_EQ(1, callback_count_--) << "UseProfile error";
+  EXPECT_EQ(0, error_callback_count_) << "UseProfile error";
+
+  adapter_chrome_os->ReleaseProfile(BluetoothUUID());
+
+  // Protected and private methods:
+
+  adapter_chrome_os->RemovePairingDelegateInternal(&pairing_delegate);
+
+  // BluetoothAdapterClient::Observer methods omitted, dbus will be shutdown.
+  // BluetoothDeviceClient::Observer methods omitted, dbus will be shutdown.
+  // BluetoothInputClient::Observer methods omitted, dbus will be shutdown.
+  // BluetoothAgentServiceProvider::Delegate omitted, dbus will be shutdown,
+  //   with the exception of Released.
+  adapter_chrome_os->Released();
+
+  adapter_chrome_os->OnRegisterAgent();
+  adapter_chrome_os->OnRegisterAgentError("", "");
+  adapter_chrome_os->OnRequestDefaultAgent();
+  adapter_chrome_os->OnRequestDefaultAgentError("", "");
+
+  adapter_chrome_os->OnRegisterAudioSink(
+      base::Bind(&BluetoothChromeOSTest::AudioSinkAcquiredCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothChromeOSTest::AudioSinkErrorCallback,
+                 base::Unretained(this)),
+      scoped_refptr<device::BluetoothAudioSink>());
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(1, error_callback_count_--) << "RegisterAudioSink error";
+
+  // GetPairing will DCHECK after Shutdown().
+  // SetAdapter will DCHECK after Shutdown().
+  // SetDefaultAdapterName will DCHECK after Shutdown().
+  // RemoveAdapter will DCHECK after Shutdown().
+  adapter_chrome_os->PoweredChanged(false);
+  adapter_chrome_os->DiscoverableChanged(false);
+  adapter_chrome_os->DiscoveringChanged(false);
+  adapter_chrome_os->PresentChanged(false);
+
+  adapter_chrome_os->OnSetDiscoverable(GetCallback(), GetErrorCallback(), true);
+  EXPECT_EQ(0, callback_count_) << "OnSetDiscoverable error";
+  EXPECT_EQ(1, error_callback_count_--) << "OnSetDiscoverable error";
+
+  adapter_chrome_os->OnPropertyChangeCompleted(GetCallback(),
+                                               GetErrorCallback(), true);
+  EXPECT_EQ(0, callback_count_) << "OnPropertyChangeCompleted error";
+  EXPECT_EQ(1, error_callback_count_--) << "OnPropertyChangeCompleted error";
+
+  adapter_chrome_os->AddDiscoverySession(GetCallback(), GetErrorCallback());
+  EXPECT_EQ(0, callback_count_) << "AddDiscoverySession error";
+  EXPECT_EQ(1, error_callback_count_--) << "AddDiscoverySession error";
+
+  adapter_chrome_os->RemoveDiscoverySession(GetCallback(), GetErrorCallback());
+  EXPECT_EQ(0, callback_count_) << "RemoveDiscoverySession error";
+  EXPECT_EQ(1, error_callback_count_--) << "RemoveDiscoverySession error";
+
+  // OnStartDiscovery tested in Shutdown_OnStartDiscovery
+  // OnStartDiscoveryError tested in Shutdown_OnStartDiscoveryError
+  // OnStopDiscovery tested in Shutdown_OnStopDiscovery
+  // OnStopDiscoveryError tested in Shutdown_OnStopDiscoveryError
+
+  // OnRegisterProfile SetProfileDelegate, OnRegisterProfileError, require
+  // UseProfile to be set first, do so again here just before calling them.
+  adapter_chrome_os->UseProfile(
+      BluetoothUUID(), dbus::ObjectPath(""),
+      BluetoothProfileManagerClient::Options(), &profile_delegate,
+      base::Bind(&BluetoothChromeOSTest::ProfileRegisteredCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothChromeOSTest::ErrorCompletionCallback,
+                 base::Unretained(this)));
+
+  adapter_chrome_os->OnRegisterProfile(
+      BluetoothUUID(), dbus::ObjectPath(""), &profile_delegate,
+      base::Bind(&BluetoothChromeOSTest::ProfileRegisteredCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothChromeOSTest::ErrorCompletionCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(1, callback_count_--) << "OnRegisterProfile error";
+  EXPECT_EQ(1, error_callback_count_--) << "OnRegisterProfile error";
+
+  adapter_chrome_os->SetProfileDelegate(
+      BluetoothUUID(), dbus::ObjectPath(""), &profile_delegate,
+      base::Bind(&BluetoothChromeOSTest::ProfileRegisteredCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothChromeOSTest::ErrorCompletionCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(0, callback_count_) << "SetProfileDelegate error";
+  EXPECT_EQ(1, error_callback_count_--) << "SetProfileDelegate error";
+
+  adapter_chrome_os->OnRegisterProfileError(
+      BluetoothUUID(),
+      base::Bind(&BluetoothChromeOSTest::ErrorCompletionCallback,
+                 base::Unretained(this)),
+      "", "");
+  EXPECT_EQ(0, callback_count_) << "OnRegisterProfileError error";
+  EXPECT_EQ(1, error_callback_count_--) << "OnRegisterProfileError error";
+
+  adapter_chrome_os->ProcessQueuedDiscoveryRequests();
+
+  // From BluetoothAdapater:
+
+  adapter_->StartDiscoverySession(
+      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+                 base::Unretained(this)),
+      GetErrorCallback());
+  EXPECT_EQ(0, callback_count_) << "StartDiscoverySession error";
+  EXPECT_EQ(1, error_callback_count_--) << "StartDiscoverySession error";
+
   EXPECT_EQ(0U, adapter_->GetDevices().size());
   EXPECT_EQ(nullptr, adapter_->GetDevice(
                          FakeBluetoothDeviceClient::kPairedDeviceAddress));
-  EXPECT_EQ(dbus::ObjectPath(""), static_cast<BluetoothAdapterChromeOS*>(
-                                      adapter_.get())->object_path());
-
-  adapter_->SetPowered(true, base::Bind(&BluetoothChromeOSTest::Callback,
-                                        base::Unretained(this)),
-                       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                                  base::Unretained(this)));
-  adapter_->SetDiscoverable(true, base::Bind(&BluetoothChromeOSTest::Callback,
-                                             base::Unretained(this)),
-                            base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                                       base::Unretained(this)));
-  adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
-  ASSERT_EQ(0, callback_count_);
-  ASSERT_EQ(3, error_callback_count_);
+  TestPairingDelegate pairing_delegate2;
+  adapter_->AddPairingDelegate(
+      &pairing_delegate2, BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
+  adapter_->RemovePairingDelegate(&pairing_delegate2);
+}
+
+// Verifies post-Shutdown of discovery sessions and OnStartDiscovery.
+TEST_F(BluetoothChromeOSTest, Shutdown_OnStartDiscovery) {
+  const int kNumberOfDiscoverySessions = 10;
+  GetAdapter();
+  BluetoothAdapterChromeOS* adapter_chrome_os =
+      static_cast<BluetoothAdapterChromeOS*>(adapter_.get());
+
+  for (int i = 0; i < kNumberOfDiscoverySessions; i++) {
+    adapter_chrome_os->AddDiscoverySession(GetCallback(), GetErrorCallback());
+  }
+  adapter_->Shutdown();
+  adapter_chrome_os->OnStartDiscovery(GetCallback(), GetErrorCallback());
+
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(kNumberOfDiscoverySessions, error_callback_count_);
+}
+
+// Verifies post-Shutdown of discovery sessions and OnStartDiscoveryError.
+TEST_F(BluetoothChromeOSTest, Shutdown_OnStartDiscoveryError) {
+  const int kNumberOfDiscoverySessions = 10;
+  GetAdapter();
+  BluetoothAdapterChromeOS* adapter_chrome_os =
+      static_cast<BluetoothAdapterChromeOS*>(adapter_.get());
+
+  for (int i = 0; i < kNumberOfDiscoverySessions; i++) {
+    adapter_chrome_os->AddDiscoverySession(GetCallback(), GetErrorCallback());
+  }
+  adapter_->Shutdown();
+  adapter_chrome_os->OnStartDiscoveryError(GetCallback(), GetErrorCallback(),
+                                           "", "");
+
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(kNumberOfDiscoverySessions, error_callback_count_);
+}
+
+// Verifies post-Shutdown of discovery sessions and OnStartDiscovery.
+TEST_F(BluetoothChromeOSTest, Shutdown_OnStopDiscovery) {
+  const int kNumberOfDiscoverySessions = 10;
+  GetAdapter();
+  BluetoothAdapterChromeOS* adapter_chrome_os =
+      static_cast<BluetoothAdapterChromeOS*>(adapter_.get());
+
+  // In order to queue up discovery sessions before an OnStopDiscovery call
+  // RemoveDiscoverySession must be called, so Add, Start, and Remove:
+  adapter_chrome_os->AddDiscoverySession(GetCallback(), GetErrorCallback());
+  adapter_chrome_os->OnStartDiscovery(GetCallback(), GetErrorCallback());
+  adapter_chrome_os->RemoveDiscoverySession(GetCallback(), GetErrorCallback());
+  callback_count_ = 0;
+  error_callback_count_ = 0;
+  // Can now queue discovery sessions while waiting for OnStopDiscovery.
+  for (int i = 0; i < kNumberOfDiscoverySessions; i++) {
+    adapter_chrome_os->AddDiscoverySession(GetCallback(), GetErrorCallback());
+  }
+  adapter_->Shutdown();
+  adapter_chrome_os->OnStopDiscovery(GetCallback());
+
+  // 1 successful stopped discovery from RemoveDiscoverySession, and
+  // kNumberOfDiscoverySessions errors from AddDiscoverySession/OnStopDiscovery.
+  EXPECT_EQ(1, callback_count_);
+  EXPECT_EQ(kNumberOfDiscoverySessions, error_callback_count_);
+}
+
+// Verifies post-Shutdown of discovery sessions and OnStopDiscoveryError.
+TEST_F(BluetoothChromeOSTest, Shutdown_OnStopDiscoveryError) {
+  const int kNumberOfDiscoverySessions = 10;
+  GetAdapter();
+  BluetoothAdapterChromeOS* adapter_chrome_os =
+      static_cast<BluetoothAdapterChromeOS*>(adapter_.get());
+
+  // In order to queue up discovery sessions before an OnStopDiscoveryError call
+  // RemoveDiscoverySession must be called, so Add, Start, and Remove:
+  adapter_chrome_os->AddDiscoverySession(GetCallback(), GetErrorCallback());
+  adapter_chrome_os->OnStartDiscovery(GetCallback(), GetErrorCallback());
+  adapter_chrome_os->RemoveDiscoverySession(GetCallback(), GetErrorCallback());
+  callback_count_ = 0;
+  error_callback_count_ = 0;
+  // Can now queue discovery sessions while waiting for OnStopDiscoveryError.
+  for (int i = 0; i < kNumberOfDiscoverySessions; i++) {
+    adapter_chrome_os->AddDiscoverySession(GetCallback(), GetErrorCallback());
+  }
+  adapter_->Shutdown();
+  adapter_chrome_os->OnStopDiscoveryError(GetErrorCallback(), "", "");
+
+  // 1 error reported to RemoveDiscoverySession because of OnStopDiscoveryError,
+  // and kNumberOfDiscoverySessions errors queued with AddDiscoverySession.
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(1 + kNumberOfDiscoverySessions, error_callback_count_);
 }
 
 }  // namespace chromeos