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/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 132 matching lines @@
     QuitMessageLoop();
   }
 
   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();
   }
 
   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.
   //
@@ skipping 2981 matching lines @@
   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_->StartDiscoverySession(
       base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   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(
+      "", base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(1, error_callback_count_) << "SetName error";
+  error_callback_count_ = 0;
+
   EXPECT_TRUE(adapter_->IsInitialized());
   EXPECT_FALSE(adapter_->IsPresent());
   EXPECT_FALSE(adapter_->IsPowered());
-  EXPECT_FALSE(adapter_->IsDiscoverable());
-  EXPECT_FALSE(adapter_->IsDiscovering());
-  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)));
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(1, error_callback_count_) << "SetPowered error";
+  error_callback_count_ = 0;
+
+  EXPECT_FALSE(adapter_->IsDiscoverable());
+
   adapter_->SetDiscoverable(true, base::Bind(&BluetoothChromeOSTest::Callback,
                                              base::Unretained(this)),
                             base::Bind(&BluetoothChromeOSTest::ErrorCallback,
                                        base::Unretained(this)));
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(1, error_callback_count_) << "SetDiscoverable error";
+  error_callback_count_ = 0;
+
+  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";
+  error_callback_count_ = 0;
+
+  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)));
+  EXPECT_EQ(0, callback_count_) << "UseProfile error";
+  EXPECT_EQ(0, error_callback_count_) << "UseProfile error";
+  error_callback_count_ = 0;
+
+  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("", "");
+
+  scoped_refptr<device::BluetoothAudioSink> audio_sink;
+  adapter_chrome_os->OnRegisterAudioSink(
+      base::Bind(&BluetoothChromeOSTest::AudioSinkAcquiredCallback,
+                 base::Unretained(this)),
+      audio_sink);
+  EXPECT_EQ(0, callback_count_);
+  EXPECT_EQ(0, 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(
+      base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothChromeOSTest::ErrorCallback, base::Unretained(this)),
+      true);
+  EXPECT_EQ(0, callback_count_) << "OnSetDiscoverable error";
+  EXPECT_EQ(1, error_callback_count_) << "OnSetDiscoverable error";
+  error_callback_count_ = 0;
+
+  adapter_chrome_os->OnPropertyChangeCompleted(
+      base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothChromeOSTest::ErrorCallback, base::Unretained(this)),
+      true);
+  EXPECT_EQ(0, callback_count_) << "OnPropertyChangeCompleted error";
+  EXPECT_EQ(1, error_callback_count_) << "OnPropertyChangeCompleted error";
+  error_callback_count_ = 0;
+
+  adapter_chrome_os->AddDiscoverySession(
+      base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(0, callback_count_) << "AddDiscoverySession error";
+  EXPECT_EQ(1, error_callback_count_) << "AddDiscoverySession error";
+  error_callback_count_ = 0;
+
+  adapter_chrome_os->RemoveDiscoverySession(
+      base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(0, callback_count_) << "RemoveDiscoverySession error";
+  EXPECT_EQ(1, error_callback_count_) << "RemoveDiscoverySession error";
+  error_callback_count_ = 0;
+
+  // OnStartDiscovery will DCHECK after Shutdown().
+
+  adapter_chrome_os->OnStartDiscoveryError(
+      base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothChromeOSTest::ErrorCallback, base::Unretained(this)),
+      "", "");
+  EXPECT_EQ(0, callback_count_) << "OnStartDiscoveryError error";
+  EXPECT_EQ(1, error_callback_count_) << "OnStartDiscoveryError error";
+  error_callback_count_ = 0;
+
+  // OnStopDiscovery will fail after Shutdown().
+
+  adapter_chrome_os->OnStopDiscoveryError(
+      base::Bind(&BluetoothChromeOSTest::ErrorCallback, base::Unretained(this)),
+      "", "");
+  EXPECT_EQ(0, callback_count_) << "OnStopDiscoveryError error";
+  EXPECT_EQ(1, error_callback_count_) << "OnStopDiscoveryError error";
+  error_callback_count_ = 0;
+
+  // OnRegisterProfile omitted, dbus will be shutdown.
+  // SetProfileDelegate omitted, dbus will be shutdown.
+  // OnRegisterProfileError omitted, dbus will be shutdown.
+
+  adapter_chrome_os->ProcessQueuedDiscoveryRequests();
+
+  // From BluetoothAdapater:
+
   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_);
+  EXPECT_EQ(0, callback_count_) << "StartDiscoverySession error";
+  EXPECT_EQ(1, error_callback_count_) << "StartDiscoverySession error";
+  error_callback_count_ = 0;
+
+  EXPECT_EQ(0U, adapter_->GetDevices().size());
+  EXPECT_EQ(nullptr, adapter_->GetDevice(
+                         FakeBluetoothDeviceClient::kPairedDeviceAddress));
+  TestPairingDelegate pairing_delegate2;
+  adapter_->AddPairingDelegate(
+      &pairing_delegate2, BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
+  adapter_->RemovePairingDelegate(&pairing_delegate2);
 }
 
 }  // namespace chromeos