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

components/cryptauth/ble/bluetooth_low_energy_weave_client_connection.h

 // 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.
 
-#ifndef COMPONENTS_PROXIMITY_AUTH_BLE_BLUETOOTH_LOW_ENERGY_WEAVE_CLIENT_CONNECTION_H_
-#define COMPONENTS_PROXIMITY_AUTH_BLE_BLUETOOTH_LOW_ENERGY_WEAVE_CLIENT_CONNECTION_H_
+#ifndef COMPONENTS_CRYPTAUTH_BLE_BLUETOOTH_LOW_ENERGY_WEAVE_CLIENT_CONNECTION_H_
+#define COMPONENTS_CRYPTAUTH_BLE_BLUETOOTH_LOW_ENERGY_WEAVE_CLIENT_CONNECTION_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <queue>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
-#include "components/proximity_auth/ble/bluetooth_low_energy_characteristics_finder.h"
-#include "components/proximity_auth/ble/bluetooth_low_energy_weave_packet_generator.h"
-#include "components/proximity_auth/ble/bluetooth_low_energy_weave_packet_receiver.h"
-#include "components/proximity_auth/ble/fake_wire_message.h"
-#include "components/proximity_auth/ble/remote_attribute.h"
+#include "components/cryptauth/ble/bluetooth_low_energy_characteristics_finder.h"
+#include "components/cryptauth/ble/bluetooth_low_energy_weave_packet_generator.h"
+#include "components/cryptauth/ble/bluetooth_low_energy_weave_packet_receiver.h"
+#include "components/cryptauth/ble/fake_wire_message.h"
+#include "components/cryptauth/ble/remote_attribute.h"
+#include "components/proximity_auth/bluetooth_throttler.h"
 #include "components/proximity_auth/connection.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_gatt_notify_session.h"
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 namespace base {
 class TaskRunner;
 }
 
-namespace proximity_auth {
-class BluetoothThrottler;
+namespace cryptauth {
 
 namespace weave {
 // Creates GATT connection on top of the BLE connection and act as a Client.
 // uWeave communication follows the flow:
 // Client                           | Server
 // ---------------------------------|--------------------------------
 // send connection request          |
 //                                  | receive connection request
 //                                  | send connection response
 // receive connection response      |
 // opt: send data                   | opt: send data
 // receive data                     | receive data
 // opt: close connection            | opt: close connection
 class BluetoothLowEnergyWeaveClientConnection
-    : public Connection,
+    : public proximity_auth::Connection,

[Kyle Horimoto, 2016/12/08 21:52:40]

//components/cryptauth should not depend on //components/proximity_auth. You'll
need to migrate Connection over.

[Ryan Hansberry, 2016/12/09 01:18:14]

Done.

       public device::BluetoothAdapter::Observer {
  public:
   class Factory {
    public:
     static std::unique_ptr<BluetoothLowEnergyWeaveClientConnection>
     NewInstance();
 
     // Exposed for testing.
     static void SetInstanceForTesting(Factory* factory);
 
    protected:
     // Exposed for testing.
     virtual std::unique_ptr<BluetoothLowEnergyWeaveClientConnection>
     BuildInstance();
 
    private:
     static Factory* factory_instance_;
   };
 
-  // The sub-state of a proximity_auth::BluetoothLowEnergyWeaveClientConnection
+  // The sub-state of a cryptauth::BluetoothLowEnergyWeaveClientConnection
   // extends the IN_PROGRESS state of proximity_auth::Connection::Status.
   enum SubStatus {
     DISCONNECTED,
     WAITING_GATT_CONNECTION,
     WAITING_CHARACTERISTICS,
     CHARACTERISTICS_FOUND,
     WAITING_NOTIFY_SESSION,
     NOTIFY_SESSION_READY,
     WAITING_CONNECTION_RESPONSE,
     CONNECTED,
   };
 
   // Constructs a Bluetooth low energy connection to the service with
   // |remote_service_| on the |remote_device|. The |adapter| must be already
   // initialized and ready. The GATT connection may alreaady be established and
   // pass through |gatt_connection|. A subsequent call to Connect() must be
   // made.
   BluetoothLowEnergyWeaveClientConnection(
       const cryptauth::RemoteDevice& remote_device,
       scoped_refptr<device::BluetoothAdapter> adapter,
       const device::BluetoothUUID remote_service_uuid,
-      BluetoothThrottler* bluetooth_throttler,
+      proximity_auth::BluetoothThrottler* bluetooth_throttler,
       int max_number_of_write_attempts);
 
   ~BluetoothLowEnergyWeaveClientConnection() override;
 
-  // proximity_auth::Connection:
+  // namespace cryptauth::Connection:
   void Connect() override;
   void Disconnect() override;
   std::string GetDeviceAddress() override;
 
  protected:
   // Exposed for testing.
   void DestroyConnection();
 
   // Exposed for testing.
   SubStatus sub_status() { return sub_status_; }
 
   // Sets |task_runner_| for testing.
   void SetTaskRunnerForTesting(scoped_refptr<base::TaskRunner> task_runner);
 
   // Virtual for testing.
   virtual BluetoothLowEnergyCharacteristicsFinder* CreateCharacteristicsFinder(
       const BluetoothLowEnergyCharacteristicsFinder::SuccessCallback&
           success_callback,
       const BluetoothLowEnergyCharacteristicsFinder::ErrorCallback&
           error_callback);
 
-  // proximity_auth::Connection:
-  void SendMessageImpl(std::unique_ptr<WireMessage> message) override;
+  // namespace cryptauth::Connection:
+  void SendMessageImpl(
+      std::unique_ptr<proximity_auth::WireMessage> message) override;
 
   // device::BluetoothAdapter::Observer:
   void DeviceChanged(device::BluetoothAdapter* adapter,
                      device::BluetoothDevice* device) override;
   void DeviceRemoved(device::BluetoothAdapter* adapter,
                      device::BluetoothDevice* device) override;
   void GattCharacteristicValueChanged(
       device::BluetoothAdapter* adapter,
       device::BluetoothRemoteGattCharacteristic* characteristic,
       const Packet& value) override;
 
  private:
   enum WriteRequestType {
     REGULAR,
     MESSAGE_COMPLETE,
     CONNECTION_REQUEST,
     CONNECTION_CLOSE
   };
 
   // Represents a request to write |value| to a some characteristic.
   // |is_last_write_for_wire_messsage| indicates whether this request
   // corresponds to the last write request for some wire message.
   struct WriteRequest {
     WriteRequest(const Packet& val,
                  WriteRequestType request_type,
-                 std::shared_ptr<WireMessage> message);
+                 std::shared_ptr<proximity_auth::WireMessage> message);
     WriteRequest(const Packet& val, WriteRequestType request_type);
     WriteRequest(const WriteRequest& other);
     ~WriteRequest();
 
     Packet value;
     WriteRequestType request_type;
-    std::shared_ptr<WireMessage> message;
+    std::shared_ptr<proximity_auth::WireMessage> message;
     int number_of_failed_attempts;
   };
 
   void SetSubStatus(SubStatus status);
 
   // Creates the GATT connection with |remote_device|.
   void CreateGattConnection();
 
   // Called when a GATT connection is created.
   void OnGattConnectionCreated(
@@ skipping 97 matching lines @@
   std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> packet_receiver_;
 
   // Characteristic used to send data to the remote device.
   RemoteAttribute tx_characteristic_;
 
   // Characteristic used to receive data from the remote device.
   RemoteAttribute rx_characteristic_;
 
   // Throttles repeated connection attempts to the same device. This is a
   // workaround for crbug.com/508919. Not owned, must outlive this instance.
-  BluetoothThrottler* bluetooth_throttler_;
+  proximity_auth::BluetoothThrottler* bluetooth_throttler_;
 
   scoped_refptr<base::TaskRunner> task_runner_;
 
   // The GATT connection with the remote device.
   std::unique_ptr<device::BluetoothGattConnection> gatt_connection_;
 
   // The characteristics finder for remote device.
   std::unique_ptr<BluetoothLowEnergyCharacteristicsFinder>
       characteristic_finder_;
 
@@ skipping 20 matching lines @@
   base::TimeTicks start_time_;
 
   base::WeakPtrFactory<BluetoothLowEnergyWeaveClientConnection>
       weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothLowEnergyWeaveClientConnection);
 };
 
 }  // namespace weave
 
-}  // namespace proximity_auth
+}  // namespace cryptauth
 
-#endif  // COMPONENTS_PROXIMITY_AUTH_BLE_BLUETOOTH_LOW_ENERGY_WEAVE_CLIENT_CONNECTION_H_
+#endif  // COMPONENTS_CRYPTAUTH_BLE_BLUETOOTH_LOW_ENERGY_WEAVE_CLIENT_CONNECTION_H_