components/proximity_auth: Remove unused BluetoothConnection*.

These classes represented Bluetooth Classic connections, which are no longer used.

R=khorimoto@chromium.org

Bug: none
Test: none
Change-Id: I8223f3afca936cf3711f4a73334e9d8aed80d9e1
Reviewed-on: https://chromium-review.googlesource.com/964624
Commit-Queue: James Hawkins <jhawkins@chromium.org>
Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#543530}

components/proximity_auth/BUILD.gn

@@ -8,10 +8,6 @@ assert(is_chromeos, "ProximityAuth is Chrome OS only")
 
 static_library("proximity_auth") {
   sources = [
-    "bluetooth_connection.cc",
-    "bluetooth_connection.h",
-    "bluetooth_connection_finder.cc",
-    "bluetooth_connection_finder.h",
     "bluetooth_low_energy_connection_finder.cc",
     "bluetooth_low_energy_connection_finder.h",
     "bluetooth_low_energy_setup_connection_finder.cc",
@@ -99,8 +95,6 @@ static_library("test_support") {
 source_set("unit_tests") {
   testonly = true
   sources = [
-    "bluetooth_connection_finder_unittest.cc",
-    "bluetooth_connection_unittest.cc",
     "bluetooth_low_energy_connection_finder_unittest.cc",
     "messenger_impl_unittest.cc",
     "promotion_manager_unittests.cc",

components/proximity_auth/bluetooth_connection.cc

-// Copyright 2014 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 "components/proximity_auth/bluetooth_connection.h"
-
-#include <utility>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/location.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/single_thread_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "components/cryptauth/remote_device.h"
-#include "components/cryptauth/wire_message.h"
-#include "components/proximity_auth/logging/logging.h"
-#include "device/bluetooth/bluetooth_adapter_factory.h"
-#include "device/bluetooth/bluetooth_device.h"
-#include "net/base/io_buffer.h"
-
-namespace proximity_auth {
-namespace {
-const int kReceiveBufferSizeBytes = 1024;
-}
-
-BluetoothConnection::BluetoothConnection(
-    const cryptauth::RemoteDevice& remote_device,
-    const device::BluetoothUUID& uuid)
-    : cryptauth::Connection(remote_device),
-      uuid_(uuid),
-      weak_ptr_factory_(this) {}
-
-BluetoothConnection::~BluetoothConnection() {
-  if (status() != DISCONNECTED)
-    Disconnect();
-}
-
-void BluetoothConnection::Connect() {
-  if (status() != DISCONNECTED) {
-    PA_LOG(WARNING)
-        << "Ignoring attempt to connect a non-disconnected connection.";
-    return;
-  }
-
-  if (!device::BluetoothAdapterFactory::IsBluetoothSupported()) {
-    PA_LOG(WARNING)
-        << "Connection failed: Bluetooth is unsupported on this platform.";
-    return;
-  }
-
-  SetStatus(IN_PROGRESS);
-  device::BluetoothAdapterFactory::GetAdapter(
-      base::Bind(&BluetoothConnection::OnAdapterInitialized,
-                 weak_ptr_factory_.GetWeakPtr()));
-}
-
-void BluetoothConnection::Disconnect() {
-  if (status() == DISCONNECTED) {
-    PA_LOG(WARNING)
-        << "Ignoring attempt to disconnect a non-connected connection.";
-    return;
-  }
-
-  // Set status as disconnected now, rather than after the socket closes, so
-  // this connection is not reused.
-  SetStatus(DISCONNECTED);
-  if (socket_.get()) {
-    socket_->Disconnect(base::DoNothing());
-    socket_ = nullptr;
-  }
-  if (adapter_.get()) {
-    adapter_->RemoveObserver(this);
-    adapter_ = nullptr;
-  }
-}
-
-void BluetoothConnection::SendMessageImpl(
-    std::unique_ptr<cryptauth::WireMessage> message) {
-  DCHECK_EQ(status(), CONNECTED);
-
-  // Serialize the message.
-  std::string serialized_message = message->Serialize();
-  int message_length = base::checked_cast<int>(serialized_message.size());
-  scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(message_length);
-  memcpy(buffer->data(), serialized_message.c_str(), message_length);
-
-  // Send it.
-  pending_message_ = std::move(message);
-  base::WeakPtr<BluetoothConnection> weak_this = weak_ptr_factory_.GetWeakPtr();
-  socket_->Send(buffer,
-                message_length,
-                base::Bind(&BluetoothConnection::OnSend, weak_this),
-                base::Bind(&BluetoothConnection::OnSendError, weak_this));
-}
-
-void BluetoothConnection::DeviceChanged(device::BluetoothAdapter* adapter,
-                                        device::BluetoothDevice* device) {
-  DCHECK_EQ(adapter, adapter_.get());
-  if (device->GetAddress() == remote_device().bluetooth_address &&
-      status() != DISCONNECTED && !device->IsConnected()) {
-    PA_LOG(INFO) << "Device disconnected...";
-    Disconnect();
-  }
-}
-
-void BluetoothConnection::DeviceRemoved(device::BluetoothAdapter* adapter,
-                                        device::BluetoothDevice* device) {
-  DCHECK_EQ(adapter, adapter_.get());
-  if (device->GetAddress() != remote_device().bluetooth_address)
-    return;
-
-  DCHECK_NE(status(), DISCONNECTED);
-  PA_LOG(INFO) << "Device disconnected...";
-  if (status() != DISCONNECTED)
-    Disconnect();
-}
-
-void BluetoothConnection::StartReceive() {
-  base::WeakPtr<BluetoothConnection> weak_this = weak_ptr_factory_.GetWeakPtr();
-  socket_->Receive(kReceiveBufferSizeBytes,
-                   base::Bind(&BluetoothConnection::OnReceive, weak_this),
-                   base::Bind(&BluetoothConnection::OnReceiveError, weak_this));
-}
-
-void BluetoothConnection::OnAdapterInitialized(
-    scoped_refptr<device::BluetoothAdapter> adapter) {
-  const std::string address = remote_device().bluetooth_address;
-  device::BluetoothDevice* bluetooth_device = adapter->GetDevice(address);
-  if (!bluetooth_device) {
-    PA_LOG(WARNING) << "Device with address " << address
-                    << " is not known to the system Bluetooth daemon.";
-    // TODO(isherman): Optimistically attempt to seek the device and connect
-    // anyway, as was previously implemented in BluetoothConnectionFinder.
-    Disconnect();
-    return;
-  }
-
-  adapter_ = adapter;
-  adapter_->AddObserver(this);
-
-  base::WeakPtr<BluetoothConnection> weak_this = weak_ptr_factory_.GetWeakPtr();
-  bluetooth_device->ConnectToServiceInsecurely(
-      uuid_,
-      base::Bind(&BluetoothConnection::OnConnected, weak_this),
-      base::Bind(&BluetoothConnection::OnConnectionError, weak_this));
-}
-
-void BluetoothConnection::OnConnected(
-    scoped_refptr<device::BluetoothSocket> socket) {
-  if (status() != IN_PROGRESS) {
-    // This case is reachable if the client of |this| connection called
-    // |Disconnect()| while the backing Bluetooth connection was pending.
-    DCHECK_EQ(status(), DISCONNECTED);
-    PA_LOG(WARNING) << "Ignoring successful backend Bluetooth connection to an "
-                    << "already disconnected logical connection.";
-    return;
-  }
-
-  PA_LOG(INFO) << "Connection established with "
-               << remote_device().bluetooth_address;
-  socket_ = socket;
-  SetStatus(CONNECTED);
-  StartReceive();
-}
-
-void BluetoothConnection::OnConnectionError(const std::string& error_message) {
-  PA_LOG(WARNING) << "Connection failed: " << error_message;
-  Disconnect();
-}
-
-void BluetoothConnection::OnSend(int bytes_sent) {
-  PA_LOG(INFO) << "Successfully sent " << bytes_sent << " bytes.";
-  OnDidSendMessage(*pending_message_, true);
-  pending_message_.reset();
-}
-
-void BluetoothConnection::OnSendError(const std::string& error_message) {
-  PA_LOG(WARNING) << "Error when sending bytes: " << error_message;
-  OnDidSendMessage(*pending_message_, false);
-  pending_message_.reset();
-
-  Disconnect();
-}
-
-void BluetoothConnection::OnReceive(int bytes_received,
-                                    scoped_refptr<net::IOBuffer> buffer) {
-  PA_LOG(INFO) << "Received " << bytes_received << " bytes.";
-  OnBytesReceived(std::string(buffer->data(), bytes_received));
-
-  // Post a task to delay the read until the socket is available, as
-  // calling StartReceive at this point would error with ERR_IO_PENDING.
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&BluetoothConnection::StartReceive,
-                            weak_ptr_factory_.GetWeakPtr()));
-}
-
-void BluetoothConnection::OnReceiveError(
-    device::BluetoothSocket::ErrorReason error_reason,
-    const std::string& error_message) {
-  PA_LOG(WARNING) << "Error receiving bytes: " << error_message;
-
-  // Post a task to delay the read until the socket is available, as
-  // calling StartReceive at this point would error with ERR_IO_PENDING.
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&BluetoothConnection::StartReceive,
-                            weak_ptr_factory_.GetWeakPtr()));
-}
-
-}  // namespace proximity_auth

components/proximity_auth/bluetooth_connection.h

-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_PROXIMITY_AUTH_BLUETOOTH_CONNECTION_H
-#define COMPONENTS_PROXIMITY_AUTH_BLUETOOTH_CONNECTION_H
-
-#include <string>
-
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
-#include "components/cryptauth/connection.h"
-#include "device/bluetooth/bluetooth_adapter.h"
-#include "device/bluetooth/bluetooth_device.h"
-#include "device/bluetooth/bluetooth_socket.h"
-#include "device/bluetooth/bluetooth_uuid.h"
-
-namespace net {
-class IOBuffer;
-}
-
-namespace cryptauth {
-struct RemoteDevice;
-}
-
-namespace proximity_auth {
-
-// Represents a Bluetooth connection with a remote device. The connection is a
-// persistent bidirectional channel for sending and receiving wire messages.
-class BluetoothConnection : public cryptauth::Connection,
-                            public device::BluetoothAdapter::Observer {
- public:
-  // Constructs a Bluetooth connection to the service with |uuid| on the
-  // |remote_device|. The |remote_device| must already be known to the system
-  // Bluetooth daemon.
-  BluetoothConnection(const cryptauth::RemoteDevice& remote_device,
-                      const device::BluetoothUUID& uuid);
-  ~BluetoothConnection() override;
-
-  // Connection:
-  void Connect() override;
-  void Disconnect() override;
-
- protected:
-  // Connection:
-  void SendMessageImpl(
-      std::unique_ptr<cryptauth::WireMessage> message) override;
-
-  // BluetoothAdapter::Observer:
-  void DeviceChanged(device::BluetoothAdapter* adapter,
-                     device::BluetoothDevice* device) override;
-  void DeviceRemoved(device::BluetoothAdapter* adapter,
-                     device::BluetoothDevice* device) override;
-
- private:
-  // Registers receive callbacks with the backing |socket_|.
-  void StartReceive();
-
-  // Callbacks for asynchronous Bluetooth operations.
-  void OnAdapterInitialized(scoped_refptr<device::BluetoothAdapter> adapter);
-  void OnConnected(scoped_refptr<device::BluetoothSocket> socket);
-  void OnConnectionError(const std::string& error_message);
-  void OnSend(int bytes_sent);
-  void OnSendError(const std::string& error_message);
-  void OnReceive(int bytes_received, scoped_refptr<net::IOBuffer> buffer);
-  void OnReceiveError(device::BluetoothSocket::ErrorReason error_reason,
-                      const std::string& error_message);
-
-  // The UUID (universally unique identifier) of the Bluetooth service on the
-  // remote device that |this| connection should connect to.
-  const device::BluetoothUUID uuid_;
-
-  // The Bluetooth adapter over which this connection is made. Non-null iff
-  // |this| connection is registered as an observer of the |adapter_|.
-  scoped_refptr<device::BluetoothAdapter> adapter_;
-
-  // The Bluetooth socket that backs this connection. NULL iff the connection is
-  // not in a connected state.
-  scoped_refptr<device::BluetoothSocket> socket_;
-
-  // The message that was sent over the backing |socket_|. NULL iff there is no
-  // send operation in progress.
-  std::unique_ptr<cryptauth::WireMessage> pending_message_;
-
-  base::WeakPtrFactory<BluetoothConnection> weak_ptr_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(BluetoothConnection);
-};
-
-}  // namespace proximity_auth
-
-#endif  // COMPONENTS_PROXIMITY_AUTH_BLUETOOTH_CONNECTION_H

components/proximity_auth/bluetooth_connection_finder.cc

-// Copyright 2014 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 "components/proximity_auth/bluetooth_connection_finder.h"
-
-#include <utility>
-
-#include "base/bind.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/single_thread_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "components/cryptauth/connection.h"
-#include "components/proximity_auth/bluetooth_connection.h"
-#include "components/proximity_auth/logging/logging.h"
-#include "device/bluetooth/bluetooth_adapter_factory.h"
-
-using device::BluetoothAdapter;
-
-namespace proximity_auth {
-
-BluetoothConnectionFinder::BluetoothConnectionFinder(
-    const cryptauth::RemoteDevice& remote_device,
-    const device::BluetoothUUID& uuid,
-    const base::TimeDelta& polling_interval)
-    : remote_device_(remote_device),
-      uuid_(uuid),
-      polling_interval_(polling_interval),
-      has_delayed_poll_scheduled_(false),
-      weak_ptr_factory_(this) {}
-
-BluetoothConnectionFinder::~BluetoothConnectionFinder() {
-  UnregisterAsObserver();
-}
-
-void BluetoothConnectionFinder::Find(
-    const cryptauth::ConnectionFinder::ConnectionCallback&
-        connection_callback) {
-  if (!device::BluetoothAdapterFactory::IsBluetoothSupported()) {
-    PA_LOG(WARNING) << "Bluetooth is unsupported on this platform. Aborting.";
-    return;
-  }
-
-  DCHECK(start_time_.is_null());
-
-  start_time_ = base::TimeTicks::Now();
-  connection_callback_ = connection_callback;
-
-  device::BluetoothAdapterFactory::GetAdapter(
-      base::Bind(&BluetoothConnectionFinder::OnAdapterInitialized,
-                 weak_ptr_factory_.GetWeakPtr()));
-}
-
-std::unique_ptr<cryptauth::Connection>
-BluetoothConnectionFinder::CreateConnection() {
-  return std::unique_ptr<cryptauth::Connection>(
-      new BluetoothConnection(remote_device_, uuid_));
-}
-
-void BluetoothConnectionFinder::SeekDeviceByAddress(
-    const std::string& bluetooth_address,
-    const base::Closure& callback,
-    const bluetooth_util::ErrorCallback& error_callback) {
-  bluetooth_util::SeekDeviceByAddress(
-      bluetooth_address, callback, error_callback,
-      base::ThreadTaskRunnerHandle::Get().get());
-}
-
-bool BluetoothConnectionFinder::IsReadyToPoll() {
-  bool is_adapter_available =
-      adapter_.get() && adapter_->IsPresent() && adapter_->IsPowered();
-  PA_LOG(INFO) << "Readiness: adapter="
-               << (is_adapter_available ? "available" : "unavailable");
-  return is_adapter_available;
-}
-
-void BluetoothConnectionFinder::PollIfReady() {
-  if (!IsReadyToPoll())
-    return;
-
-  // If there is a pending task to poll at a later time, the time requisite
-  // timeout has not yet elapsed since the previous polling attempt. In that
-  // case, keep waiting until the delayed task comes in.
-  if (has_delayed_poll_scheduled_)
-    return;
-
-  // If the |connection_| is pending, wait for it to connect or fail prior to
-  // polling again.
-  if (connection_ &&
-      connection_->status() != cryptauth::Connection::DISCONNECTED)
-    return;
-
-  // This SeekDeviceByAddress operation is needed to connect to a device if
-  // it is not already known to the adapter.
-  if (!adapter_->GetDevice(remote_device_.bluetooth_address)) {
-    PA_LOG(INFO) << "Remote device [" << remote_device_.bluetooth_address
-                 << "] is not known. "
-                 << "Seeking device directly by address...";
-
-    SeekDeviceByAddress(
-        remote_device_.bluetooth_address,
-        base::Bind(&BluetoothConnectionFinder::OnSeekedDeviceByAddress,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&BluetoothConnectionFinder::OnSeekedDeviceByAddressError,
-                   weak_ptr_factory_.GetWeakPtr()));
-  } else {
-    PA_LOG(INFO) << "Remote device known, connecting...";
-    connection_ = CreateConnection();
-    connection_->AddObserver(this);
-    connection_->Connect();
-  }
-}
-
-void BluetoothConnectionFinder::PostDelayedPoll() {
-  if (has_delayed_poll_scheduled_) {
-    PA_LOG(WARNING) << "Delayed poll already scheduled, skipping.";
-    return;
-  }
-
-  PA_LOG(INFO) << "Posting delayed poll..";
-  has_delayed_poll_scheduled_ = true;
-  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, base::Bind(&BluetoothConnectionFinder::OnDelayedPoll,
-                            weak_ptr_factory_.GetWeakPtr()),
-      polling_interval_);
-}
-
-void BluetoothConnectionFinder::OnDelayedPoll() {
-  // Note that there is no longer a pending task, and therefore polling is
-  // permitted.
-  has_delayed_poll_scheduled_ = false;
-  PollIfReady();
-}
-
-void BluetoothConnectionFinder::OnSeekedDeviceByAddress() {
-  // Sanity check that the remote device is now known by the adapter.
-  if (adapter_->GetDevice(remote_device_.bluetooth_address))
-    PollIfReady();
-  else
-    PostDelayedPoll();
-}
-
-void BluetoothConnectionFinder::OnSeekedDeviceByAddressError(
-    const std::string& error_message) {
-  PA_LOG(ERROR) << "Failed to seek device: " << error_message;
-  PostDelayedPoll();
-}
-
-void BluetoothConnectionFinder::UnregisterAsObserver() {
-  if (connection_) {
-    connection_->RemoveObserver(this);
-    // The connection is about to be released or destroyed, so no need to clear
-    // it explicitly here.
-  }
-
-  if (adapter_.get()) {
-    adapter_->RemoveObserver(this);
-    adapter_ = nullptr;
-  }
-}
-
-void BluetoothConnectionFinder::OnAdapterInitialized(
-    scoped_refptr<BluetoothAdapter> adapter) {
-  adapter_ = adapter;
-  adapter_->AddObserver(this);
-  PollIfReady();
-}
-
-void BluetoothConnectionFinder::AdapterPresentChanged(BluetoothAdapter* adapter,
-                                                      bool present) {
-  PollIfReady();
-}
-
-void BluetoothConnectionFinder::AdapterPoweredChanged(BluetoothAdapter* adapter,
-                                                      bool powered) {
-  PollIfReady();
-}
-
-void BluetoothConnectionFinder::OnConnectionStatusChanged(
-    cryptauth::Connection* connection,
-    cryptauth::Connection::Status old_status,
-    cryptauth::Connection::Status new_status) {
-  DCHECK_EQ(connection, connection_.get());
-
-  if (connection_->IsConnected()) {
-    base::TimeDelta elapsed = base::TimeTicks::Now() - start_time_;
-    PA_LOG(WARNING) << "Connection found! Elapsed Time: "
-                    << elapsed.InMilliseconds() << "ms.";
-    UnregisterAsObserver();
-
-    // If we invoke the callback now, the callback function may install its own
-    // observer to |connection_|. Because we are in the
-    // cryptauth::ConnectionObserver
-    // callstack, this new observer will receive this connection event.
-    // Therefore, we need to invoke the callback asynchronously.
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&BluetoothConnectionFinder::InvokeCallbackAsync,
-                              weak_ptr_factory_.GetWeakPtr()));
-  } else if (old_status == cryptauth::Connection::IN_PROGRESS) {
-    PA_LOG(WARNING)
-        << "Connection failed! Scheduling another polling iteration.";
-    PostDelayedPoll();
-  }
-}
-
-void BluetoothConnectionFinder::InvokeCallbackAsync() {
-  connection_callback_.Run(std::move(connection_));
-}
-
-}  // namespace proximity_auth

components/proximity_auth/bluetooth_connection_finder.h

-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_PROXIMITY_AUTH_BLUETOOTH_CONNECTION_FINDER_H
-#define COMPONENTS_PROXIMITY_AUTH_BLUETOOTH_CONNECTION_FINDER_H
-
-#include <memory>
-
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
-#include "base/time/time.h"
-#include "components/cryptauth/connection.h"
-#include "components/cryptauth/connection_finder.h"
-#include "components/cryptauth/connection_observer.h"
-#include "components/cryptauth/remote_device.h"
-#include "components/proximity_auth/bluetooth_util.h"
-#include "device/bluetooth/bluetooth_adapter.h"
-#include "device/bluetooth/bluetooth_uuid.h"
-
-namespace proximity_auth {
-
-// This cryptauth::ConnectionFinder implementation tries to find a Bluetooth
-// connection to
-// the remote device by polling at a fixed interval.
-class BluetoothConnectionFinder : public cryptauth::ConnectionFinder,
-                                  public cryptauth::ConnectionObserver,
-                                  public device::BluetoothAdapter::Observer {
- public:
-  BluetoothConnectionFinder(const cryptauth::RemoteDevice& remote_device,
-                            const device::BluetoothUUID& uuid,
-                            const base::TimeDelta& polling_interval);
-  ~BluetoothConnectionFinder() override;
-
-  // cryptauth::ConnectionFinder:
-  void Find(const cryptauth::ConnectionFinder::ConnectionCallback&
-                connection_callback) override;
-
- protected:
-  // Exposed for mocking out the connection in tests.
-  virtual std::unique_ptr<cryptauth::Connection> CreateConnection();
-
-  // Calls bluetooth_util::SeekDeviceByAddress. Exposed for testing, as this
-  // utility function is platform dependent.
-  virtual void SeekDeviceByAddress(
-      const std::string& bluetooth_address,
-      const base::Closure& callback,
-      const bluetooth_util::ErrorCallback& error_callback);
-
-  // BluetoothAdapter::Observer:
-  void AdapterPresentChanged(device::BluetoothAdapter* adapter,
-                             bool present) override;
-  void AdapterPoweredChanged(device::BluetoothAdapter* adapter,
-                             bool powered) override;
-
- private:
-  // Returns true iff the Bluetooth adapter is ready to make connections.
-  bool IsReadyToPoll();
-
-  // Attempts to connect to the |remote_device_| if the system is ready for
-  // another iteration of polling.
-  void PollIfReady();
-
-  // Posts a delayed task to call |PollIfReady|. |OnDelayedPoll()| will be
-  // called when the task fires.
-  void PostDelayedPoll();
-  void OnDelayedPoll();
-
-  // Callbacks for bluetooth_util::SeekDeviceByAddress().
-  void OnSeekedDeviceByAddress();
-  void OnSeekedDeviceByAddressError(const std::string& error_message);
-
-  // Unregisters |this| instance as an observer from all objects that it might
-  // have registered with.
-  void UnregisterAsObserver();
-
-  // Callback to be called when the Bluetooth adapter is initialized.
-  void OnAdapterInitialized(scoped_refptr<device::BluetoothAdapter> adapter);
-
-  // ConnectionObserver:
-  void OnConnectionStatusChanged(
-      cryptauth::Connection* connection,
-      cryptauth::Connection::Status old_status,
-      cryptauth::Connection::Status new_status) override;
-
-  // Used to invoke |connection_callback_| asynchronously, decoupling the
-  // callback invocation from the ConnectionObserver callstack.
-  void InvokeCallbackAsync();
-
-  // The remote device to connect to.
-  const cryptauth::RemoteDevice remote_device_;
-
-  // The UUID of the service on the remote device.
-  const device::BluetoothUUID uuid_;
-
-  // The time to wait between polling attempts.
-  const base::TimeDelta polling_interval_;
-
-  // Records the time at which the finder began searching for connections.
-  base::TimeTicks start_time_;
-
-  // The callback that should be called upon a successful connection.
-  cryptauth::ConnectionFinder::ConnectionCallback connection_callback_;
-
-  // The Bluetooth adapter over which the Bluetooth connection will be made.
-  scoped_refptr<device::BluetoothAdapter> adapter_;
-
-  // The Bluetooth connection that will be opened.
-  std::unique_ptr<cryptauth::Connection> connection_;
-
-  // Whether there is currently a polling task scheduled.
-  bool has_delayed_poll_scheduled_;
-
-  // Used to schedule everything else.
-  base::WeakPtrFactory<BluetoothConnectionFinder> weak_ptr_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(BluetoothConnectionFinder);
-};
-
-// TODO(isherman): Make sure to wire up the controller to listen for screen lock
-// state change events, and create or destroy the connection finder as
-// appropriate.
-
-}  // namespace proximity_auth
-
-#endif  // COMPONENTS_PROXIMITY_AUTH_BLUETOOTH_CONNECTION_FINDER_H

components/proximity_auth/remote_device_life_cycle_impl.cc

@@ -16,8 +16,6 @@
 #include "components/cryptauth/device_to_device_authenticator.h"
 #include "components/cryptauth/secure_context.h"
 #include "components/cryptauth/secure_message_delegate.h"
-#include "components/proximity_auth/bluetooth_connection.h"
-#include "components/proximity_auth/bluetooth_connection_finder.h"
 #include "components/proximity_auth/bluetooth_low_energy_connection_finder.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/messenger_impl.h"

components/proximity_auth/webui/proximity_auth_webui_handler.cc

@@ -22,7 +22,6 @@
 #include "components/cryptauth/secure_context.h"
 #include "components/cryptauth/secure_message_delegate.h"
 #include "components/prefs/pref_service.h"
-#include "components/proximity_auth/bluetooth_connection_finder.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/messenger.h"
 #include "components/proximity_auth/remote_device_life_cycle_impl.h"