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

components/cryptauth/background_eid_generator.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 "components/cryptauth/background_eid_generator.h"
 
 #include <cstring>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
@@ skipping 22 matching lines @@
     const std::vector<BeaconSeed>& beacon_seeds) {
   for (const BeaconSeed& seed : beacon_seeds) {
     if (timestamp_ms >= seed.start_time_millis() &&
         timestamp_ms <= seed.end_time_millis()) {
       return &seed;
     }
   }
   return nullptr;
 }
 
+// Given a list of |eids| and their respective |timestamps|, return a human
+// readable string for debugging.
+std::string EidsToDebugString(const std::vector<DataWithTimestamp>& eids) {

[Kyle Horimoto, 2017/04/30 03:17:43]

Can you make this a static function on DataWithTimestamp instead?

[Tim Song, 2017/05/01 22:23:38]

Done.

+  std::stringstream ss;
+  ss << "[";
+  for (const DataWithTimestamp& eid : eids) {
+    ss << "\n  (" << eid.start_timestamp_ms << ": " << eid.DataInHex() << "),";
+  }
+  ss << "\n]";
+  return ss.str();
+}
+
 }  // namespace
 
 BackgroundEidGenerator::BackgroundEidGenerator()
     : BackgroundEidGenerator(base::MakeUnique<RawEidGeneratorImpl>(),
                              base::MakeUnique<base::DefaultClock>()) {}
 
 BackgroundEidGenerator::~BackgroundEidGenerator() {}
 
 BackgroundEidGenerator::BackgroundEidGenerator(
     std::unique_ptr<RawEidGenerator> raw_eid_generator,
     std::unique_ptr<base::Clock> clock)
     : raw_eid_generator_(std::move(raw_eid_generator)),
       clock_(std::move(clock)) {}
 
-std::vector<std::string> BackgroundEidGenerator::GenerateNearestEids(
+std::vector<DataWithTimestamp> BackgroundEidGenerator::GenerateNearestEids(
     const std::vector<BeaconSeed>& beacon_seeds) const {
   int64_t now_timestamp_ms = clock_->Now().ToJavaTime();
-  std::vector<std::string> eids;
+  std::vector<DataWithTimestamp> eids;
 
-  PA_LOG(INFO) << "Generating EIDs:";
   for (int i = -kEidLookAhead; i <= kEidLookAhead; ++i) {
     int64_t timestamp_ms = now_timestamp_ms + i * kEidPeriodMs;
-    std::unique_ptr<std::string> eid = GenerateEid(timestamp_ms, beacon_seeds);
+    std::unique_ptr<DataWithTimestamp> eid =
+        GenerateEid(timestamp_ms, beacon_seeds);
     if (eid)
       eids.push_back(*eid);
   }
 
+  PA_LOG(INFO) << "Generated EIDs: " << EidsToDebugString(eids);
   return eids;
 }
 
-std::unique_ptr<std::string> BackgroundEidGenerator::GenerateEid(
+std::unique_ptr<DataWithTimestamp> BackgroundEidGenerator::GenerateEid(
     int64_t timestamp_ms,
     const std::vector<BeaconSeed>& beacon_seeds) const {
   const BeaconSeed* beacon_seed =
       GetBeaconSeedForTimestamp(timestamp_ms, beacon_seeds);
   if (!beacon_seed) {
     PA_LOG(INFO) << "  " << timestamp_ms << ": outside of BeaconSeed range.";
     return nullptr;
   }
 
   int64_t seed_start_time_ms = beacon_seed->start_time_millis();
   int64_t offset_time_ms = timestamp_ms - seed_start_time_ms;
   int64_t start_of_period_ms =
       seed_start_time_ms + (offset_time_ms / kEidPeriodMs) * kEidPeriodMs;
 
   std::string eid = raw_eid_generator_->GenerateEid(
       beacon_seed->data(), start_of_period_ms, nullptr);
 
-  PA_LOG(INFO) << "  " << start_of_period_ms << ": " << eid;
-  return base::MakeUnique<std::string>(eid);
+  return base::MakeUnique<DataWithTimestamp>(eid, start_of_period_ms,
+                                             start_of_period_ms + kEidPeriodMs);
 }
 
 }  // cryptauth