[EasyUnlock] Move DataWithTimestamp out of ForegroundEidGenerator so it can be shared.

chromeos/components/tether/ble_advertiser_unittest.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 "chromeos/components/tether/ble_advertiser.h"
 
 #include "base/logging.h"
 #include "chromeos/components/tether/ble_constants.h"
 #include "chromeos/components/tether/mock_local_device_data_provider.h"
 #include "components/cryptauth/mock_foreground_eid_generator.h"
 #include "components/cryptauth/mock_remote_beacon_seed_fetcher.h"
 #include "components/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/cryptauth/remote_device_test_util.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_advertisement.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::Invoke;
 using testing::Return;
 using testing::StrictMock;
 using testing::_;
 
 namespace chromeos {
 
 namespace tether {
 
 namespace {
 uint8_t kInvertedConnectionFlag = 0x01;
 
-const std::string fake_public_key = "fakePublicKey";
+const char kFakePublicKey[] = "fakePublicKey";
 
 struct RegisterAdvertisementArgs
     : public base::RefCounted<RegisterAdvertisementArgs> {
   RegisterAdvertisementArgs(
       const device::BluetoothAdvertisement::ServiceData& service_data,
       const device::BluetoothAdvertisement::UUIDList& service_uuids,
       const device::BluetoothAdapter::CreateAdvertisementCallback& callback,
       const device::BluetoothAdapter::AdvertisementErrorCallback& errback)
       : service_data(service_data),
         service_uuids(service_uuids),
@@ skipping 32 matching lines @@
     RegisterAdvertisementWithArgsStruct(
         make_scoped_refptr(new RegisterAdvertisementArgs(
             *advertisement_data->service_data(),
             *advertisement_data->service_uuids(), callback, errback)));
   }
 
  protected:
   ~MockBluetoothAdapterWithAdvertisements() override {}
 };
 
-std::vector<cryptauth::ForegroundEidGenerator::DataWithTimestamp>
-GenerateFakeAdvertisements() {
-  cryptauth::ForegroundEidGenerator::DataWithTimestamp advertisement1(
-      "advertisement1", 1000L, 2000L);
-  cryptauth::ForegroundEidGenerator::DataWithTimestamp advertisement2(
-      "advertisement2", 2000L, 3000L);
+std::vector<cryptauth::DataWithTimestamp> GenerateFakeAdvertisements() {
+  cryptauth::DataWithTimestamp advertisement1("advertisement1", 1000L, 2000L);
+  cryptauth::DataWithTimestamp advertisement2("advertisement2", 2000L, 3000L);
 
-  std::vector<cryptauth::ForegroundEidGenerator::DataWithTimestamp>
-      advertisements = {advertisement1, advertisement2};
+  std::vector<cryptauth::DataWithTimestamp> advertisements = {advertisement1,
+                                                              advertisement2};
   return advertisements;
 }
 
 std::vector<cryptauth::BeaconSeed> CreateFakeBeaconSeedsForDevice(
     const cryptauth::RemoteDevice& remote_device) {
   cryptauth::BeaconSeed seed1;
   seed1.set_data("seed1Data" + remote_device.GetTruncatedDeviceIdForLogs());
   seed1.set_start_time_millis(1000L);
   seed1.set_start_time_millis(2000L);
 
   cryptauth::BeaconSeed seed2;
   seed2.set_data("seed2Data" + remote_device.GetTruncatedDeviceIdForLogs());
   seed2.set_start_time_millis(2000L);
   seed2.set_start_time_millis(3000L);
 
   std::vector<cryptauth::BeaconSeed> seeds = {seed1, seed2};
   return seeds;
-};
+}
 
 }  // namespace
 
 class BleAdvertiserTest : public testing::Test {
  protected:
   class TestBleAdvertisementUnregisterHandler
       : public BleAdvertiser::BleAdvertisementUnregisterHandler {
    public:
     TestBleAdvertisementUnregisterHandler()
         : num_advertisements_unregistered_(0) {}
@@ skipping 51 matching lines @@
         CreateFakeBeaconSeedsForDevice(fake_devices_[2]);
     mock_seed_fetcher_->SetSeedsForDevice(fake_devices_[0],
                                           &device_0_beacon_seeds);
     mock_seed_fetcher_->SetSeedsForDevice(fake_devices_[1],
                                           &device_1_beacon_seeds);
     mock_seed_fetcher_->SetSeedsForDevice(fake_devices_[2],
                                           &device_2_beacon_seeds);
 
     mock_local_data_provider_ = base::MakeUnique<MockLocalDeviceDataProvider>();
     mock_local_data_provider_->SetPublicKey(
-        base::MakeUnique<std::string>(fake_public_key));
+        base::MakeUnique<std::string>(kFakePublicKey));
 
     ble_advertiser_ = base::WrapUnique(new BleAdvertiser(
         mock_adapter_, base::WrapUnique(test_unregister_handler_),
         std::move(eid_generator), mock_seed_fetcher_.get(),
         mock_local_data_provider_.get()));
   }
 
   void TearDown() override {
     // Delete the advertiser to ensure that cleanup happens properly.
     ble_advertiser_.reset();
@@ skipping 72 matching lines @@
   cryptauth::MockForegroundEidGenerator* mock_eid_generator_;
   std::unique_ptr<cryptauth::MockRemoteBeaconSeedFetcher> mock_seed_fetcher_;
   std::unique_ptr<MockLocalDeviceDataProvider> mock_local_data_provider_;
 
   std::vector<scoped_refptr<RegisterAdvertisementArgs>>
       register_advertisement_args_;
   std::vector<BleAdvertiser::IndividualAdvertisement*>
       individual_advertisements_;
 
   const std::vector<cryptauth::RemoteDevice> fake_devices_;
-  const std::vector<cryptauth::ForegroundEidGenerator::DataWithTimestamp>
-      fake_advertisements_;
+  const std::vector<cryptauth::DataWithTimestamp> fake_advertisements_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BleAdvertiserTest);
 };
 
 TEST_F(BleAdvertiserTest, TestCannotFetchPublicKey) {
   EXPECT_CALL(*mock_adapter_, RegisterAdvertisementWithArgsStruct(_)).Times(0);
 
   mock_local_data_provider_->SetPublicKey(nullptr);
 
@@ skipping 32 matching lines @@
 
   EXPECT_FALSE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[0]));
 }
 
 TEST_F(BleAdvertiserTest, AdapterPoweredOffWhenAdvertisementRegistered) {
   EXPECT_CALL(*mock_adapter_, AddObserver(_)).Times(1);
   EXPECT_CALL(*mock_adapter_, RemoveObserver(_)).Times(1);
   EXPECT_CALL(*mock_adapter_, IsPowered()).Times(1).WillOnce(Return(false));
 
   mock_eid_generator_->set_advertisement(
-      base::MakeUnique<cryptauth::ForegroundEidGenerator::DataWithTimestamp>(
-          fake_advertisements_[0]));
+      base::MakeUnique<cryptauth::DataWithTimestamp>(fake_advertisements_[0]));
 
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[0]));
   EXPECT_EQ(static_cast<size_t>(1), individual_advertisements_.size());
 
   // RegisterAdvertisement() should not have been called.
   EXPECT_FALSE(register_advertisement_args_.size());
 }
 
 TEST_F(BleAdvertiserTest, RegisteringAdvertisementFails) {
   EXPECT_CALL(*mock_adapter_, AddObserver(_)).Times(1);
   EXPECT_CALL(*mock_adapter_, RemoveObserver(_)).Times(1);
   EXPECT_CALL(*mock_adapter_, IsPowered()).Times(1);
   EXPECT_CALL(*mock_adapter_, RegisterAdvertisementWithArgsStruct(_)).Times(1);
 
   mock_eid_generator_->set_advertisement(
-      base::MakeUnique<cryptauth::ForegroundEidGenerator::DataWithTimestamp>(
-          fake_advertisements_[0]));
+      base::MakeUnique<cryptauth::DataWithTimestamp>(fake_advertisements_[0]));
 
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[0]));
   EXPECT_EQ(static_cast<size_t>(1), individual_advertisements_.size());
   EXPECT_EQ(static_cast<size_t>(1), register_advertisement_args_.size());
   VerifyServiceDataMatches(register_advertisement_args_[0],
                            individual_advertisements_[0]);
 
   InvokeErrback(register_advertisement_args_[0]);
   VerifyAdvertisementHasNotStarted(individual_advertisements_[0]);
 }
 
 TEST_F(BleAdvertiserTest, AdvertisementRegisteredSuccessfully) {
   EXPECT_CALL(*mock_adapter_, AddObserver(_)).Times(1);
   EXPECT_CALL(*mock_adapter_, RemoveObserver(_)).Times(1);
   EXPECT_CALL(*mock_adapter_, IsPowered()).Times(1);
   EXPECT_CALL(*mock_adapter_, RegisterAdvertisementWithArgsStruct(_)).Times(1);
 
   mock_eid_generator_->set_advertisement(
-      base::MakeUnique<cryptauth::ForegroundEidGenerator::DataWithTimestamp>(
-          fake_advertisements_[0]));
+      base::MakeUnique<cryptauth::DataWithTimestamp>(fake_advertisements_[0]));
 
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[0]));
   EXPECT_EQ(static_cast<size_t>(1), individual_advertisements_.size());
   EXPECT_EQ(static_cast<size_t>(1), register_advertisement_args_.size());
   VerifyServiceDataMatches(register_advertisement_args_[0],
                            individual_advertisements_[0]);
 
   InvokeCallback(register_advertisement_args_[0]);
   VerifyAdvertisementHasStarted(individual_advertisements_[0]);
 
   // Now, unregister.
   EXPECT_TRUE(ble_advertiser_->StopAdvertisingToDevice(fake_devices_[0]));
   EXPECT_FALSE(individual_advertisements_.size());
   EXPECT_EQ(1u, test_unregister_handler_->num_advertisements_unregistered());
 }
 
 TEST_F(BleAdvertiserTest, AdvertisementRegisteredSuccessfully_TwoDevices) {
   EXPECT_CALL(*mock_adapter_, AddObserver(_)).Times(2);
   EXPECT_CALL(*mock_adapter_, RemoveObserver(_)).Times(2);
   EXPECT_CALL(*mock_adapter_, IsPowered()).Times(2);
   EXPECT_CALL(*mock_adapter_, RegisterAdvertisementWithArgsStruct(_)).Times(2);
 
   // First device.
   mock_eid_generator_->set_advertisement(
-      base::MakeUnique<cryptauth::ForegroundEidGenerator::DataWithTimestamp>(
-          fake_advertisements_[0]));
+      base::MakeUnique<cryptauth::DataWithTimestamp>(fake_advertisements_[0]));
 
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[0]));
   EXPECT_EQ(static_cast<size_t>(1), individual_advertisements_.size());
   EXPECT_EQ(static_cast<size_t>(1), register_advertisement_args_.size());
   VerifyServiceDataMatches(register_advertisement_args_[0],
                            individual_advertisements_[0]);
 
   InvokeCallback(register_advertisement_args_[0]);
   VerifyAdvertisementHasStarted(individual_advertisements_[0]);
 
   // Second device.
   mock_eid_generator_->set_advertisement(
-      base::MakeUnique<cryptauth::ForegroundEidGenerator::DataWithTimestamp>(
-          fake_advertisements_[1]));
+      base::MakeUnique<cryptauth::DataWithTimestamp>(fake_advertisements_[1]));
 
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[1]));
   EXPECT_EQ(static_cast<size_t>(2), individual_advertisements_.size());
   EXPECT_EQ(static_cast<size_t>(2), register_advertisement_args_.size());
   VerifyServiceDataMatches(register_advertisement_args_[1],
                            individual_advertisements_[1]);
 
   InvokeCallback(register_advertisement_args_[1]);
   VerifyAdvertisementHasStarted(individual_advertisements_[1]);
 
   // Now, unregister.
   EXPECT_TRUE(ble_advertiser_->StopAdvertisingToDevice(fake_devices_[0]));
   EXPECT_EQ(1u, test_unregister_handler_->num_advertisements_unregistered());
 
   EXPECT_TRUE(ble_advertiser_->StopAdvertisingToDevice(fake_devices_[1]));
   EXPECT_EQ(2u, test_unregister_handler_->num_advertisements_unregistered());
 
   EXPECT_FALSE(individual_advertisements_.size());
 }
 
 TEST_F(BleAdvertiserTest, TooManyDevicesRegistered) {
   ASSERT_EQ(2, kMaxConcurrentAdvertisements);
 
   EXPECT_CALL(*mock_adapter_, AddObserver(_)).Times(3);
   EXPECT_CALL(*mock_adapter_, RemoveObserver(_)).Times(3);
   EXPECT_CALL(*mock_adapter_, IsPowered()).Times(3);
   EXPECT_CALL(*mock_adapter_, RegisterAdvertisementWithArgsStruct(_)).Times(3);
 
   mock_eid_generator_->set_advertisement(
-      base::MakeUnique<cryptauth::ForegroundEidGenerator::DataWithTimestamp>(
-          fake_advertisements_[0]));
+      base::MakeUnique<cryptauth::DataWithTimestamp>(fake_advertisements_[0]));
 
   // Should succeed for the first two devices.
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[0]));
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[1]));
 
   // Should fail on the third device.
   EXPECT_FALSE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[2]));
 
   // Now, stop advertising to one; registering the third device should succeed
   // at this point.
   EXPECT_TRUE(ble_advertiser_->StopAdvertisingToDevice(fake_devices_[0]));
 
   // Because the advertisement was never registered to begin with, it also
   // should never have been unregistered.
   EXPECT_EQ(0u, test_unregister_handler_->num_advertisements_unregistered());
 
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[2]));
 }
 
 TEST_F(BleAdvertiserTest, AdapterPowerChange_StartsOffThenTurnsOn) {
   EXPECT_CALL(*mock_adapter_, AddObserver(_)).Times(1);
   EXPECT_CALL(*mock_adapter_, RemoveObserver(_)).Times(1);
   EXPECT_CALL(*mock_adapter_, IsPowered())
       .Times(2)
       .WillOnce(Return(false))  // First, the adapter is powered off.
       .WillOnce(Return(true));  // Then, the adapter is powered back on.
   EXPECT_CALL(*mock_adapter_, RegisterAdvertisementWithArgsStruct(_)).Times(1);
 
   mock_eid_generator_->set_advertisement(
-      base::MakeUnique<cryptauth::ForegroundEidGenerator::DataWithTimestamp>(
-          fake_advertisements_[0]));
+      base::MakeUnique<cryptauth::DataWithTimestamp>(fake_advertisements_[0]));
 
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[0]));
   EXPECT_EQ(static_cast<size_t>(1), individual_advertisements_.size());
 
   // RegisterAdvertisement() should not have been called.
   EXPECT_FALSE(register_advertisement_args_.size());
 
   // Now, simulate power being changed. Since the power is now on,
   // RegisterAdvertisement() should have been called.
   individual_advertisements_[0]->AdapterPoweredChanged(mock_adapter_.get(),
                                                        true);
   EXPECT_EQ(static_cast<size_t>(1), individual_advertisements_.size());
   EXPECT_EQ(static_cast<size_t>(1), register_advertisement_args_.size());
   VerifyServiceDataMatches(register_advertisement_args_[0],
                            individual_advertisements_[0]);
 }
 
 TEST_F(BleAdvertiserTest, AdvertisementReleased) {
   EXPECT_CALL(*mock_adapter_, AddObserver(_)).Times(1);
   EXPECT_CALL(*mock_adapter_, RemoveObserver(_)).Times(1);
   EXPECT_CALL(*mock_adapter_, IsPowered()).Times(2);
   EXPECT_CALL(*mock_adapter_, RegisterAdvertisementWithArgsStruct(_)).Times(2);
 
   mock_eid_generator_->set_advertisement(
-      base::MakeUnique<cryptauth::ForegroundEidGenerator::DataWithTimestamp>(
-          fake_advertisements_[0]));
+      base::MakeUnique<cryptauth::DataWithTimestamp>(fake_advertisements_[0]));
 
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[0]));
   EXPECT_EQ(static_cast<size_t>(1), individual_advertisements_.size());
   EXPECT_EQ(static_cast<size_t>(1), register_advertisement_args_.size());
   VerifyServiceDataMatches(register_advertisement_args_[0],
                            individual_advertisements_[0]);
 
   InvokeCallback(register_advertisement_args_[0]);
   VerifyAdvertisementHasStarted(individual_advertisements_[0]);
 
   // Now, simulate the advertisement being released. A new advertisement should
   // have been created.
   ReleaseAdvertisement(individual_advertisements_[0]);
   EXPECT_EQ(static_cast<size_t>(2), register_advertisement_args_.size());
   VerifyServiceDataMatches(register_advertisement_args_[1],
                            individual_advertisements_[0]);
 
   InvokeCallback(register_advertisement_args_[1]);
   VerifyAdvertisementHasStarted(individual_advertisements_[0]);
 
   // Now, unregister.
   EXPECT_TRUE(ble_advertiser_->StopAdvertisingToDevice(fake_devices_[0]));
   EXPECT_EQ(1u, test_unregister_handler_->num_advertisements_unregistered());
   EXPECT_FALSE(individual_advertisements_.size());
 }
 
 }  // namespace tether
 
-}  // namespace cryptauth
+}  // namespace chromeos