network_time_tracker: add temporary time protocol.

components/network_time/network_time_tracker_unittest.cc

 // Copyright 2014 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/network_time/network_time_tracker.h"
 
 #include "base/compiler_specific.h"
+#include "base/message_loop/message_loop.h"
 #include "base/test/simple_test_clock.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "components/network_time/network_time_pref_names.h"
 #include "components/prefs/testing_pref_service.h"
+#include "net/http/http_response_headers.h"
+#include "net/url_request/test_url_fetcher_factory.h"
+#include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace network_time {
 
+struct NetworkTimeTrackerPeer {

[estark, 2016/03/28 17:35:10]

I haven't seen this pattern before. FRIEND_TEST_ALL_PREFIXES is more common in
Chromium, though maybe you're trying to avoid enumerating all the tests that
need to be friended?

(If you end up sticking with this pattern, maybe name it
NetworkTimeTrackerPeerForTesting or something to indicate that it's designed for
testing; I was confused about this when reading the header file.)

[mab, 2016/03/28 19:56:26]

No, no, I just wasn't aware of the standard pattern.  Thanks.  Fixed.

+  void QueryTimeService() { tracker_->QueryTimeService(); }
+
+  bool TimerIsRunning() { return tracker_->query_timer_.IsRunning(); }
+
+  NetworkTimeTracker* tracker_;
+};
+
 class NetworkTimeTrackerTest : public testing::Test {
  public:
   ~NetworkTimeTrackerTest() override {}
 
   void SetUp() override {
+    url_fetcher_factory_.reset(new net::TestURLFetcherFactory());
     NetworkTimeTracker::RegisterPrefs(pref_service_.registry());
 
     clock_ = new base::SimpleTestClock();
     tick_clock_ = new base::SimpleTestTickClock();
     // Do this to be sure that |is_null| returns false.
     clock_->Advance(base::TimeDelta::FromDays(111));
     tick_clock_->Advance(base::TimeDelta::FromDays(222));
 
     tracker_.reset(new NetworkTimeTracker(
         scoped_ptr<base::Clock>(clock_),
-        scoped_ptr<base::TickClock>(tick_clock_),
-        &pref_service_));
+        scoped_ptr<base::TickClock>(tick_clock_), &pref_service_,
+        new net::TestURLRequestContextGetter(message_loop_.task_runner())));
+    peer_.tracker_ = tracker_.get();
 
     // Can not be smaller than 15, it's the NowFromSystemTime() resolution.
     resolution_ = base::TimeDelta::FromMilliseconds(17);
     latency_ = base::TimeDelta::FromMilliseconds(50);
     adjustment_ = 7 * base::TimeDelta::FromMilliseconds(kTicksResolutionMs);
   }
 
   // Replaces |tracker_| with a new object, while preserving the
   // testing clocks.
   void Reset() {
     base::SimpleTestClock* new_clock = new base::SimpleTestClock();
     new_clock->SetNow(clock_->Now());
     base::SimpleTestTickClock* new_tick_clock = new base::SimpleTestTickClock();
     new_tick_clock->SetNowTicks(tick_clock_->NowTicks());
     clock_ = new_clock;
     tick_clock_= new_tick_clock;
     tracker_.reset(new NetworkTimeTracker(
         scoped_ptr<base::Clock>(clock_),
-        scoped_ptr<base::TickClock>(tick_clock_),
-        &pref_service_));
+        scoped_ptr<base::TickClock>(tick_clock_), &pref_service_,
+        new net::TestURLRequestContextGetter(message_loop_.task_runner())));
+    peer_.tracker_ = tracker_.get();
   }
 
   // Updates the notifier's time with the specified parameters.
   void UpdateNetworkTime(const base::Time& network_time,
                          const base::TimeDelta& resolution,
                          const base::TimeDelta& latency,
                          const base::TimeTicks& post_time) {
     tracker_->UpdateNetworkTime(
         network_time, resolution, latency, post_time);
   }
 
   // Advances both the system clock and the tick clock.  This should be used for
   // the normal passage of time, i.e. when neither clock is doing anything odd.
   void AdvanceBoth(const base::TimeDelta& delta) {
     tick_clock_->Advance(delta);
     clock_->Advance(delta);
   }
 
  protected:
+  base::MessageLoop message_loop_;
   base::TimeDelta resolution_;
   base::TimeDelta latency_;
   base::TimeDelta adjustment_;
   base::SimpleTestClock* clock_;
   base::SimpleTestTickClock* tick_clock_;
   TestingPrefServiceSimple pref_service_;
   scoped_ptr<NetworkTimeTracker> tracker_;
+  scoped_ptr<net::TestURLFetcherFactory> url_fetcher_factory_;
+  NetworkTimeTrackerPeer peer_;
 };
 
 TEST_F(NetworkTimeTrackerTest, Uninitialized) {
   base::Time network_time;
   base::TimeDelta uncertainty;
   EXPECT_FALSE(tracker_->GetNetworkTime(&network_time, &uncertainty));
 }
 
 TEST_F(NetworkTimeTrackerTest, LongPostingDelay) {
   // The request arrives at the server, which records the time.  Advance the
@@ skipping 195 matching lines @@
   UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_,
                     tick_clock_->NowTicks());
 
   base::Time out_network_time;
   EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL));
   clock_->Advance(base::TimeDelta::FromDays(1));
   Reset();
   EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL));
 }
 
+TEST_F(NetworkTimeTrackerTest, UpdateFromNetwork) {
+  base::Time out_network_time;
+  EXPECT_EQ(nullptr, url_fetcher_factory_->GetFetcherByID(0));
+  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL));

[estark, 2016/03/28 17:35:10]

nullptr instead of NULL

[mab, 2016/03/28 19:56:26]

Done.

+
+  peer_.QueryTimeService();
+  net::TestURLFetcher* fetcher = url_fetcher_factory_->GetFetcherByID(0);
+  EXPECT_NE(nullptr, fetcher);

[estark, 2016/03/28 17:35:10]

ASSERT_NE (if this fails, the test should be aborted)

[mab, 2016/03/28 19:56:26]

Done.

+  EXPECT_EQ("", fetcher->upload_data());
+
+  fetcher->set_response_code(200);
+  fetcher->SetResponseString(
+      "{\"current_time_millis\":1458939575214,\"server_nonce\":8."
+      "18927404567873E115}");
+  fetcher->set_response_headers(new net::HttpResponseHeaders(
+      "x-cup-server-proof: "
+      "304402206f29b656ee23aafc7b6df4cfaa3bf711018cca2cbdbcb366932ae4433286f1f6"
+      "022061ddbd4a6ea0d5d36b9f3a6c2a37b5ba4b5f42065f93cda5ed5e5fb60419bb81:"
+      "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\n"
+      "ETag: "
+      "W/"
+      "\"304402206f29b656ee23aafc7b6df4cfaa3bf711018cca2cbdbcb366932ae4433286f1"
+      "f6022061ddbd4a6ea0d5d36b9f3a6c2a37b5ba4b5f42065f93cda5ed5e5fb60419bb81:"
+      "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\"\n"));
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL));
+  EXPECT_EQ(base::Time::UnixEpoch() +
+                base::TimeDelta::FromMilliseconds(1458939575214),
+            out_network_time);
+  EXPECT_TRUE(peer_.TimerIsRunning());
+}
+
+TEST_F(NetworkTimeTrackerTest, NoNetworkQueryWhileSynced) {
+  base::Time in_network_time = clock_->Now();
+  UpdateNetworkTime(in_network_time, resolution_, latency_,
+                    tick_clock_->NowTicks());
+
+  peer_.QueryTimeService();
+  net::TestURLFetcher* fetcher = url_fetcher_factory_->GetFetcherByID(0);
+  EXPECT_EQ(nullptr, fetcher);  // No query should be started.
+}
+
+TEST_F(NetworkTimeTrackerTest, UpdateFromNetworkBadSignature) {
+  base::Time out_network_time;
+  EXPECT_EQ(nullptr, url_fetcher_factory_->GetFetcherByID(0));
+  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL));
+
+  peer_.QueryTimeService();
+  net::TestURLFetcher* fetcher = url_fetcher_factory_->GetFetcherByID(0);
+  EXPECT_NE(nullptr, fetcher);

[estark, 2016/03/28 17:35:10]

ASSERT_NE

[mab, 2016/03/28 19:56:26]

Done.

+  EXPECT_EQ("", fetcher->upload_data());
+
+  fetcher->set_response_code(200);
+  fetcher->SetResponseString(
+      "{\"current_time_millis\":1458939575214,\"server_nonce\":8."
+      "18927404567873E115}");
+  fetcher->set_response_headers(new net::HttpResponseHeaders(
+      "x-cup-server-proof: "
+      "304402206f29b656ee23aafc7b6df4cfaa3bf711018cca2cbdbcb366932ae4433286f1f6"
+      "022061ddbd4a6ea0d5d36b9f3a6c2a37b5ba4b5f42065f93cda5ed5e5fb60419bb81:"
+      "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\n"
+      "ETag: "
+      "W/"
+      "\"304402206f29b656ee23aafc7b6df4cfaa3bf711018cca2cbdbcb366932ae4433286f1"
+      "f6022061ddbd4a6ea0d5d36b9f3a6c2a37b5ba4b5f42065f93cda5ed5e5fb60419bb81:"
+      "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\"\n"));
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL));
+  EXPECT_TRUE(peer_.TimerIsRunning());
+}
+
 }  // namespace network_time