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

components/cryptauth/foreground_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/foreground_eid_generator.h"
 
 #include <cstring>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
@@ skipping 12 matching lines @@
 const int64_t kMaxPositiveInt64TValue = 0x7FFFFFFF;
 }  // namespace
 
 const int64_t ForegroundEidGenerator::kNumMsInEidPeriod =
     base::TimeDelta::FromHours(8).InMilliseconds();
 const int64_t ForegroundEidGenerator::kNumMsInBeginningOfEidPeriod =
     base::TimeDelta::FromHours(2).InMilliseconds();
 const int8_t ForegroundEidGenerator::kBluetooth4Flag = 0x01;
 
 ForegroundEidGenerator::EidData::EidData(
-    const DataWithTimestamp current_data,
-    std::unique_ptr<DataWithTimestamp> adjacent_data)
+    const EidDataWithTimestamp current_data,
+    std::unique_ptr<EidDataWithTimestamp> adjacent_data)
     : current_data(current_data), adjacent_data(std::move(adjacent_data)) {}
 
 ForegroundEidGenerator::EidData::~EidData() {}
 
 ForegroundEidGenerator::EidData::AdjacentDataType
 ForegroundEidGenerator::EidData::GetAdjacentDataType() const {
   if (!adjacent_data) {
     return AdjacentDataType::NONE;
   }
 
   if (adjacent_data->start_timestamp_ms < current_data.start_timestamp_ms) {
     return AdjacentDataType::PAST;
   }
 
   return AdjacentDataType::FUTURE;
 }
 
 std::string ForegroundEidGenerator::EidData::DataInHex() const {
   std::string str = "[" + current_data.DataInHex();
 
   if (adjacent_data) {
     return str + ", " + adjacent_data->DataInHex() + "]";
   }
 
   return str + "]";
 }
 
-ForegroundEidGenerator::DataWithTimestamp::DataWithTimestamp(
-    const std::string& data,
-    const int64_t start_timestamp_ms,
-    const int64_t end_timestamp_ms)
-    : data(data),
-      start_timestamp_ms(start_timestamp_ms),
-      end_timestamp_ms(end_timestamp_ms) {
-  DCHECK(start_timestamp_ms < end_timestamp_ms);
-  DCHECK(data.size());
-}
-
-ForegroundEidGenerator::DataWithTimestamp::DataWithTimestamp(
-    const DataWithTimestamp& other)
-    : data(other.data),
-      start_timestamp_ms(other.start_timestamp_ms),
-      end_timestamp_ms(other.end_timestamp_ms) {
-  DCHECK(start_timestamp_ms < end_timestamp_ms);
-  DCHECK(data.size());
-}
-
-bool ForegroundEidGenerator::DataWithTimestamp::ContainsTime(
-    const int64_t timestamp_ms) const {
-  return start_timestamp_ms <= timestamp_ms && timestamp_ms < end_timestamp_ms;
-}
-
-std::string ForegroundEidGenerator::DataWithTimestamp::DataInHex() const {
-  std::stringstream ss;
-  ss << "0x" << std::hex;
-
-  for (size_t i = 0; i < data.size(); i++) {
-    ss << static_cast<int>(data.data()[i]);
-  }
-
-  return ss.str();
-}
-
 ForegroundEidGenerator::ForegroundEidGenerator()
     : ForegroundEidGenerator(base::MakeUnique<RawEidGeneratorImpl>(),
                              base::MakeUnique<base::DefaultClock>()) {}
 
 ForegroundEidGenerator::ForegroundEidGenerator(
     std::unique_ptr<RawEidGenerator> raw_eid_generator,
     std::unique_ptr<base::Clock> clock)
     : clock_(std::move(clock)),
       raw_eid_generator_(std::move(raw_eid_generator)) {}
 
 ForegroundEidGenerator::~ForegroundEidGenerator() {}
 
 std::unique_ptr<ForegroundEidGenerator::EidData>
 ForegroundEidGenerator::GenerateBackgroundScanFilter(
     const std::vector<BeaconSeed>& scanning_device_beacon_seeds) const {
   std::unique_ptr<EidPeriodTimestamps> timestamps =
       GetEidPeriodTimestamps(scanning_device_beacon_seeds);
   if (!timestamps) {
     // If the device does not have seeds for the correct period, no EIDs can be
     // generated.
     return nullptr;
   }
 
-  std::unique_ptr<DataWithTimestamp> current_eid = GenerateEidDataWithTimestamp(
-      scanning_device_beacon_seeds,
-      timestamps->current_period_start_timestamp_ms,
-      timestamps->current_period_end_timestamp_ms);
+  std::unique_ptr<EidDataWithTimestamp> current_eid =
+      GenerateEidEidDataWithTimestamp(
+          scanning_device_beacon_seeds,
+          timestamps->current_period_start_timestamp_ms,
+          timestamps->current_period_end_timestamp_ms);
   if (!current_eid) {
     // The current EID could not be generated.
     return nullptr;
   }
 
-  std::unique_ptr<DataWithTimestamp> adjacent_eid =
-      GenerateEidDataWithTimestamp(
+  std::unique_ptr<EidDataWithTimestamp> adjacent_eid =
+      GenerateEidEidDataWithTimestamp(
           scanning_device_beacon_seeds,
           timestamps->adjacent_period_start_timestamp_ms,
           timestamps->adjacent_period_end_timestamp_ms);
   return base::WrapUnique(new EidData(*current_eid, std::move(adjacent_eid)));
 }
 
-std::unique_ptr<ForegroundEidGenerator::DataWithTimestamp>
+std::unique_ptr<EidDataWithTimestamp>
 ForegroundEidGenerator::GenerateAdvertisement(
     const std::string& advertising_device_public_key,
     const std::vector<BeaconSeed>& scanning_device_beacon_seeds) const {
   std::unique_ptr<EidPeriodTimestamps> timestamps =
       GetEidPeriodTimestamps(scanning_device_beacon_seeds);
   if (!timestamps) {
     return nullptr;
   }
 
   return GenerateAdvertisement(advertising_device_public_key,
@@ skipping 33 matching lines @@
 
   std::unique_ptr<EidPeriodTimestamps> timestamps =
       GetEidPeriodTimestamps(scanning_device_beacon_seeds, true);
   if (!timestamps) {
     // If the devices do not have seeds for the correct period, no
     // advertisements can be generated.
     return possible_advertisements;
   }
 
   if (timestamps->current_period_start_timestamp_ms != kNoTimestamp) {
-    std::unique_ptr<DataWithTimestamp> current_advertisement =
+    std::unique_ptr<EidDataWithTimestamp> current_advertisement =
         GenerateAdvertisement(advertising_device_public_key,
                               scanning_device_beacon_seeds,
                               timestamps->current_period_start_timestamp_ms,
                               timestamps->current_period_end_timestamp_ms);
     if (current_advertisement) {
       possible_advertisements.push_back(current_advertisement->data);
     }
   }
 
-  std::unique_ptr<DataWithTimestamp> adjacent_advertisement =
+  std::unique_ptr<EidDataWithTimestamp> adjacent_advertisement =
       GenerateAdvertisement(advertising_device_public_key,
                             scanning_device_beacon_seeds,
                             timestamps->adjacent_period_start_timestamp_ms,
                             timestamps->adjacent_period_end_timestamp_ms);
   if (adjacent_advertisement) {
     possible_advertisements.push_back(adjacent_advertisement->data);
   }
 
   return possible_advertisements;
 }
 
-std::unique_ptr<ForegroundEidGenerator::DataWithTimestamp>
+std::unique_ptr<EidDataWithTimestamp>
 ForegroundEidGenerator::GenerateAdvertisement(
     const std::string& advertising_device_public_key,
     const std::vector<BeaconSeed>& scanning_device_beacon_seeds,
     const int64_t start_of_period_timestamp_ms,
     const int64_t end_of_period_timestamp_ms) const {
-  std::unique_ptr<DataWithTimestamp> advertising_device_identifying_data =
-      GenerateEidDataWithTimestamp(
+  std::unique_ptr<EidDataWithTimestamp> advertising_device_identifying_data =
+      GenerateEidEidDataWithTimestamp(
           scanning_device_beacon_seeds, start_of_period_timestamp_ms,
           end_of_period_timestamp_ms, &advertising_device_public_key);
-  std::unique_ptr<DataWithTimestamp> scanning_device_identifying_data =
-      GenerateEidDataWithTimestamp(scanning_device_beacon_seeds,
-                                   start_of_period_timestamp_ms,
-                                   end_of_period_timestamp_ms);
+  std::unique_ptr<EidDataWithTimestamp> scanning_device_identifying_data =
+      GenerateEidEidDataWithTimestamp(scanning_device_beacon_seeds,
+                                      start_of_period_timestamp_ms,
+                                      end_of_period_timestamp_ms);
   if (!advertising_device_identifying_data ||
       !scanning_device_identifying_data) {
     return nullptr;
   }
 
   std::string full_advertisement = scanning_device_identifying_data->data +
                                    advertising_device_identifying_data->data;
-  return base::WrapUnique(new DataWithTimestamp(full_advertisement,
-                                                start_of_period_timestamp_ms,
-                                                end_of_period_timestamp_ms));
+  return base::WrapUnique(new EidDataWithTimestamp(full_advertisement,
+                                                   start_of_period_timestamp_ms,
+                                                   end_of_period_timestamp_ms));
 }
 
-std::unique_ptr<ForegroundEidGenerator::DataWithTimestamp>
-ForegroundEidGenerator::GenerateEidDataWithTimestamp(
+std::unique_ptr<EidDataWithTimestamp>
+ForegroundEidGenerator::GenerateEidEidDataWithTimestamp(
     const std::vector<BeaconSeed>& scanning_device_beacon_seeds,
     const int64_t start_of_period_timestamp_ms,
     const int64_t end_of_period_timestamp_ms) const {
-  return GenerateEidDataWithTimestamp(scanning_device_beacon_seeds,
-                                      start_of_period_timestamp_ms,
-                                      end_of_period_timestamp_ms, nullptr);
+  return GenerateEidEidDataWithTimestamp(scanning_device_beacon_seeds,
+                                         start_of_period_timestamp_ms,
+                                         end_of_period_timestamp_ms, nullptr);
 }
 
-std::unique_ptr<ForegroundEidGenerator::DataWithTimestamp>
-ForegroundEidGenerator::GenerateEidDataWithTimestamp(
+std::unique_ptr<EidDataWithTimestamp>
+ForegroundEidGenerator::GenerateEidEidDataWithTimestamp(
     const std::vector<BeaconSeed>& scanning_device_beacon_seeds,
     const int64_t start_of_period_timestamp_ms,
     const int64_t end_of_period_timestamp_ms,
     std::string const* extra_entropy) const {
   std::unique_ptr<std::string> eid_seed = GetEidSeedForPeriod(
       scanning_device_beacon_seeds, start_of_period_timestamp_ms);
   if (!eid_seed) {
     return nullptr;
   }
 
   std::string eid_data = raw_eid_generator_->GenerateEid(
       *eid_seed, start_of_period_timestamp_ms, extra_entropy);
 
-  return base::WrapUnique(new DataWithTimestamp(
+  return base::WrapUnique(new EidDataWithTimestamp(
       eid_data, start_of_period_timestamp_ms, end_of_period_timestamp_ms));
 }
 
 std::unique_ptr<std::string> ForegroundEidGenerator::GetEidSeedForPeriod(
     const std::vector<BeaconSeed>& scanning_device_beacon_seeds,
     const int64_t start_of_period_timestamp_ms) const {
   for (auto seed : scanning_device_beacon_seeds) {
     if (seed.start_time_millis() <= start_of_period_timestamp_ms &&
         start_of_period_timestamp_ms < seed.end_time_millis()) {
       return base::WrapUnique(new std::string(seed.data()));
@@ skipping 142 matching lines @@
     const int64_t end_of_period_timestamp_ms,
     const int64_t current_timestamp_ms) {
   DCHECK(start_of_period_timestamp_ms <= current_timestamp_ms);
   DCHECK(current_timestamp_ms < end_of_period_timestamp_ms);
 
   return current_timestamp_ms <
          start_of_period_timestamp_ms + kNumMsInBeginningOfEidPeriod;
 }
 
 }  // namespace cryptauth