[Clean up] Expose ConnectToServiceInsecurely as a BluetoothDevice API on all platforms.

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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
-#include "components/proximity_auth/bluetooth_util.h"
 #include "components/proximity_auth/remote_device.h"
 #include "components/proximity_auth/wire_message.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;
 }
@@ skipping 68 matching lines @@
                                         device::BluetoothDevice* device) {
   DCHECK_EQ(adapter, adapter_.get());
   if (device->GetAddress() != remote_device().bluetooth_address)
     return;
 
   DCHECK_NE(status(), DISCONNECTED);
   VLOG(1) << "[BC] Device disconnected...";
   Disconnect();
 }
 
-void BluetoothConnection::ConnectToService(
-    device::BluetoothDevice* device,
-    const device::BluetoothUUID& uuid,
-    const device::BluetoothDevice::ConnectToServiceCallback& callback,
-    const device::BluetoothDevice::ConnectToServiceErrorCallback&
-        error_callback) {
-  bluetooth_util::ConnectToServiceInsecurely(
-      device, uuid, callback, error_callback);
-}
-
 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) {
     VLOG(1) << "[BC] Device with address " << address
             << " is not known to the system Bluetooth daemon.";
     // TOOD(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();
-  ConnectToService(
-      bluetooth_device,
+  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.
@@ skipping 49 matching lines @@
 
   // 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::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothConnection::StartReceive,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 }  // namespace proximity_auth