Record the time when the interstitial is constructed

components/certificate_reporting/error_report_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/certificate_reporting/error_report.h"
 
 #include <set>
 #include <string>
 
 #include "base/files/file_path.h"
@@ skipping 110 matching lines @@
 TEST(ErrorReportTest, SerializedReportAsProtobufWithInterstitialInfo) {
   std::string serialized_report;
   SSLInfo ssl_info;
   // Use EXCLUDE_UNVERIFIED_CERT_CHAIN here to exercise the code path
   // where SSLInfo does not contain the unverified cert chain. (The test
   // above exercises the path where it does.)
   ASSERT_NO_FATAL_FAILURE(
       GetTestSSLInfo(EXCLUDE_UNVERIFIED_CERT_CHAIN, &ssl_info, kCertStatus));
   ErrorReport report(kDummyHostname, ssl_info);
 
-  report.SetInterstitialInfo(ErrorReport::INTERSTITIAL_CLOCK,
-                             ErrorReport::USER_PROCEEDED,
-                             ErrorReport::INTERSTITIAL_OVERRIDABLE);
+  const base::Time interstitial_time = base::Time::Now();
+  report.SetInterstitialInfo(
+      ErrorReport::INTERSTITIAL_CLOCK, ErrorReport::USER_PROCEEDED,
+      ErrorReport::INTERSTITIAL_OVERRIDABLE, interstitial_time);
 
   ASSERT_TRUE(report.Serialize(&serialized_report));
 
   CertLoggerRequest deserialized_report;
   ASSERT_TRUE(deserialized_report.ParseFromString(serialized_report));
   EXPECT_EQ(kDummyHostname, deserialized_report.hostname());
   EXPECT_EQ(GetPEMEncodedChain(), deserialized_report.cert_chain());
   EXPECT_EQ(std::string(), deserialized_report.unverified_cert_chain());
   EXPECT_EQ(1, deserialized_report.pin().size());
   EXPECT_EQ(kDummyFailureLog, deserialized_report.pin().Get(0));
 
   EXPECT_EQ(CertLoggerInterstitialInfo::INTERSTITIAL_CLOCK,
             deserialized_report.interstitial_info().interstitial_reason());
   EXPECT_EQ(true, deserialized_report.interstitial_info().user_proceeded());
   EXPECT_EQ(true, deserialized_report.interstitial_info().overridable());
   EXPECT_EQ(
       ssl_info.is_issued_by_known_root,
       deserialized_report.is_issued_by_known_root());
 
   EXPECT_THAT(
       deserialized_report.cert_error(),
       UnorderedElementsAre(kFirstReportedCertError, kSecondReportedCertError));
+
+  EXPECT_EQ(
+      interstitial_time.ToInternalValue(),
+      deserialized_report.interstitial_info().interstitial_created_time_usec());
 }
 
 // Test that a serialized report can be parsed.
 TEST(ErrorReportTest, ParseSerializedReport) {
   std::string serialized_report;
   SSLInfo ssl_info;
   ASSERT_NO_FATAL_FAILURE(
       GetTestSSLInfo(INCLUDE_UNVERIFIED_CERT_CHAIN, &ssl_info, kCertStatus));
   ErrorReport report(kDummyHostname, ssl_info);
   EXPECT_EQ(kDummyHostname, report.hostname());
@@ skipping 58 matching lines @@
   EXPECT_EQ(CertLoggerFeaturesInfo::NetworkTimeQueryingInfo::
                 NETWORK_TIME_FETCHES_ON_DEMAND_ONLY,
             parsed.features_info()
                 .network_time_querying_info()
                 .network_time_query_behavior());
 }
 
 }  // namespace
 
 }  // namespace certificate_reporting