[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 41 matching lines @@
 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)) {}
 
@@ skipping 20 matching lines @@
   }
 
   std::unique_ptr<DataWithTimestamp> adjacent_eid =
       GenerateEidDataWithTimestamp(
           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<DataWithTimestamp>
 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 55 matching lines @@
                             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<DataWithTimestamp>
 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(
           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);
   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));
 }
 
-std::unique_ptr<ForegroundEidGenerator::DataWithTimestamp>
+std::unique_ptr<DataWithTimestamp>
 ForegroundEidGenerator::GenerateEidDataWithTimestamp(
     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);
 }
 
-std::unique_ptr<ForegroundEidGenerator::DataWithTimestamp>
+std::unique_ptr<DataWithTimestamp>
 ForegroundEidGenerator::GenerateEidDataWithTimestamp(
     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;
   }
@@ skipping 157 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