[CrOS Tether]: Create BleConnectionManager, which manages secure connections between the current de…

components/cryptauth/ble/bluetooth_low_energy_weave_client_connection.cc

 // Copyright 2016 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/cryptauth/ble/bluetooth_low_energy_weave_client_connection.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 25 matching lines @@
 const int kMaxNumberOfRetryAttempts = 2;
 
 }  // namespace
 
 // static
 std::shared_ptr<BluetoothLowEnergyWeaveClientConnection::Factory>
     BluetoothLowEnergyWeaveClientConnection::Factory::factory_instance_ =
         nullptr;
 
 // static
-std::unique_ptr<BluetoothLowEnergyWeaveClientConnection>
+std::unique_ptr<Connection>

[Ryan Hansberry, 2017/02/14 18:27:28]

Why did you change this? It doesn't really make sense to return Connection from
BluetoothLowEnergyWeaveClientConnection's Factory. 

[Kyle Horimoto, 2017/02/14 22:54:46]

We need the factory to return |FakeConnection|s in tests. I don't think there's
necessarily a problem with return a |Connection| here, though I agree it looks a
little weird. In practice, the only place this is used is in
BleConnectionManager, where the connection is simply passed to the
SecureChannel, which does not care about what type of Connection is used. I'm
inclined to leave this as-is, unless you have a better idea.

[Ryan Hansberry, 2017/02/16 19:29:35]

Oh man, lame. If Connection had a factory that this factory could extend, maybe
you could inject a Factory into BleConnectionManager, but that's outside the
scope of this CL and isn't even worth it. Please just write a comment explaining
why this returns Connection. 

 BluetoothLowEnergyWeaveClientConnection::Factory::NewInstance(
     const RemoteDevice& remote_device,
     const std::string& device_address,
     scoped_refptr<device::BluetoothAdapter> adapter,
     const device::BluetoothUUID remote_service_uuid,
     BluetoothThrottler* bluetooth_throttler) {
   if (!factory_instance_) {
     factory_instance_.reset(new Factory());
   }
   return factory_instance_->BuildInstance(
       remote_device,
       device_address,
       adapter,
       remote_service_uuid,
       bluetooth_throttler);
 }
 
 // static
 void BluetoothLowEnergyWeaveClientConnection::Factory::SetInstanceForTesting(
     std::shared_ptr<Factory> factory) {
   factory_instance_ = factory;
 }
 
-std::unique_ptr<BluetoothLowEnergyWeaveClientConnection>
+std::unique_ptr<Connection>
 BluetoothLowEnergyWeaveClientConnection::Factory::BuildInstance(
     const RemoteDevice& remote_device,
     const std::string& device_address,
     scoped_refptr<device::BluetoothAdapter> adapter,
     const device::BluetoothUUID remote_service_uuid,
     BluetoothThrottler* bluetooth_throttler) {
   return base::MakeUnique<BluetoothLowEnergyWeaveClientConnection>(
       remote_device, device_address, adapter, remote_service_uuid,
       bluetooth_throttler);
 }
@@ skipping 585 matching lines @@
       number_of_failed_attempts(0) {}
 
 BluetoothLowEnergyWeaveClientConnection::WriteRequest::WriteRequest(
     const WriteRequest& other) = default;
 
 BluetoothLowEnergyWeaveClientConnection::WriteRequest::~WriteRequest() {}
 
 }  // namespace weave
 
 }  // namespace cryptauth