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

components/cryptauth/background_eid_generator_unittest.cc

 // Copyright 2017 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/background_eid_generator.h"
 
 #include <memory>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 30 matching lines @@
 BeaconSeed CreateBeaconSeed(const std::string& data,
                             const int64_t start_timestamp_ms,
                             const int64_t end_timestamp_ms) {
   BeaconSeed seed;
   seed.set_data(data);
   seed.set_start_time_millis(start_timestamp_ms);
   seed.set_end_time_millis(end_timestamp_ms);
   return seed;
 }
 
-std::string CreateEid(const std::string& eid_seed,
-                      int64_t start_of_period_timestamp_ms) {
-  return eid_seed + "|" + std::to_string(start_of_period_timestamp_ms);
+EidDataWithTimestamp CreateEid(const std::string& eid_seed,
+                               int64_t start_of_period_timestamp_ms) {
+  std::string data =
+      eid_seed + "|" + std::to_string(start_of_period_timestamp_ms);
+  return EidDataWithTimestamp(data, start_of_period_timestamp_ms,
+                              start_of_period_timestamp_ms + kEidPeriodMs);
 }
 
 class TestRawEidGenerator : public RawEidGenerator {
  public:
   TestRawEidGenerator() {}
   ~TestRawEidGenerator() override {}
 
   // RawEidGenerator:
   std::string GenerateEid(const std::string& eid_seed,
                           int64_t start_of_period_timestamp_ms,
                           std::string const* extra_entropy) override {
-    // ASSERT_FALSE(extra_entropy);
-    return CreateEid(eid_seed, start_of_period_timestamp_ms);
+    EXPECT_FALSE(extra_entropy);
+    return CreateEid(eid_seed, start_of_period_timestamp_ms).data;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestRawEidGenerator);
 };
 
 }  //  namespace
 
 class CryptAuthBackgroundEidGeneratorTest : public testing::Test {
  protected:
@@ skipping 27 matching lines @@
   }
 
   std::unique_ptr<BackgroundEidGenerator> eid_generator_;
   base::SimpleTestClock* test_clock_;
   std::vector<BeaconSeed> beacon_seeds_;
 };
 
 TEST_F(CryptAuthBackgroundEidGeneratorTest, BeaconSeedsExpired) {
   SetTestTime(beacon_seeds_[beacon_seeds_.size() - 1].end_time_millis() +
               kEidCount * kEidPeriodMs);
-  std::vector<std::string> eids =
+  std::vector<EidDataWithTimestamp> eids =
       eid_generator_->GenerateNearestEids(beacon_seeds_);
   EXPECT_EQ(0u, eids.size());
 }
 
 TEST_F(CryptAuthBackgroundEidGeneratorTest, BeaconSeedsValidInFuture) {
   SetTestTime(beacon_seeds_[0].start_time_millis() - kEidCount * kEidPeriodMs);
-  std::vector<std::string> eids =
+  std::vector<EidDataWithTimestamp> eids =
       eid_generator_->GenerateNearestEids(beacon_seeds_);
   EXPECT_EQ(0u, eids.size());
 }
 
 TEST_F(CryptAuthBackgroundEidGeneratorTest, EidsUseSameBeaconSeed) {
   int64_t start_period_ms =
       beacon_seeds_[0].start_time_millis() + kEidCount * kEidPeriodMs;
   SetTestTime(start_period_ms + kEidPeriodMs / 2);
 
-  std::vector<std::string> eids =
+  std::vector<EidDataWithTimestamp> eids =
       eid_generator_->GenerateNearestEids(beacon_seeds_);
 
   std::string seed = beacon_seeds_[0].data();
   EXPECT_EQ(kEidCount, eids.size());
   EXPECT_EQ(CreateEid(seed, start_period_ms - 2 * kEidPeriodMs), eids[0]);
   EXPECT_EQ(CreateEid(seed, start_period_ms - 1 * kEidPeriodMs), eids[1]);
   EXPECT_EQ(CreateEid(seed, start_period_ms + 0 * kEidPeriodMs), eids[2]);
   EXPECT_EQ(CreateEid(seed, start_period_ms + 1 * kEidPeriodMs), eids[3]);
   EXPECT_EQ(CreateEid(seed, start_period_ms + 2 * kEidPeriodMs), eids[4]);
 }
 
 TEST_F(CryptAuthBackgroundEidGeneratorTest, EidsAcrossBeaconSeeds) {
   int64_t end_period_ms = beacon_seeds_[0].end_time_millis();
   int64_t start_period_ms = beacon_seeds_[1].start_time_millis();
   SetTestTime(start_period_ms + kEidPeriodMs / 2);
 
-  std::vector<std::string> eids =
+  std::vector<EidDataWithTimestamp> eids =
       eid_generator_->GenerateNearestEids(beacon_seeds_);
 
   std::string seed0 = beacon_seeds_[0].data();
   std::string seed1 = beacon_seeds_[1].data();
   EXPECT_EQ(kEidCount, eids.size());
   EXPECT_EQ(CreateEid(seed0, end_period_ms - 2 * kEidPeriodMs), eids[0]);
   EXPECT_EQ(CreateEid(seed0, end_period_ms - 1 * kEidPeriodMs), eids[1]);
   EXPECT_EQ(CreateEid(seed1, start_period_ms + 0 * kEidPeriodMs), eids[2]);
   EXPECT_EQ(CreateEid(seed1, start_period_ms + 1 * kEidPeriodMs), eids[3]);
   EXPECT_EQ(CreateEid(seed1, start_period_ms + 2 * kEidPeriodMs), eids[4]);
 }
 
 TEST_F(CryptAuthBackgroundEidGeneratorTest, CurrentTimeAtStartOfRange) {
   int64_t start_period_ms = beacon_seeds_[0].start_time_millis();
   SetTestTime(start_period_ms + kEidPeriodMs / 2);
 
-  std::vector<std::string> eids =
+  std::vector<EidDataWithTimestamp> eids =
       eid_generator_->GenerateNearestEids(beacon_seeds_);
 
   std::string seed = beacon_seeds_[0].data();
   EXPECT_EQ(3u, eids.size());
   EXPECT_EQ(CreateEid(seed, start_period_ms + 0 * kEidPeriodMs), eids[0]);
   EXPECT_EQ(CreateEid(seed, start_period_ms + 1 * kEidPeriodMs), eids[1]);
   EXPECT_EQ(CreateEid(seed, start_period_ms + 2 * kEidPeriodMs), eids[2]);
 }
 
 TEST_F(CryptAuthBackgroundEidGeneratorTest, CurrentTimeAtEndOfRange) {
   int64_t start_period_ms = beacon_seeds_[3].end_time_millis() - kEidPeriodMs;
   SetTestTime(start_period_ms + kEidPeriodMs / 2);
 
-  std::vector<std::string> eids =
+  std::vector<EidDataWithTimestamp> eids =
       eid_generator_->GenerateNearestEids(beacon_seeds_);
 
   std::string seed = beacon_seeds_[3].data();
   EXPECT_EQ(3u, eids.size());
   EXPECT_EQ(CreateEid(seed, start_period_ms - 2 * kEidPeriodMs), eids[0]);
   EXPECT_EQ(CreateEid(seed, start_period_ms - 1 * kEidPeriodMs), eids[1]);
   EXPECT_EQ(CreateEid(seed, start_period_ms - 0 * kEidPeriodMs), eids[2]);
 }
 
 }  // namespace cryptauth