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

components/proximity_auth/ble/bluetooth_low_energy_connection_unittest.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 <stdint.h>
+
 #include "base/bind.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_characteristics_finder.h"
 #include "components/proximity_auth/bluetooth_throttler.h"
 #include "components/proximity_auth/connection_finder.h"
 #include "components/proximity_auth/proximity_auth_test_util.h"
 #include "components/proximity_auth/remote_device.h"
@@ skipping 244 matching lines @@
 
     EXPECT_EQ(connection->sub_status(),
               BluetoothLowEnergyConnection::SubStatus::WAITING_RESPONSE_SIGNAL);
     EXPECT_EQ(connection->status(), Connection::IN_PROGRESS);
   }
 
   // Transitions |connection| from WAITING_RESPONSE_SIGNAL to CONNECTED state.
   void ResponseSignalReceived(MockBluetoothLowEnergyConnection* connection) {
     // Written value contains only the
     // BluetoothLowEneryConnection::ControlSignal::kInviteToConnectSignal.
-    const std::vector<uint8> kInviteToConnectSignal = ToByteVector(static_cast<
-        uint32>(
-        BluetoothLowEnergyConnection::ControlSignal::kInviteToConnectSignal));
+    const std::vector<uint8_t> kInviteToConnectSignal = ToByteVector(
+        static_cast<uint32_t>(BluetoothLowEnergyConnection::ControlSignal::
+                                  kInviteToConnectSignal));
     EXPECT_EQ(last_value_written_on_to_peripheral_char_,
               kInviteToConnectSignal);
 
     EXPECT_CALL(*connection, OnDidSendMessage(_, _)).Times(0);
     RunWriteCharacteristicSuccessCallback();
 
     // Received the
     // BluetoothLowEneryConnection::ControlSignal::kInvitationResponseSignal.
-    const std::vector<uint8> kInvitationResponseSignal = ToByteVector(
-        static_cast<uint32>(BluetoothLowEnergyConnection::ControlSignal::
-                                kInvitationResponseSignal));
+    const std::vector<uint8_t> kInvitationResponseSignal = ToByteVector(
+        static_cast<uint32_t>(BluetoothLowEnergyConnection::ControlSignal::
+                                  kInvitationResponseSignal));
     connection->GattCharacteristicValueChanged(
         adapter_.get(), from_peripheral_char_.get(), kInvitationResponseSignal);
 
     EXPECT_EQ(connection->sub_status(),
               BluetoothLowEnergyConnection::SubStatus::CONNECTED);
     EXPECT_EQ(connection->status(), Connection::CONNECTED);
   }
 
   // Transitions |connection| to a DISCONNECTED state regardless of its initial
   // state.
@@ skipping 15 matching lines @@
     NotifySessionStarted(connection);
     ResponseSignalReceived(connection);
   }
 
   void RunWriteCharacteristicSuccessCallback() {
     EXPECT_FALSE(write_remote_characteristic_error_callback_.is_null());
     ASSERT_FALSE(write_remote_characteristic_success_callback_.is_null());
     write_remote_characteristic_success_callback_.Run();
   }
 
-  std::vector<uint8> CreateSendSignalWithSize(int message_size) {
-    std::vector<uint8> value = ToByteVector(static_cast<uint32>(
+  std::vector<uint8_t> CreateSendSignalWithSize(int message_size) {
+    std::vector<uint8_t> value = ToByteVector(static_cast<uint32_t>(
         BluetoothLowEnergyConnection::ControlSignal::kSendSignal));
-    std::vector<uint8> size = ToByteVector(static_cast<uint32>(message_size));
+    std::vector<uint8_t> size =
+        ToByteVector(static_cast<uint32_t>(message_size));
     value.insert(value.end(), size.begin(), size.end());
     return value;
   }
 
-  std::vector<uint8> CreateFirstCharacteristicValue(const std::string& message,
-                                                    int size) {
-    std::vector<uint8> value(CreateSendSignalWithSize(size));
-    std::vector<uint8> bytes(message.begin(), message.end());
+  std::vector<uint8_t> CreateFirstCharacteristicValue(
+      const std::string& message,
+      int size) {
+    std::vector<uint8_t> value(CreateSendSignalWithSize(size));
+    std::vector<uint8_t> bytes(message.begin(), message.end());
     value.insert(value.end(), bytes.begin(), bytes.end());
     return value;
   }
 
-  std::vector<uint8> ToByteVector(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);
+  std::vector<uint8_t> ToByteVector(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;
   }
 
  protected:
   scoped_refptr<device::MockBluetoothAdapter> adapter_;
   RemoteDevice remote_device_;
   device::BluetoothUUID service_uuid_;
   device::BluetoothUUID to_peripheral_char_uuid_;
   device::BluetoothUUID from_peripheral_char_uuid_;
   scoped_ptr<device::MockBluetoothDevice> device_;
   scoped_ptr<device::MockBluetoothGattService> service_;
   scoped_ptr<device::MockBluetoothGattCharacteristic> to_peripheral_char_;
   scoped_ptr<device::MockBluetoothGattCharacteristic> from_peripheral_char_;
-  std::vector<uint8> last_value_written_on_to_peripheral_char_;
+  std::vector<uint8_t> last_value_written_on_to_peripheral_char_;
   device::MockBluetoothGattNotifySession* notify_session_alias_;
   scoped_ptr<MockBluetoothThrottler> bluetooth_throttler_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::MessageLoop message_loop_;
 
   // Callbacks
   device::BluetoothDevice::GattConnectionCallback
       create_gatt_connection_success_callback_;
   device::BluetoothDevice::ConnectErrorCallback
       create_gatt_connection_error_callback_;
@@ skipping 115 matching lines @@
   // |kMaxNumberOfTries-1| in the EXPECT_CALL statement.
   EXPECT_CALL(*connection, OnDidSendMessage(_, _)).Times(0);
   EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
       .Times(kMaxNumberOfTries - 1)
       .WillRepeatedly(
           DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
                 SaveArg<1>(&write_remote_characteristic_success_callback_),
                 SaveArg<2>(&write_remote_characteristic_error_callback_)));
 
   for (int i = 0; i < kMaxNumberOfTries; i++) {
-    const std::vector<uint8> kInviteToConnectSignal = ToByteVector(static_cast<
-        uint32>(
-        BluetoothLowEnergyConnection::ControlSignal::kInviteToConnectSignal));
+    const std::vector<uint8_t> kInviteToConnectSignal = ToByteVector(
+        static_cast<uint32_t>(BluetoothLowEnergyConnection::ControlSignal::
+                                  kInviteToConnectSignal));
     EXPECT_EQ(last_value_written_on_to_peripheral_char_,
               kInviteToConnectSignal);
     ASSERT_FALSE(write_remote_characteristic_error_callback_.is_null());
     EXPECT_FALSE(write_remote_characteristic_success_callback_.is_null());
     write_remote_characteristic_error_callback_.Run(
         device::BluetoothGattService::GATT_ERROR_UNKNOWN);
   }
 
   EXPECT_EQ(connection->sub_status(),
             BluetoothLowEnergyConnection::SubStatus::DISCONNECTED);
@@ skipping 37 matching lines @@
   // Sending the |kSendSignal| + |message_size| + |message| (truncated at
   // |chunk_size|).
   int first_write_payload_size =
       chunk_size - CreateSendSignalWithSize(message_size).size();
   connection->GattCharacteristicValueChanged(
       adapter_.get(), from_peripheral_char_.get(),
       CreateFirstCharacteristicValue(
           message.substr(0, first_write_payload_size), message.size()));
 
   // Sending the remaining bytes.
-  std::vector<uint8> value;
+  std::vector<uint8_t> value;
   value.push_back(0);
   value.insert(value.end(), message.begin() + first_write_payload_size,
                message.end());
   connection->GattCharacteristicValueChanged(
       adapter_.get(), from_peripheral_char_.get(), value);
 
   EXPECT_EQ(received_bytes, message);
 }
 
 TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
@@ skipping 37 matching lines @@
                 SaveArg<2>(&write_remote_characteristic_error_callback_)));
 
   // Message (bytes) that is going to be sent.
   int message_size = 600;
   std::string message(message_size, 'A');
   message[0] = 'B';
   connection->SendMessage(make_scoped_ptr(new FakeWireMessage(message)));
 
   // Expecting that |kSendSignal| + |message_size| was written in the first 8
   // bytes.
-  std::vector<uint8> prefix(
+  std::vector<uint8_t> prefix(
       last_value_written_on_to_peripheral_char_.begin(),
       last_value_written_on_to_peripheral_char_.begin() + 8);
   EXPECT_EQ(prefix, CreateSendSignalWithSize(message_size));
-  std::vector<uint8> bytes_received(
+  std::vector<uint8_t> bytes_received(
       last_value_written_on_to_peripheral_char_.begin() + 8,
       last_value_written_on_to_peripheral_char_.end());
 
   // Expecting a second call of WriteRemoteCharacteristic, after success
   // callback is called.
   EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
       .WillOnce(
           DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
                 SaveArg<1>(&write_remote_characteristic_success_callback_),
                 SaveArg<2>(&write_remote_characteristic_error_callback_)));
 
   RunWriteCharacteristicSuccessCallback();
   bytes_received.insert(bytes_received.end(),
                         last_value_written_on_to_peripheral_char_.begin() + 1,
                         last_value_written_on_to_peripheral_char_.end());
 
   // Expecting that the message was written.
-  std::vector<uint8> expected_value(message.begin(), message.end());
+  std::vector<uint8_t> expected_value(message.begin(), message.end());
   EXPECT_EQ(expected_value.size(), bytes_received.size());
   EXPECT_EQ(expected_value, bytes_received);
 
   EXPECT_CALL(*connection, OnDidSendMessage(_, _));
   RunWriteCharacteristicSuccessCallback();
 }
 
 TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
        Connect_AfterADelayWhenThrottled) {
   scoped_ptr<MockBluetoothLowEnergyConnection> connection(CreateConnection());
@@ skipping 27 matching lines @@
   create_gatt_connection_success_callback_.Run(
       make_scoped_ptr(new NiceMock<device::MockBluetoothGattConnection>(
           adapter_, kTestRemoteDeviceBluetoothAddress)));
 
   CharacteristicsFound(connection.get());
   NotifySessionStarted(connection.get());
   ResponseSignalReceived(connection.get());
 }
 
 }  // namespace proximity_auth