network_time_tracker: add temporary time protocol.

components/network_time/network_time_tracker_unittest.cc

Index: components/network_time/network_time_tracker_unittest.cc
diff --git a/components/network_time/network_time_tracker_unittest.cc b/components/network_time/network_time_tracker_unittest.cc
index b42196cf0183b723eee4eacfd22071c2ca25ff5a..9a3c1818ad2be6699419a8374cc1a3bccf2a824a 100644
--- a/components/network_time/network_time_tracker_unittest.cc
+++ b/components/network_time/network_time_tracker_unittest.cc
@@ -7,10 +7,16 @@
 #include <memory>
 
 #include "base/compiler_specific.h"
+#include "base/message_loop/message_loop.h"
+#include "base/strings/stringprintf.h"
 #include "base/test/simple_test_clock.h"
 #include "base/test/simple_test_tick_clock.h"
+#include "components/client_update_protocol/ecdsa.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 {
@@ -20,6 +26,7 @@ class NetworkTimeTrackerTest : public testing::Test {
   ~NetworkTimeTrackerTest() override {}
 
   void SetUp() override {

[Ryan Sleevi, 2016/04/28 01:08:34]

Please see
https://github.com/google/googletest/blob/master/googletest/docs/FAQ.md#shoul...

Based on this code, I believe you should be fine moving it all into the
constructor, rather than the SetUp method.

[mab, 2016/04/28 02:29:04]

Done.

+    url_fetcher_factory_.reset(new net::TestURLFetcherFactory());
     NetworkTimeTracker::RegisterPrefs(pref_service_.registry());
 
     clock_ = new base::SimpleTestClock();
@@ -30,7 +37,8 @@ class NetworkTimeTrackerTest : public testing::Test {
 
     tracker_.reset(new NetworkTimeTracker(
         std::unique_ptr<base::Clock>(clock_),
-        std::unique_ptr<base::TickClock>(tick_clock_), &pref_service_));
+        std::unique_ptr<base::TickClock>(tick_clock_), &pref_service_,
+        new net::TestURLRequestContextGetter(message_loop_.task_runner())));

[Ryan Sleevi, 2016/04/28 01:08:34]

This means the TestURLRequestContextGetter is leaked, correct? Since you only
pass and store the raw pointer.

That's where changing to the scoped_refptr<> will help :)

[mab, 2016/04/28 02:29:04]

I guess leaks are not detected automatically by the test infrastructure. :-/ 
Done.

 
     // Can not be smaller than 15, it's the NowFromSystemTime() resolution.
     resolution_ = base::TimeDelta::FromMilliseconds(17);
@@ -49,7 +57,16 @@ class NetworkTimeTrackerTest : public testing::Test {
     tick_clock_= new_tick_clock;
     tracker_.reset(new NetworkTimeTracker(
         std::unique_ptr<base::Clock>(clock_),
-        std::unique_ptr<base::TickClock>(tick_clock_), &pref_service_));
+        std::unique_ptr<base::TickClock>(tick_clock_), &pref_service_,
+        new net::TestURLRequestContextGetter(message_loop_.task_runner())));
+  }
+
+  // Helper for verifying signatures over time server responses.  Sets the
+  // client's internal nonce, which is normally randomly generated, to a
+  // predictable value.
+  void OverrideNonce(uint32_t nonce) {
+    tracker_->query_signer_->request_query_cup2key_ =
+        base::StringPrintf("%d:%u", 1 /* key version */, nonce);
   }
 
   // Updates the notifier's time with the specified parameters.
@@ -69,6 +86,7 @@ class NetworkTimeTrackerTest : public testing::Test {
   }
 
  protected:
+  base::MessageLoop message_loop_;
   base::TimeDelta resolution_;
   base::TimeDelta latency_;
   base::TimeDelta adjustment_;
@@ -76,6 +94,7 @@ class NetworkTimeTrackerTest : public testing::Test {
   base::SimpleTestTickClock* tick_clock_;
   TestingPrefServiceSimple pref_service_;
   std::unique_ptr<NetworkTimeTracker> tracker_;
+  std::unique_ptr<net::TestURLFetcherFactory> url_fetcher_factory_;
 };
 
 TEST_F(NetworkTimeTrackerTest, Uninitialized) {
@@ -131,7 +150,7 @@ TEST_F(NetworkTimeTrackerTest, ClockIsWack) {
                     tick_clock_->NowTicks());
 
   base::Time out_network_time;
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL));
+  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr));
   EXPECT_EQ(in_network_time, out_network_time);
 }
 
@@ -185,7 +204,7 @@ TEST_F(NetworkTimeTrackerTest, SpringForward) {
   tick_clock_->Advance(base::TimeDelta::FromSeconds(1));
   clock_->Advance(base::TimeDelta::FromDays(1));
   base::Time out_network_time;
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL));
+  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
 }
 
 TEST_F(NetworkTimeTrackerTest, FallBack) {
@@ -195,7 +214,7 @@ TEST_F(NetworkTimeTrackerTest, FallBack) {
   tick_clock_->Advance(base::TimeDelta::FromSeconds(1));
   clock_->Advance(base::TimeDelta::FromDays(-1));
   base::Time out_network_time;
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL));
+  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
 }
 
 TEST_F(NetworkTimeTrackerTest, SuspendAndResume) {
@@ -205,7 +224,7 @@ TEST_F(NetworkTimeTrackerTest, SuspendAndResume) {
                     tick_clock_->NowTicks());
   clock_->Advance(base::TimeDelta::FromHours(1));
   base::Time out_network_time;
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL));
+  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
 }
 
 TEST_F(NetworkTimeTrackerTest, Serialize) {
@@ -237,7 +256,7 @@ TEST_F(NetworkTimeTrackerTest, DeserializeOldFormat) {
                     tick_clock_->NowTicks());
 
   base::Time out_network_time;
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL));
+  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr));
   double local, network;
   const base::DictionaryValue* saved_prefs =
       pref_service_.GetDictionary(prefs::kNetworkTimeMapping);
@@ -248,7 +267,7 @@ TEST_F(NetworkTimeTrackerTest, DeserializeOldFormat) {
   prefs.SetDouble("network", network);
   pref_service_.Set(prefs::kNetworkTimeMapping, prefs);
   Reset();
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL));
+  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
 }
 
 TEST_F(NetworkTimeTrackerTest, SerializeWithLongDelay) {
@@ -258,10 +277,10 @@ TEST_F(NetworkTimeTrackerTest, SerializeWithLongDelay) {
   UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_,
                     tick_clock_->NowTicks());
   base::Time out_network_time;
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL));
+  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr));
   AdvanceBoth(base::TimeDelta::FromDays(8));
   Reset();
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL));
+  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
 }
 
 TEST_F(NetworkTimeTrackerTest, SerializeWithTickClockAdvance) {
@@ -271,10 +290,10 @@ TEST_F(NetworkTimeTrackerTest, SerializeWithTickClockAdvance) {
   UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_,
                     tick_clock_->NowTicks());
   base::Time out_network_time;
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL));
+  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr));
   tick_clock_->Advance(base::TimeDelta::FromDays(1));
   Reset();
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL));
+  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
 }
 
 TEST_F(NetworkTimeTrackerTest, SerializeWithWallClockAdvance) {
@@ -285,10 +304,79 @@ TEST_F(NetworkTimeTrackerTest, SerializeWithWallClockAdvance) {
                     tick_clock_->NowTicks());
 
   base::Time out_network_time;
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL));
+  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr));
   clock_->Advance(base::TimeDelta::FromDays(1));
   Reset();
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL));
+  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+}
+
+TEST_F(NetworkTimeTrackerTest, UpdateFromNetwork) {
+  base::Time out_network_time;
+  EXPECT_EQ(nullptr, url_fetcher_factory_->GetFetcherByID(0));
+  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+
+  tracker_->QueryTimeService();
+  OverrideNonce(123123123);
+  net::TestURLFetcher* fetcher = url_fetcher_factory_->GetFetcherByID(0);
+  ASSERT_NE(nullptr, fetcher);
+  EXPECT_EQ("", fetcher->upload_data());
+
+  fetcher->set_response_code(200);
+  fetcher->SetResponseString(
+      ")]}'\n"
+      "{\"current_time_millis\":1461621971825,\"server_nonce\":-6."
+      "006853099049523E85}");
+
+  net::HttpResponseHeaders* headers = new net::HttpResponseHeaders("");

[Ryan Sleevi, 2016/04/28 01:08:34]

pedantry: For empty strings, std::string() avoids any dependencies on compiler
inlining and behaviours (namely, realizing it's strlen on a constant, that the
length is 0, then folding the branch that copies the string if size != 0 while
initializing the object)

[mab, 2016/04/28 02:29:04]

Done.

+  headers->AddHeader(
+      "x-cup-server-proof: "
+      "304402202e0f24db1ea69f1bbe81da4108f381fcf7a2781c53cf7663cb47083cb5fe8efd"
+      "022009d2b67c0deceaaf849f7c529be96701ed5f15d5efcaf401a94e0801accc9832:"
+      "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");

[Ryan Sleevi, 2016/04/28 01:08:34]

This proof is tied to the key used, right? Is it also tied to the response?

I'm just wondering whether it makes sense to put as a constant for easier
updating (if the key changes). But perhaps I'm dense.

[mab, 2016/04/28 02:29:04]

It is tied to the server's keypair, to the (overridden) request nonce above, and
to the response.  Honestly I don't think making it a constant is a huge help. 
My procedure here is pretty much: issue a query; copy the results.  But that's
worth documenting, so, did that.

+  fetcher->set_response_headers(headers);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(base::Time::UnixEpoch() +
+                base::TimeDelta::FromMilliseconds(1461621971825),
+            out_network_time);
+  EXPECT_TRUE(tracker_->query_timer_.IsRunning());
+}
+
+TEST_F(NetworkTimeTrackerTest, NoNetworkQueryWhileSynced) {
+  base::Time in_network_time = clock_->Now();
+  UpdateNetworkTime(in_network_time, resolution_, latency_,
+                    tick_clock_->NowTicks());
+
+  tracker_->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, nullptr));
+
+  tracker_->QueryTimeService();
+  OverrideNonce(123123123);
+  net::TestURLFetcher* fetcher = url_fetcher_factory_->GetFetcherByID(0);
+  ASSERT_NE(nullptr, fetcher);
+  EXPECT_EQ("", fetcher->upload_data());
+
+  fetcher->set_response_code(200);
+  fetcher->SetResponseString(
+      ")]}'\n"
+      "{\"current_time_millis\":1461621971825,\"server_nonce\":-6."
+      "006853099049523E85}");
+
+  net::HttpResponseHeaders* headers = new net::HttpResponseHeaders("");
+  headers->AddHeader("x-cup-server-proof: deadbeef:deadbeef");
+  fetcher->set_response_headers(headers);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_TRUE(tracker_->query_timer_.IsRunning());
 }
 
 }  // namespace network_time