Migrate weave-related classes from proximity_auth/ble to cryptauth/ble.

components/proximity_auth/ble/bluetooth_low_energy_connection_finder.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/proximity_auth/ble/bluetooth_low_energy_connection_finder.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "components/cryptauth/bluetooth_throttler.h"
+#include "components/cryptauth/connection.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_connection.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_device_whitelist.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_common.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
 using device::BluetoothGattConnection;
 using device::BluetoothDiscoveryFilter;
 
 namespace proximity_auth {
 namespace {
 const int kMinDiscoveryRSSI = -90;
 }  // namespace
 
-class BluetoothThrottler;
-
 BluetoothLowEnergyConnectionFinder::BluetoothLowEnergyConnectionFinder(
     const cryptauth::RemoteDevice remote_device,
     const std::string& remote_service_uuid,
     FinderStrategy finder_strategy,
     const BluetoothLowEnergyDeviceWhitelist* device_whitelist,
-    BluetoothThrottler* bluetooth_throttler,
+    cryptauth::BluetoothThrottler* bluetooth_throttler,
     int max_number_of_tries)
     : remote_device_(remote_device),
       remote_service_uuid_(device::BluetoothUUID(remote_service_uuid)),
       finder_strategy_(finder_strategy),
       device_whitelist_(device_whitelist),
       bluetooth_throttler_(bluetooth_throttler),
       max_number_of_tries_(max_number_of_tries),
       weak_ptr_factory_(this) {
   DCHECK(finder_strategy_ == FIND_ANY_DEVICE ||
          !remote_device.bluetooth_address.empty());
 }
 
 BluetoothLowEnergyConnectionFinder::~BluetoothLowEnergyConnectionFinder() {
   if (discovery_session_) {
     StopDiscoverySession();
   }
 
   if (connection_) {
     connection_->RemoveObserver(this);
     connection_.reset();
   }
 
   if (adapter_) {
     adapter_->RemoveObserver(this);
     adapter_ = NULL;
   }
 }
 
 void BluetoothLowEnergyConnectionFinder::Find(
-    const ConnectionCallback& connection_callback) {
+    const cryptauth::ConnectionFinder::ConnectionCallback&
+        connection_callback) {
   if (!device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
     PA_LOG(WARNING) << "Bluetooth is unsupported on this platform. Aborting.";
     return;
   }
   PA_LOG(INFO) << "Finding connection";
 
   connection_callback_ = connection_callback;
 
   device::BluetoothAdapterFactory::GetAdapter(
       base::Bind(&BluetoothLowEnergyConnectionFinder::OnAdapterInitialized,
@@ skipping 153 matching lines @@
           &BluetoothLowEnergyConnectionFinder::OnStartDiscoverySessionError,
           weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothLowEnergyConnectionFinder::StopDiscoverySession() {
   PA_LOG(INFO) << "Stopping discovery session";
   // Destroying the discovery session also stops it.
   discovery_session_.reset();
 }
 
-std::unique_ptr<Connection>
+std::unique_ptr<cryptauth::Connection>
 BluetoothLowEnergyConnectionFinder::CreateConnection(
     const std::string& device_address) {
   DCHECK(remote_device_.bluetooth_address.empty() ||
          remote_device_.bluetooth_address == device_address);
   remote_device_.bluetooth_address = device_address;
   return base::MakeUnique<BluetoothLowEnergyConnection>(
       remote_device_, adapter_, remote_service_uuid_, bluetooth_throttler_,
       max_number_of_tries_);
 }
 
 void BluetoothLowEnergyConnectionFinder::OnConnectionStatusChanged(
-    Connection* connection,
-    Connection::Status old_status,
-    Connection::Status new_status) {
+    cryptauth::Connection* connection,
+    cryptauth::Connection::Status old_status,
+    cryptauth::Connection::Status new_status) {
   DCHECK_EQ(connection, connection_.get());
   PA_LOG(INFO) << "OnConnectionStatusChanged: " << old_status << " -> "
                << new_status;
 
   if (!connection_callback_.is_null() && connection_->IsConnected()) {
     adapter_->RemoveObserver(this);
     connection_->RemoveObserver(this);
 
     // If we invoke the callback now, the callback function may install its own
     // observer to |connection_|. Because we are in the ConnectionObserver
     // callstack, this new observer will receive this connection event.
     // Therefore, we need to invoke the callback or restart discovery
     // asynchronously.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&BluetoothLowEnergyConnectionFinder::InvokeCallbackAsync,
                    weak_ptr_factory_.GetWeakPtr()));
-  } else if (old_status == Connection::IN_PROGRESS) {
+  } else if (old_status == cryptauth::Connection::IN_PROGRESS) {
     PA_LOG(WARNING) << "Connection failed. Retrying.";
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(
             &BluetoothLowEnergyConnectionFinder::RestartDiscoverySessionAsync,
             weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void BluetoothLowEnergyConnectionFinder::RestartDiscoverySessionAsync() {
@@ skipping 18 matching lines @@
       return device;
   }
   return nullptr;
 }
 
 void BluetoothLowEnergyConnectionFinder::InvokeCallbackAsync() {
   connection_callback_.Run(std::move(connection_));
 }
 
 }  // namespace proximity_auth