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

components/proximity_auth/ble/bluetooth_low_energy_connection.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.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
-#include "components/proximity_auth/ble/bluetooth_low_energy_characteristics_finder.h"
-#include "components/proximity_auth/ble/fake_wire_message.h"
-#include "components/proximity_auth/bluetooth_throttler.h"
+#include "components/cryptauth/ble/bluetooth_low_energy_characteristics_finder.h"
+#include "components/cryptauth/ble/fake_wire_message.h"
+#include "components/cryptauth/bluetooth_throttler.h"
+#include "components/cryptauth/connection.h"
+#include "components/cryptauth/wire_message.h"
 #include "components/proximity_auth/connection_finder.h"
 #include "components/proximity_auth/logging/logging.h"
-#include "components/proximity_auth/wire_message.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_gatt_connection.h"
 #include "device/bluetooth/bluetooth_gatt_notify_session.h"
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
 using device::BluetoothGattConnection;
@@ skipping 17 matching lines @@
 // The maximum number of bytes written in a remote characteristic with a single
 // write request. This is not the connection MTU, we are assuming that the
 // remote device allows for writes larger than MTU.
 const int kMaxChunkSize = 500;
 }  // namespace
 
 BluetoothLowEnergyConnection::BluetoothLowEnergyConnection(
     const cryptauth::RemoteDevice& device,
     scoped_refptr<device::BluetoothAdapter> adapter,
     const BluetoothUUID remote_service_uuid,
-    BluetoothThrottler* bluetooth_throttler,
+    cryptauth::BluetoothThrottler* bluetooth_throttler,
     int max_number_of_write_attempts)
-    : Connection(device),
+    : cryptauth::Connection(device),
       adapter_(adapter),
       remote_service_({remote_service_uuid, ""}),
       to_peripheral_char_({BluetoothUUID(kToPeripheralCharUUID), ""}),
       from_peripheral_char_({BluetoothUUID(kFromPeripheralCharUUID), ""}),
       bluetooth_throttler_(bluetooth_throttler),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       sub_status_(SubStatus::DISCONNECTED),
       receiving_bytes_(false),
       write_remote_characteristic_pending_(false),
       max_number_of_write_attempts_(max_number_of_write_attempts),
@@ skipping 70 matching lines @@
     // Only transition to the DISCONNECTED state after perfoming all necessary
     // operations. Otherwise, it'll trigger observers that can pontentially
     // destroy the current instance (causing a crash).
     SetSubStatus(SubStatus::DISCONNECTED);
   }
 }
 
 void BluetoothLowEnergyConnection::SetSubStatus(SubStatus new_sub_status) {
   sub_status_ = new_sub_status;
 
-  // Sets the status of parent class proximity_auth::Connection accordingly.
+  // Sets the status of parent class cryptauth::Connection accordingly.
   if (new_sub_status == SubStatus::CONNECTED) {
     SetStatus(CONNECTED);
   } else if (new_sub_status == SubStatus::DISCONNECTED) {
     SetStatus(DISCONNECTED);
   } else {
     SetStatus(IN_PROGRESS);
   }
 }
 
 void BluetoothLowEnergyConnection::SetTaskRunnerForTesting(
     scoped_refptr<base::TaskRunner> task_runner) {
   task_runner_ = task_runner;
 }
 
 void BluetoothLowEnergyConnection::SendMessageImpl(
-    std::unique_ptr<WireMessage> message) {
+    std::unique_ptr<cryptauth::WireMessage> message) {
   PA_LOG(INFO) << "Sending message " << message->Serialize();
   std::string serialized_msg = message->Serialize();
 
   // [First write]: Build a header with the [send signal] + [size of the
   // message].
   WriteRequest write_request = BuildWriteRequest(
       ToByteVector(static_cast<uint32_t>(ControlSignal::kSendSignal)),
       ToByteVector(static_cast<uint32_t>(serialized_msg.size())), false);
 
   // [First write]: Fill the it with a prefix of |serialized_msg| up to
@@ skipping 171 matching lines @@
 
   gatt_connection_ = std::move(gatt_connection);
   SetSubStatus(SubStatus::WAITING_CHARACTERISTICS);
   characteristic_finder_.reset(CreateCharacteristicsFinder(
       base::Bind(&BluetoothLowEnergyConnection::OnCharacteristicsFound,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&BluetoothLowEnergyConnection::OnCharacteristicsFinderError,
                  weak_ptr_factory_.GetWeakPtr())));
 }
 
-BluetoothLowEnergyCharacteristicsFinder*
+cryptauth::BluetoothLowEnergyCharacteristicsFinder*
 BluetoothLowEnergyConnection::CreateCharacteristicsFinder(
-    const BluetoothLowEnergyCharacteristicsFinder::SuccessCallback&
+    const cryptauth::BluetoothLowEnergyCharacteristicsFinder::SuccessCallback&
         success_callback,
-    const BluetoothLowEnergyCharacteristicsFinder::ErrorCallback&
+    const cryptauth::BluetoothLowEnergyCharacteristicsFinder::ErrorCallback&
         error_callback) {
-  return new BluetoothLowEnergyCharacteristicsFinder(
+  return new cryptauth::BluetoothLowEnergyCharacteristicsFinder(
       adapter_, GetRemoteDevice(), remote_service_, to_peripheral_char_,
       from_peripheral_char_, success_callback, error_callback);
 }
 
 void BluetoothLowEnergyConnection::OnCharacteristicsFound(
-    const RemoteAttribute& service,
-    const RemoteAttribute& to_peripheral_char,
-    const RemoteAttribute& from_peripheral_char) {
+    const cryptauth::RemoteAttribute& service,
+    const cryptauth::RemoteAttribute& to_peripheral_char,
+    const cryptauth::RemoteAttribute& from_peripheral_char) {
   PA_LOG(INFO) << "Remote chacteristics found.";
   PrintTimeElapsed();
 
   DCHECK(sub_status() == SubStatus::WAITING_CHARACTERISTICS);
   remote_service_ = service;
   to_peripheral_char_ = to_peripheral_char;
   from_peripheral_char_ = from_peripheral_char;
 
   SetSubStatus(SubStatus::CHARACTERISTICS_FOUND);
   StartNotifySession();
 }
 
 void BluetoothLowEnergyConnection::OnCharacteristicsFinderError(
-    const RemoteAttribute& to_peripheral_char,
-    const RemoteAttribute& from_peripheral_char) {
+    const cryptauth::RemoteAttribute& to_peripheral_char,
+    const cryptauth::RemoteAttribute& from_peripheral_char) {
   DCHECK(sub_status() == SubStatus::WAITING_CHARACTERISTICS);
   PA_LOG(WARNING) << "Connection error, missing characteristics for SmartLock "
                      "service.\n"
                   << (to_peripheral_char.id.empty()
                           ? to_peripheral_char.uuid.canonical_value()
                           : "")
                   << (from_peripheral_char.id.empty()
                           ? ", " + from_peripheral_char.uuid.canonical_value()
                           : "") << " not found.";
 
@@ skipping 92 matching lines @@
             next_request.is_last_write_for_wire_message));
   }
 }
 
 void BluetoothLowEnergyConnection::OnRemoteCharacteristicWritten(
     bool run_did_send_message_callback) {
   PA_LOG(INFO) << "Characteristic written.";
   write_remote_characteristic_pending_ = false;
   // TODO(sacomoto): Actually pass the current message to the observer.
   if (run_did_send_message_callback)
-    OnDidSendMessage(WireMessage(std::string(), std::string()), true);
+    OnDidSendMessage(cryptauth::WireMessage(std::string(), std::string()),
+                     true);
 
   // Removes the top of queue (already processed) and process the next request.
   DCHECK(!write_requests_queue_.empty());
   write_requests_queue_.pop();
   ProcessNextWriteRequest();
 }
 
 void BluetoothLowEnergyConnection::OnWriteRemoteCharacteristicError(
     bool run_did_send_message_callback,
     BluetoothRemoteGattService::GattErrorCode error) {
   PA_LOG(WARNING) << "Error " << error << " writing characteristic: "
                   << to_peripheral_char_.uuid.canonical_value();
   write_remote_characteristic_pending_ = false;
   // TODO(sacomoto): Actually pass the current message to the observer.
   if (run_did_send_message_callback)
-    OnDidSendMessage(WireMessage(std::string(), std::string()), false);
+    OnDidSendMessage(cryptauth::WireMessage(std::string(), std::string()),
+                     false);
 
   // Increases the number of failed attempts and retry.
   DCHECK(!write_requests_queue_.empty());
   if (++write_requests_queue_.front().number_of_failed_attempts >=
       max_number_of_write_attempts_) {
     Disconnect();
     return;
   }
   ProcessNextWriteRequest();
 }
@@ skipping 80 matching lines @@
     const uint32_t value) {
   std::vector<uint8_t> bytes(4, 0);
   bytes[0] = static_cast<uint8_t>(value);
   bytes[1] = static_cast<uint8_t>(value >> 8);
   bytes[2] = static_cast<uint8_t>(value >> 16);
   bytes[3] = static_cast<uint8_t>(value >> 24);
   return bytes;
 }
 
 }  // namespace proximity_auth