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

components/cryptauth/foreground_eid_generator_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/cryptauth/foreground_eid_generator.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 341 matching lines @@
             data->adjacent_data->start_timestamp_ms);
   EXPECT_EQ(kDefaultCurrentPeriodStart, data->adjacent_data->end_timestamp_ms);
   // Since this uses the real RawEidGenerator, just make sure the data
   // exists and has the proper length.
   EXPECT_EQ((size_t)kNumBytesInEidValue, data->adjacent_data->data.length());
 }
 
 TEST_F(CryptAuthForegroundEidGeneratorTest, GenerateAdvertisementData) {
   SetTestTime(kDefaultCurrentTime);
 
-  std::unique_ptr<ForegroundEidGenerator::DataWithTimestamp> data =
+  std::unique_ptr<EidDataWithTimestamp> data =
       eid_generator_->GenerateAdvertisement(kDefaultAdvertisingDevicePublicKey,
                                             scanning_device_beacon_seeds_);
   ASSERT_TRUE(data);
 
   EXPECT_EQ(kDefaultCurrentPeriodStart, data->start_timestamp_ms);
   EXPECT_EQ(kDefaultCurrentPeriodStart + kNumMsInEidPeriod,
             data->end_timestamp_ms);
   EXPECT_EQ(GenerateFakeAdvertisement(kSecondSeed, kDefaultCurrentPeriodStart,
                                       kDefaultAdvertisingDevicePublicKey),
             data->data);
 }
 
 TEST_F(CryptAuthForegroundEidGeneratorTest,
        GenerateAdvertisementData_NoSeedForPeriod) {
   SetTestTime(kDefaultCurrentTime + 4 * kNumMsInEidSeedPeriod);
 
-  std::unique_ptr<ForegroundEidGenerator::DataWithTimestamp> data =
+  std::unique_ptr<EidDataWithTimestamp> data =
       eid_generator_->GenerateAdvertisement(kDefaultAdvertisingDevicePublicKey,
                                             scanning_device_beacon_seeds_);
   EXPECT_FALSE(data);
 }
 
 TEST_F(CryptAuthForegroundEidGeneratorTest,
        GenerateAdvertisementData_EmptySeeds) {
   SetTestTime(kDefaultCurrentTime + 4 * kNumMsInEidSeedPeriod);
 
   std::vector<BeaconSeed> empty;
-  std::unique_ptr<ForegroundEidGenerator::DataWithTimestamp> data =
+  std::unique_ptr<EidDataWithTimestamp> data =
       eid_generator_->GenerateAdvertisement(kDefaultAdvertisingDevicePublicKey,
                                             empty);
   EXPECT_FALSE(data);
 }
 
 TEST_F(CryptAuthForegroundEidGeneratorTest,
        GeneratePossibleAdvertisements_CurrentAndPastAdjacentPeriods) {
   SetTestTime(kDefaultCurrentPeriodStart);
 
   std::vector<std::string> possible_advertisements =
@@ skipping 228 matching lines @@
                                 kDefaultAdvertisingDevicePublicKey);
 
   RemoteDevice wrong_device = CreateRemoteDevice("wrongPublicKey");
   std::vector<RemoteDevice> device_list = {wrong_device, wrong_device};
   const RemoteDevice* identified_device =
       eid_generator_->IdentifyRemoteDeviceByAdvertisement(
           service_data, device_list, scanning_device_beacon_seeds_);
   EXPECT_FALSE(identified_device);
 }
 
-TEST_F(CryptAuthForegroundEidGeneratorTest, DataWithTimestamp_ContainsTime) {
-  ForegroundEidGenerator::DataWithTimestamp data_with_timestamp(
-      "data", /* start */ 1000L, /* end */ 2000L);
+TEST_F(CryptAuthForegroundEidGeneratorTest, EidDataWithTimestamp_ContainsTime) {
+  EidDataWithTimestamp data_with_timestamp("data", /* start */ 1000L,
+                                           /* end */ 2000L);
   EXPECT_FALSE(data_with_timestamp.ContainsTime(999L));
   EXPECT_TRUE(data_with_timestamp.ContainsTime(1000L));
   EXPECT_TRUE(data_with_timestamp.ContainsTime(1500L));
   EXPECT_TRUE(data_with_timestamp.ContainsTime(1999L));
   EXPECT_FALSE(data_with_timestamp.ContainsTime(2000L));
 }
 
 }  // namespace cryptauth