Substituting legacy protocol with uWeave protocol

components/proximity_auth/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_CONNECTION_H_
-#define COMPONENTS_PROXIMITY_AUTH_BLE_BLUETOOTH_LOW_ENERGY_CONNECTION_H_
+#ifndef COMPONENTS_PROXIMITY_AUTH_BLE_BLUETOOTH_LOW_ENERGY_WEAVE_CLIENT_CONNECTION_H_
+#define COMPONENTS_PROXIMITY_AUTH_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/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;
 
-// Represents a connection with a remote device over Bluetooth low energy. The
-// connection is a persistent bidirectional channel for sending and receiving
-// wire messages. The remote device is the peripheral mode and the service
-// contains two characteristics: one to send data and another to receive it.
-//
-// The connection flow is described below.
-//
-//          Discover Reader and Writer Characteristics
-//                              |
-//                              |
-//                              |
-//                    Start Notify Session
-//                              |
-//                              |
-//                              |
-//     Write kInviteToConnectSignal to Writer Characteristic
-//                              |
-//                              |
-//                              |
-//    Read kInvitationResponseSignal from Reader Characteristic
-//                              |
-//                              |
-//                              |
-//           Proximity Auth Connection Established
-class BluetoothLowEnergyConnection : public Connection,
-                                     public device::BluetoothAdapter::Observer {
+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 device::BluetoothAdapter::Observer {
  public:
-  // Signals sent to the remote device to indicate connection related events.
-  enum class ControlSignal : uint32_t {
-    kInviteToConnectSignal = 0,
-    kInvitationResponseSignal = 1,
-    kSendSignal = 2,
-    kDisconnectSignal = 3,
+  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::BluetoothLowEnergyConnection class
+  // The sub-state of a proximity_auth::BluetoothLowEnergyWeaveClientConnection
   // extends the IN_PROGRESS state of proximity_auth::Connection::Status.
-  enum class SubStatus {
+  enum SubStatus {
     DISCONNECTED,
     WAITING_GATT_CONNECTION,
     WAITING_CHARACTERISTICS,
     CHARACTERISTICS_FOUND,
     WAITING_NOTIFY_SESSION,
     NOTIFY_SESSION_READY,
-    WAITING_RESPONSE_SIGNAL,
+    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
-  // initaalized and ready. The GATT connection may alreaady be established and
+  // initialized and ready. The GATT connection may alreaady be established and
   // pass through |gatt_connection|. A subsequent call to Connect() must be
   // made.
-  BluetoothLowEnergyConnection(
+  BluetoothLowEnergyWeaveClientConnection(
       const RemoteDevice& remote_device,
       scoped_refptr<device::BluetoothAdapter> adapter,
       const device::BluetoothUUID remote_service_uuid,
       BluetoothThrottler* bluetooth_throttler,
       int max_number_of_write_attempts);
 
-  ~BluetoothLowEnergyConnection() override;
+  ~BluetoothLowEnergyWeaveClientConnection() override;
 
   // proximity_auth::Connection:
   void Connect() override;
   void Disconnect() override;
   std::string GetDeviceAddress() override;
 
  protected:
   // Exposed for testing.
-  void SetSubStatus(SubStatus status);
+  void DestroyConnection();
+
+  // Exposed for testing.
   SubStatus sub_status() { return sub_status_; }
 
+  // Exposed for testing.
+  int GetNumPendingMessages() { return map_to_message_.size(); }
+
   // 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;
 
   // 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 std::vector<uint8_t>& value) override;
+      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.
-  // A WireMessage corresponds to exactly two WriteRequest: the first containing
-  // a kSendSignal + the size of the WireMessage, and the second containing a
-  // SendStatusSignal + the serialized WireMessage.
   struct WriteRequest {
-    WriteRequest(const std::vector<uint8_t>& val, bool flag);
+    WriteRequest(const Packet& val,
+                 WriteRequestType request_type,
+                 int message_counter);
+    WriteRequest(const Packet& val, WriteRequestType request_type);
     WriteRequest(const WriteRequest& other);
     ~WriteRequest();
 
-    std::vector<uint8_t> value;
-    bool is_last_write_for_wire_message;
+    Packet value;
+    WriteRequestType request_type;
+    int message_counter;
     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(
       std::unique_ptr<device::BluetoothGattConnection> gatt_connection);
 
   // Callback called when there is an error creating the GATT connection.
   void OnCreateGattConnectionError(
       device::BluetoothDevice::ConnectErrorCode error_code);
 
-  // Callback called when |to_peripheral_char_| and |from_peripheral_char_| were
+  // Callback called when |tx_characteristic_| and |rx_characteristic_| were
   // found.
   void OnCharacteristicsFound(const RemoteAttribute& service,
-                              const RemoteAttribute& to_peripheral_char,
-                              const RemoteAttribute& from_peripheral_char);
+                              const RemoteAttribute& tx_characteristic,
+                              const RemoteAttribute& rx_characteristic);
 
   // Callback called there was an error finding the characteristics.
-  void OnCharacteristicsFinderError(
-      const RemoteAttribute& to_peripheral_char,
-      const RemoteAttribute& from_peripheral_char);
+  void OnCharacteristicsFinderError(const RemoteAttribute& tx_characteristic,
+                                    const RemoteAttribute& rx_characteristic);
 
-  // Starts a notify session for |from_peripheral_char_| when ready
+  // Starts a notify session for |rx_characteristic_| when ready
   // (SubStatus::CHARACTERISTICS_FOUND).
   void StartNotifySession();
 
   // Called when a notification session is successfully started for
-  // |from_peripheral_char_| characteristic.
+  // |rx_characteristic_| characteristic.
   void OnNotifySessionStarted(
       std::unique_ptr<device::BluetoothGattNotifySession> notify_session);
 
   // Called when there is an error starting a notification session for
-  // |from_peripheral_char_| characteristic.
+  // |rx_characteristic_| characteristic.
   void OnNotifySessionError(device::BluetoothGattService::GattErrorCode);
 
   // Stops |notify_session_|.
   void StopNotifySession();
 
-  // Sends an invite to connect signal to the peripheral if when ready
+  // Sends a connection request to server if ready
   // (SubStatus::NOTIFY_SESSION_READY).
-  void SendInviteToConnectSignal();
+  void SendConnectionRequest();
 
   // Completes and updates the status accordingly.
   void CompleteConnection();
 
   // This is the only entry point for WriteRequests, which are processed
   // accordingly the following flow:
   // 1) |request| is enqueued;
   // 2) |request| will be processed by ProcessNextWriteRequest() when there is
   // no pending write request;
   // 3) |request| will be dequeued when it's successfully processed
   // (OnRemoteCharacteristicWritten());
   // 4) |request| is not dequeued if it fails
   // (OnWriteRemoteCharacteristicError()), it remains on the queue and will be
   // retried. |request| will remain on the queue until it succeeds or it
   // triggers a Disconnect() call (after |max_number_of_tries_|).
-  void WriteRemoteCharacteristic(WriteRequest request);
+  void WriteRemoteCharacteristic(const WriteRequest& request);
 
   // Processes the next request in |write_requests_queue_|.
   void ProcessNextWriteRequest();
 
   // Called when the
   // BluetoothRemoteGattCharacteristic::RemoteCharacteristicWrite() is
   // successfully complete.
-  void OnRemoteCharacteristicWritten(bool run_did_send_message_callback);
+  void OnRemoteCharacteristicWritten(WriteRequestType request_type,
+                                     int message_counter);
 
   // Called when there is an error writing to the remote characteristic
-  // |to_peripheral_char_|.
+  // |tx_characteristic_|.
   void OnWriteRemoteCharacteristicError(
-      bool run_did_send_message_callback,
+      WriteRequestType request_type,
+      int message_counter,
       device::BluetoothRemoteGattService::GattErrorCode error);
 
-  // Builds the value to be written on |to_peripheral_char_|. The value
-  // corresponds to |signal| concatenated with |payload|.
-  WriteRequest BuildWriteRequest(const std::vector<uint8_t>& signal,
-                                 const std::vector<uint8_t>& bytes,
-                                 bool is_last_message_for_wire_message);
+  void OnPacketReceiverError();
 
   // Prints the time elapsed since |Connect()| was called.
   void PrintTimeElapsed();
 
   // Returns the device corresponding to |remote_device_address_|.
   device::BluetoothDevice* GetRemoteDevice();
 
   // Returns the service corresponding to |remote_service_| in the current
   // device.
   device::BluetoothRemoteGattService* GetRemoteService();
 
   // Returns the characteristic corresponding to |identifier| in the current
   // service.
   device::BluetoothRemoteGattCharacteristic* GetGattCharacteristic(
       const std::string& identifier);
 
-  // Convert the first 4 bytes from a byte vector to a uint32_t.
-  uint32_t ToUint32(const std::vector<uint8_t>& bytes);
-
-  // Convert an uint32_t to a byte vector.
-  const std::vector<uint8_t> ToByteVector(uint32_t value);
+  // Get the reason that the other side of the connection decided to close the
+  // connection.
+  // Will crash if the receiver is not in CONNECTION_CLOSED state.
+  std::string GetReasonForClose();
 
   // The Bluetooth adapter over which the Bluetooth connection will be made.
   scoped_refptr<device::BluetoothAdapter> adapter_;
 
   // Remote service the |gatt_connection_| was established with.
   RemoteAttribute remote_service_;
 
+  // uWeave packet generator.
+  std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator> packet_generator_;
+
+  // uWeave packet receiver.
+  std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> packet_receiver_;
+
   // Characteristic used to send data to the remote device.
-  RemoteAttribute to_peripheral_char_;
+  RemoteAttribute tx_characteristic_;
 
   // Characteristic used to receive data from the remote device.
-  RemoteAttribute from_peripheral_char_;
+  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_;
 
   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_;
 
-  // The notify session for |from_peripheral_char|.
+  // The notify session for |rx_characteristic|.
   std::unique_ptr<device::BluetoothGattNotifySession> notify_session_;
 
   // Internal connection status
   SubStatus sub_status_;
 
-  // Indicates a receiving operation is in progress. This is set after a
-  // ControlSignal::kSendSignal was received from the remote device.
-  bool receiving_bytes_;
-
-  // Total number of bytes expected for the current receive operation.
-  std::size_t expected_number_of_incoming_bytes_;
-
   // Bytes already received for the current receive operation.
   std::string incoming_bytes_buffer_;
 
   // Indicates there is a
   // BluetoothRemoteGattCharacteristic::WriteRemoteCharacteristic
   // operation pending.
   bool write_remote_characteristic_pending_;
 
   std::queue<WriteRequest> write_requests_queue_;
 
+  // Counter indicating which message the packet is from.
+  int next_message_counter_to_use_;
+
+  // Map of the message_counter_ to it's corresponding message.
+  std::map<int, std::unique_ptr<WireMessage>> map_to_message_;

[Tim Song, 2016/07/21 20:49:35]

Do you actually need to store a map of WireMessages that were sent? It seems you
are inserting and then erasing each written message. Wouldn't it suffice just to
store the last written WireMessage?

[jingxuy, 2016/07/21 21:30:34]

I think the problem there is no guarantee when the write remote characteristic
success callback is called. It could have been 2 outstanding writes and it
doesn't finish the order you expect them. Unless it's guarantee FIFO and I can
change it.

[Tim Song, 2016/07/22 00:52:50]

|characteristic->WriteRemoteCharacteristic()| is only called when the last
request completes (whether success or error), so it seems to me that there is no
way to have 2 outstanding requests at the same time.

[jingxuy, 2016/07/22 17:14:59]

I wasn't thinking clearly yesterday. But the reason that you need the map is
that sendMessaeImpl can be called many times with different message before any
one message finish sending. So at any given time, there could be more than 1
outstanding message and the callback needs to know which is which.

[Tim Song, 2016/07/22 18:41:34]

SendMessageImpl() creates a new WriteRequest and puts it in the
|write_requests_queue_|, and processes one request at a time, so it already does
the queuing.

[jingxuy, 2016/07/22 23:06:11]

Done.

+
   // Maximum number of tries to send any write request.
   int max_number_of_write_attempts_;
 
-  // Maximum number of bytes that fit in a single chunk to be written in
-  // |to_peripheral_char_|. Ideally, this should be the maximum value the
-  // peripheral supports and it should be agreed when the GATT connection is
-  // created. Currently, there is no API to find this value. The implementation
-  // uses a hard-coded constant.
-  int max_chunk_size_;
-
   // Stores when the instace was created.
   base::TimeTicks start_time_;
 
-  base::WeakPtrFactory<BluetoothLowEnergyConnection> weak_ptr_factory_;
+  base::WeakPtrFactory<BluetoothLowEnergyWeaveClientConnection>
+      weak_ptr_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(BluetoothLowEnergyConnection);
+  DISALLOW_COPY_AND_ASSIGN(BluetoothLowEnergyWeaveClientConnection);
 };
 
+}  // namespace weave
+
 }  // namespace proximity_auth
 
-#endif  // COMPONENTS_PROXIMITY_AUTH_BLE_BLUETOOTH_LOW_ENERGY_CONNECTION_H_
+#endif  // COMPONENTS_PROXIMITY_AUTH_BLE_BLUETOOTH_LOW_ENERGY_WEAVE_CLIENT_CONNECTION_H_