Sending the time of the pingback request in the request

components/data_reduction_proxy/core/browser/data_reduction_proxy_pingback_client_unittest.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/data_reduction_proxy/core/browser/data_reduction_proxy_pingback_client.h"
 
 #include <memory>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 29 matching lines @@
 }  // namespace
 
 // Controls whether a pingback is sent or not.
 class TestDataReductionProxyPingbackClient
     : public DataReductionProxyPingbackClient {
  public:
   TestDataReductionProxyPingbackClient(
       net::URLRequestContextGetter* url_request_context_getter)
       : DataReductionProxyPingbackClient(url_request_context_getter),
         should_override_random_(false),
-        override_value_(0.0f) {}
+        override_value_(0.0f),
+        current_time_(base::Time::Now()) {}
 
+  // Overrides the bahvior of the random float generator in
+  // DataReductionProxyPingbackClient.
+  // If |should_override_random| is true, the typically random value that is
+  // compared with reporting fraction will deterministically be
+  // |override_value|.
   void OverrideRandom(bool should_override_random, float override_value) {
     should_override_random_ = should_override_random;
     override_value_ = override_value;
   }
 
+  // Sets the time used for the metrics reporting time.
+  void set_current_time(base::Time current_time) {
+    current_time_ = current_time;
+  }
+
  private:
   float GenerateRandomFloat() const override {
     if (should_override_random_)
       return override_value_;
     return DataReductionProxyPingbackClient::GenerateRandomFloat();
   }
 
+  base::Time CurrentTime() const override { return current_time_; }
+
   bool should_override_random_;
   float override_value_;
+  base::Time current_time_;
 };
 
 class DataReductionProxyPingbackClientTest : public testing::Test {
  public:
   DataReductionProxyPingbackClientTest()
       : timing_(base::Time::FromJsTime(1500),
                 base::Optional<base::TimeDelta>(
                     base::TimeDelta::FromMilliseconds(1600)),
                 base::Optional<base::TimeDelta>(
                     base::TimeDelta::FromMilliseconds(1700)),
@@ skipping 35 matching lines @@
   net::TestURLFetcherFactory factory_;
   DataReductionProxyPageLoadTiming timing_;
   base::HistogramTester histogram_tester_;
 };
 
 TEST_F(DataReductionProxyPingbackClientTest, VerifyPingbackContent) {
   Init();
   EXPECT_FALSE(factory()->GetFetcherByID(0));
   pingback_client()->OverrideRandom(true, 0.5f);
   pingback_client()->SetPingbackReportingFraction(1.0f);
+  base::Time current_time = base::Time::UnixEpoch();
+  pingback_client()->set_current_time(current_time);
   CreateAndSendPingback();
   histogram_tester().ExpectUniqueSample(kHistogramAttempted, true, 1);
   net::TestURLFetcher* test_fetcher = factory()->GetFetcherByID(0);
   EXPECT_EQ(test_fetcher->upload_content_type(), "application/x-protobuf");
   RecordPageloadMetricsRequest batched_request;
   batched_request.ParseFromString(test_fetcher->upload_data());
+  EXPECT_EQ(current_time, protobuf_parser::TimestampToTime(
+                              batched_request.metrics_sent_time()));
   PageloadMetrics pageload_metrics = batched_request.pageloads(0);
   EXPECT_EQ(
       timing().navigation_start,
       protobuf_parser::TimestampToTime(pageload_metrics.first_request_time()));
   EXPECT_EQ(timing().response_start.value(),
             protobuf_parser::DurationToTimeDelta(
                 pageload_metrics.time_to_first_byte()));
   EXPECT_EQ(
       timing().load_event_start.value(),
       protobuf_parser::DurationToTimeDelta(pageload_metrics.page_load_time()));
@@ skipping 99 matching lines @@
   net::TestURLFetcher* test_fetcher = factory()->GetFetcherByID(0);
   EXPECT_TRUE(test_fetcher);
   // Simulate a network error.
   test_fetcher->set_status(net::URLRequestStatus(
       net::URLRequestStatus::FAILED, net::ERR_INVALID_AUTH_CREDENTIALS));
   test_fetcher->delegate()->OnURLFetchComplete(test_fetcher);
   histogram_tester().ExpectUniqueSample(kHistogramSucceeded, false, 1);
 }
 
 }  // namespace data_reduction_proxy