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

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/proximity_auth/ble/bluetooth_low_energy_weave_client_connection.h"
+#include "components/cryptauth/ble/bluetooth_low_energy_weave_client_connection.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/proximity_auth/bluetooth_throttler.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_gatt_connection.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
 using device::BluetoothGattConnection;
 using device::BluetoothRemoteGattService;
 using device::BluetoothRemoteGattCharacteristic;
 using device::BluetoothGattNotifySession;
 using device::BluetoothUUID;
 
-namespace proximity_auth {
+namespace cryptauth {
 namespace weave {
 namespace {
 
 typedef BluetoothLowEnergyWeavePacketReceiver::State ReceiverState;
 
 // The UUID of the TX characteristic used to transmit data to the server.
 const char kTXCharacteristicUUID[] = "00000100-0004-1000-8000-001A11000101";
 
 // The UUID of the RX characteristic used to receive data from the server.
 const char kRXCharacteristicUUID[] = "00000100-0004-1000-8000-001A11000102";
 
 }  // namespace
 
 BluetoothLowEnergyWeaveClientConnection::
     BluetoothLowEnergyWeaveClientConnection(
         const cryptauth::RemoteDevice& device,
         scoped_refptr<device::BluetoothAdapter> adapter,
         const BluetoothUUID remote_service_uuid,
-        BluetoothThrottler* bluetooth_throttler,
+        proximity_auth::BluetoothThrottler* bluetooth_throttler,
         int max_number_of_write_attempts)
     : Connection(device),
       adapter_(adapter),
       remote_service_({remote_service_uuid, ""}),
       packet_generator_(
           BluetoothLowEnergyWeavePacketGenerator::Factory::NewInstance()),
       packet_receiver_(
           BluetoothLowEnergyWeavePacketReceiver::Factory::NewInstance(
               BluetoothLowEnergyWeavePacketReceiver::ReceiverType::CLIENT)),
       tx_characteristic_({BluetoothUUID(kTXCharacteristicUUID), ""}),
@@ skipping 114 matching lines @@
     SetStatus(Status::IN_PROGRESS);
   }
 }
 
 void BluetoothLowEnergyWeaveClientConnection::SetTaskRunnerForTesting(
     scoped_refptr<base::TaskRunner> task_runner) {
   task_runner_ = task_runner;
 }
 
 void BluetoothLowEnergyWeaveClientConnection::SendMessageImpl(
-    std::unique_ptr<WireMessage> message) {
+    std::unique_ptr<proximity_auth::WireMessage> message) {
   PA_LOG(INFO) << "Sending message " << message->Serialize();
   std::string serialized_msg = message->Serialize();
 
   std::vector<Packet> packets =
       packet_generator_->EncodeDataMessage(serialized_msg);
 
-  std::shared_ptr<WireMessage> request_message(message.release());
+  std::shared_ptr<proximity_auth::WireMessage> request_message(
+      message.release());
 
   for (uint32_t i = 0; i < packets.size(); ++i) {
     WriteRequestType request_type = (i == packets.size() - 1)
                                         ? WriteRequestType::MESSAGE_COMPLETE
                                         : WriteRequestType::REGULAR;
     WriteRequest request(packets[i], request_type, request_message);
     WriteRemoteCharacteristic(request);
   }
 }
 
@@ skipping 409 matching lines @@
       return "APPLICATION_ERROR";
     default:
       NOTREACHED();
       return "";
   }
 }
 
 BluetoothLowEnergyWeaveClientConnection::WriteRequest::WriteRequest(
     const Packet& val,
     WriteRequestType request_type,
-    std::shared_ptr<WireMessage> message)
+    std::shared_ptr<proximity_auth::WireMessage> message)
     : value(val),
       request_type(request_type),
       message(message),
       number_of_failed_attempts(0) {}
 
 BluetoothLowEnergyWeaveClientConnection::WriteRequest::WriteRequest(
     const Packet& val,
     WriteRequestType request_type)
     : value(val),
       request_type(request_type),
       message(nullptr),
       number_of_failed_attempts(0) {}
 
 BluetoothLowEnergyWeaveClientConnection::WriteRequest::WriteRequest(
     const WriteRequest& other) = default;
 
 BluetoothLowEnergyWeaveClientConnection::WriteRequest::~WriteRequest() {}
 
 }  // namespace weave
 
-}  // namespace proximity_auth
+}  // namespace cryptauth