Switch to standard integer types in components/, part 3 of 4.

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 "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 152 matching lines @@
 }
 
 void BluetoothLowEnergyConnection::SendMessageImpl(
     scoped_ptr<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>(ControlSignal::kSendSignal)),
-      ToByteVector(static_cast<uint32>(serialized_msg.size())), false);
+      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
   // |max_chunk_size_|.
   size_t first_chunk_size = std::min(
       max_chunk_size_ - write_request.value.size(), serialized_msg.size());
-  std::vector<uint8> bytes(serialized_msg.begin(),
-                           serialized_msg.begin() + first_chunk_size);
+  std::vector<uint8_t> bytes(serialized_msg.begin(),
+                             serialized_msg.begin() + first_chunk_size);
   write_request.value.insert(write_request.value.end(), bytes.begin(),
                              bytes.end());
 
   bool is_last_write_request = first_chunk_size == serialized_msg.size();
   write_request.is_last_write_for_wire_message = is_last_write_request;
   WriteRemoteCharacteristic(write_request);
   if (is_last_write_request)
     return;
 
   // [Other write requests]: Each chunk has to include a deprecated signal:
   // |kFirstByteZero| as the first byte.
   int chunk_size = max_chunk_size_ - 1;
-  std::vector<uint8> kFirstByteZeroVector;
-  kFirstByteZeroVector.push_back(static_cast<uint8>(kFirstByteZero));
+  std::vector<uint8_t> kFirstByteZeroVector;
+  kFirstByteZeroVector.push_back(static_cast<uint8_t>(kFirstByteZero));
 
   int message_size = static_cast<int>(serialized_msg.size());
   int start_index = first_chunk_size;
   while (start_index < message_size) {
     int end_index = (start_index + chunk_size) <= message_size
                         ? (start_index + chunk_size)
                         : message_size;
     bool is_last_write_request = (end_index == message_size);
     write_request = BuildWriteRequest(
         kFirstByteZeroVector,
-        std::vector<uint8>(serialized_msg.begin() + start_index,
-                           serialized_msg.begin() + end_index),
+        std::vector<uint8_t>(serialized_msg.begin() + start_index,
+                             serialized_msg.begin() + end_index),
         is_last_write_request);
     WriteRemoteCharacteristic(write_request);
     start_index = end_index;
   }
 }
 
 // Changes in the GATT connection with the remote device should be observed
 // here. If the GATT connection is dropped, we should call Disconnect() anyway,
 // so the object can notify its observers.
 void BluetoothLowEnergyConnection::DeviceChanged(BluetoothAdapter* adapter,
@@ skipping 21 matching lines @@
       device->GetAddress() != GetDeviceAddress())
     return;
 
   PA_LOG(INFO) << "Device removed " << GetDeviceAddress();
   Disconnect();
 }
 
 void BluetoothLowEnergyConnection::GattCharacteristicValueChanged(
     BluetoothAdapter* adapter,
     BluetoothGattCharacteristic* characteristic,
-    const std::vector<uint8>& value) {
+    const std::vector<uint8_t>& value) {
   DCHECK_EQ(adapter, adapter_.get());
   if (sub_status() != SubStatus::WAITING_RESPONSE_SIGNAL &&
       sub_status() != SubStatus::CONNECTED)
     return;
 
   PA_LOG(INFO) << "Characteristic value changed: "
                << characteristic->GetUUID().canonical_value();
 
   if (characteristic->GetIdentifier() == from_peripheral_char_.id) {
     if (receiving_bytes_) {
@@ skipping 19 matching lines @@
           CompleteConnection();
         break;
       case ControlSignal::kInviteToConnectSignal:
         break;
       case ControlSignal::kSendSignal: {
         if (value.size() < 8) {
           PA_LOG(WARNING)
               << "Incoming data corrupted, expected message size not found.";
           return;
         }
-        std::vector<uint8> size(value.begin() + 4, value.begin() + 8);
+        std::vector<uint8_t> size(value.begin() + 4, value.begin() + 8);
         expected_number_of_incoming_bytes_ =
             static_cast<size_t>(ToUint32(size));
         receiving_bytes_ = true;
         incoming_bytes_buffer_.clear();
 
         const std::string bytes(value.begin() + 8, value.end());
         incoming_bytes_buffer_.append(bytes);
         if (incoming_bytes_buffer_.size() >=
             expected_number_of_incoming_bytes_) {
           OnBytesReceived(incoming_bytes_buffer_);
           receiving_bytes_ = false;
         }
         break;
       }
       case ControlSignal::kDisconnectSignal:
         PA_LOG(INFO) << "Disconnect signal received.";
         Disconnect();
         break;
     }
   }
 }
 
 BluetoothLowEnergyConnection::WriteRequest::WriteRequest(
-    const std::vector<uint8>& val,
+    const std::vector<uint8_t>& val,
     bool flag)
     : value(val),
       is_last_write_for_wire_message(flag),
-      number_of_failed_attempts(0) {
-}
+      number_of_failed_attempts(0) {}
 
 BluetoothLowEnergyConnection::WriteRequest::~WriteRequest() {}
 
 void BluetoothLowEnergyConnection::CompleteConnection() {
   PA_LOG(INFO) << "Connection completed. Time elapsed: "
                << base::TimeTicks::Now() - start_time_;
   SetSubStatus(SubStatus::CONNECTED);
 }
 
 void BluetoothLowEnergyConnection::OnCreateGattConnectionError(
@@ skipping 120 matching lines @@
   }
 }
 
 void BluetoothLowEnergyConnection::SendInviteToConnectSignal() {
   if (sub_status() == SubStatus::NOTIFY_SESSION_READY) {
     PA_LOG(INFO) << "Sending invite to connect signal";
     SetSubStatus(SubStatus::WAITING_RESPONSE_SIGNAL);
 
     WriteRequest write_request = BuildWriteRequest(
         ToByteVector(
-            static_cast<uint32>(ControlSignal::kInviteToConnectSignal)),
-        std::vector<uint8>(), false);
+            static_cast<uint32_t>(ControlSignal::kInviteToConnectSignal)),
+        std::vector<uint8_t>(), false);
 
     WriteRemoteCharacteristic(write_request);
   }
 }
 
 void BluetoothLowEnergyConnection::WriteRemoteCharacteristic(
     WriteRequest request) {
   write_requests_queue_.push(request);
   ProcessNextWriteRequest();
 }
@@ skipping 47 matching lines @@
   if (++write_requests_queue_.front().number_of_failed_attempts >=
       max_number_of_write_attempts_) {
     Disconnect();
     return;
   }
   ProcessNextWriteRequest();
 }
 
 BluetoothLowEnergyConnection::WriteRequest
 BluetoothLowEnergyConnection::BuildWriteRequest(
-    const std::vector<uint8>& signal,
-    const std::vector<uint8>& bytes,
+    const std::vector<uint8_t>& signal,
+    const std::vector<uint8_t>& bytes,
     bool is_last_write_for_wire_message) {
-  std::vector<uint8> value(signal.begin(), signal.end());
+  std::vector<uint8_t> value(signal.begin(), signal.end());
   value.insert(value.end(), bytes.begin(), bytes.end());
   return WriteRequest(value, is_last_write_for_wire_message);
 }
 
 void BluetoothLowEnergyConnection::PrintTimeElapsed() {
   PA_LOG(INFO) << "Time elapsed: " << base::TimeTicks::Now() - start_time_;
 }
 
 std::string BluetoothLowEnergyConnection::GetDeviceAddress() {
   // When the remote device is connected we should rely on the address given by
@@ skipping 45 matching lines @@
   BluetoothGattService* remote_service = GetRemoteService();
   if (!remote_service) {
     PA_LOG(WARNING) << "Remote service not found.";
     return NULL;
   }
   return remote_service->GetCharacteristic(gatt_characteristic);
 }
 
 // TODO(sacomoto): make this robust to byte ordering in both sides of the
 // SmartLock BLE socket.
-uint32 BluetoothLowEnergyConnection::ToUint32(const std::vector<uint8>& bytes) {
+uint32_t BluetoothLowEnergyConnection::ToUint32(
+    const std::vector<uint8_t>& bytes) {
   return bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24);
 }
 
 // TODO(sacomoto): make this robust to byte ordering in both sides of the
 // SmartLock BLE socket.
-const std::vector<uint8> BluetoothLowEnergyConnection::ToByteVector(
-    const uint32 value) {
-  std::vector<uint8> bytes(4, 0);
-  bytes[0] = static_cast<uint8>(value);
-  bytes[1] = static_cast<uint8>(value >> 8);
-  bytes[2] = static_cast<uint8>(value >> 16);
-  bytes[3] = static_cast<uint8>(value >> 24);
+const std::vector<uint8_t> BluetoothLowEnergyConnection::ToByteVector(
+    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