[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"
@@ skipping 62 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::EidDataWithTimestamp> GenerateFakeAdvertisements() {
+  cryptauth::EidDataWithTimestamp advertisement1("advertisement1", 1000L,
+                                                 2000L);
+  cryptauth::EidDataWithTimestamp advertisement2("advertisement2", 2000L,
+                                                 3000L);
 
-  std::vector<cryptauth::ForegroundEidGenerator::DataWithTimestamp>
-      advertisements = {advertisement1, advertisement2};
+  std::vector<cryptauth::EidDataWithTimestamp> 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);
 
@@ skipping 162 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::EidDataWithTimestamp> 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>(
+      base::MakeUnique<cryptauth::EidDataWithTimestamp>(
           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>(
+      base::MakeUnique<cryptauth::EidDataWithTimestamp>(
           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>(
+      base::MakeUnique<cryptauth::EidDataWithTimestamp>(
           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>(
+      base::MakeUnique<cryptauth::EidDataWithTimestamp>(
           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>(
+      base::MakeUnique<cryptauth::EidDataWithTimestamp>(
           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]);
@@ skipping 10 matching lines @@
 
 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>(
+      base::MakeUnique<cryptauth::EidDataWithTimestamp>(
           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
@@ skipping 10 matching lines @@
 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>(
+      base::MakeUnique<cryptauth::EidDataWithTimestamp>(
           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>(
+      base::MakeUnique<cryptauth::EidDataWithTimestamp>(
           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]);
@@ skipping 10 matching lines @@
 
   // 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