Delete unused BluetoothAudioSink code.

device/bluetooth/bluez/bluetooth_bluez_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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
@@ skipping 16 matching lines @@
 #include "device/bluetooth/dbus/fake_bluetooth_agent_manager_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_device_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_gatt_service_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_input_client.h"
 #include "device/bluetooth/test/test_bluetooth_adapter_observer.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::BluetoothDiscoveryFilter;
 using device::BluetoothDiscoverySession;
 using device::BluetoothUUID;
 using device::TestBluetoothAdapterObserver;
 
 namespace bluez {
 
 namespace {
 
@@ skipping 194 matching lines @@
 
   void AdapterCallback() { QuitMessageLoop(); }
 
   void DiscoverySessionCallback(
       std::unique_ptr<BluetoothDiscoverySession> discovery_session) {
     ++callback_count_;
     discovery_sessions_.push_back(discovery_session.release());
     QuitMessageLoop();
   }
 
-  void AudioSinkAcquiredCallback(scoped_refptr<BluetoothAudioSink>) {
-    ++callback_count_;
-    QuitMessageLoop();
-  }
-
   void ProfileRegisteredCallback(BluetoothAdapterProfileBlueZ* profile) {
     adapter_profile_ = profile;
     ++callback_count_;
     QuitMessageLoop();
   }
 
   void ErrorCallback() {
     ++error_callback_count_;
     QuitMessageLoop();
   }
@@ skipping 18 matching lines @@
     ++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 BluetoothAdapterBlueZ(base::Bind(
         &BluetoothBlueZTest::AdapterCallback, base::Unretained(this)));
     base::RunLoop().Run();
@@ skipping 3944 matching lines @@
   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(&BluetoothBlueZTest::AudioSinkAcquiredCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothBlueZTest::AudioSinkErrorCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(0, callback_count_);
-  EXPECT_EQ(1, error_callback_count_--) << "RegisterAudioSink error";
-
   BluetoothAdapterBlueZ* adapter_bluez =
       static_cast<BluetoothAdapterBlueZ*>(adapter_.get());
   EXPECT_EQ(nullptr, adapter_bluez->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
@@ skipping 36 matching lines @@
   // bluez::BluetoothAgentServiceProvider::Delegate omitted, dbus will be
   // shutdown,
   //   with the exception of Released.
   adapter_bluez->Released();
 
   adapter_bluez->OnRegisterAgent();
   adapter_bluez->OnRegisterAgentError("", "");
   adapter_bluez->OnRequestDefaultAgent();
   adapter_bluez->OnRequestDefaultAgentError("", "");
 
-  adapter_bluez->OnRegisterAudioSink(
-      base::Bind(&BluetoothBlueZTest::AudioSinkAcquiredCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothBlueZTest::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_bluez->NotifyAdapterPoweredChanged(false);
   adapter_bluez->DiscoverableChanged(false);
   adapter_bluez->DiscoveringChanged(false);
   adapter_bluez->PresentChanged(false);
 
   adapter_bluez->OnSetDiscoverable(GetCallback(), GetErrorCallback(), true);
@@ skipping 161 matching lines @@
   adapter_->Shutdown();
   adapter_bluez->OnStopDiscoveryError(GetDiscoveryErrorCallback(), "", "");
 
   // 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 bluez