Change http_server_properties_manager to always persist data to memory after 1s

net/http/http_server_properties_manager_unittest.cc

Index: net/http/http_server_properties_manager_unittest.cc
diff --git a/net/http/http_server_properties_manager_unittest.cc b/net/http/http_server_properties_manager_unittest.cc
index b2f11528bdb6a81c88f45554792ea29b474bff37..0d6747ba2d668cceff422a9b04dd653613ea78e1 100644
--- a/net/http/http_server_properties_manager_unittest.cc
+++ b/net/http/http_server_properties_manager_unittest.cc
@@ -85,7 +85,8 @@ class TestingHttpServerPropertiesManager : public HttpServerPropertiesManager {
       : HttpServerPropertiesManager(pref_delegate,
                                     pref_task_runner,
                                     net_task_runner),
-        pref_update_delay_(base::TimeDelta()) {
+        pref_update_delay_(base::TimeDelta()),
+        cache_update_delay_(base::TimeDelta()) {
     InitializeOnNetworkThread();
   }
 
@@ -107,7 +108,7 @@ class TestingHttpServerPropertiesManager : public HttpServerPropertiesManager {
   // Post tasks without a delay during tests.
   void StartCacheUpdateTimerOnPrefThread(base::TimeDelta delay) override {
     HttpServerPropertiesManager::StartCacheUpdateTimerOnPrefThread(
-        base::TimeDelta());
+        cache_update_delay_);
   }
 
   void UpdatePrefsFromCacheOnNetworkThreadConcrete(
@@ -128,6 +129,9 @@ class TestingHttpServerPropertiesManager : public HttpServerPropertiesManager {
   void set_pref_update_delay(base::TimeDelta delay) {
     pref_update_delay_ = delay;
   }
+  void set_cache_update_delay(base::TimeDelta delay) {
+    cache_update_delay_ = delay;
+  }
   MOCK_METHOD0(UpdateCacheFromPrefsOnPrefThread, void());
   MOCK_METHOD1(UpdatePrefsFromCacheOnNetworkThread, void(const base::Closure&));
   MOCK_METHOD1(ScheduleUpdatePrefsOnNetworkThread, void(Location location));
@@ -149,6 +153,7 @@ class TestingHttpServerPropertiesManager : public HttpServerPropertiesManager {
  private:
   // Time delays used in test for posting tasks. Default to zero.
   base::TimeDelta pref_update_delay_;
+  base::TimeDelta cache_update_delay_;
   DISALLOW_COPY_AND_ASSIGN(TestingHttpServerPropertiesManager);
 };
 
@@ -1200,6 +1205,44 @@ TEST_P(HttpServerPropertiesManagerTest, UpdateCacheWithPrefs) {
   EXPECT_EQ(expected_json, preferences_json);
 }
 
+TEST_P(HttpServerPropertiesManagerTest,
+       SingleCacheUpdateForMultipleUpdatesScheduled) {
+  http_server_props_manager_->set_cache_update_delay(
+      base::TimeDelta::FromMilliseconds(60));
+
+  // Update cache.
+  ExpectCacheUpdate();

[xunjieli, 2016/12/20 14:00:27]

I guess you are doing a follow-up to make sure that there are 3 scheduled tasks
and 2 actual updates? (just like you did for pref?)

[Zhongyi Shi, 2016/12/20 20:03:38]

If you take a close look on the previous CL, we check the number of calls of
ScheduleUpdatePrefsOnNetworkThread vs UpdatePrefsFromCacheOnNetworkThread.
That's because we invoke ScheduleUpdatePrefsOnNetworkThread indirectly by
calling SetSupportsSpdy. 

In this CL, we call ScheduleUpdateCacheOnPrefThread directly 3 times, the reason
we don't invoke this method indirectly is because it involves pref_delegate.
Note in the test the ExpectCacheUpdate() is invoked twice. I think it's fine to
leave as is. It's pretty clear that we schedule 3 times but only update twice. 

[xunjieli, 2016/12/21 02:13:09]

Acknowledged.

+
+  EXPECT_EQ(0u, pref_test_task_runner_->GetPendingTaskCount());
+  // Update cache.
+  http_server_props_manager_->ScheduleUpdateCacheOnPrefThread();
+  EXPECT_EQ(1u, pref_test_task_runner_->GetPendingTaskCount());
+
+  // Move forward the task runner 20ms.
+  pref_test_task_runner_->FastForwardBy(base::TimeDelta::FromMilliseconds(20));
+  // Schedule a new cache update within the time window should be a no-op.
+  http_server_props_manager_->ScheduleUpdateCacheOnPrefThread();
+  EXPECT_EQ(1u, pref_test_task_runner_->GetPendingTaskCount());
+
+  // Move forward the task runner 40ms, now the cache update should be
+  // exectured.
+  pref_test_task_runner_->FastForwardBy(base::TimeDelta::FromMilliseconds(40));
+
+  // Since this test has no pref corruption, there shouldn't be any pref update.
+  EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
+  EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
+
+  // Schedule one more cache update. The task should be successfully scheduled
+  // on pref task runner.
+  ExpectCacheUpdate();
+  http_server_props_manager_->ScheduleUpdateCacheOnPrefThread();
+  EXPECT_EQ(1u, pref_test_task_runner_->GetPendingTaskCount());
+
+  pref_test_task_runner_->FastForwardUntilNoTasksRemain();
+  EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
+  EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
+}
+
 TEST_P(HttpServerPropertiesManagerTest, AddToAlternativeServiceMap) {
   std::unique_ptr<base::Value> server_value = base::JSONReader::Read(
       "{\"alternative_service\":[{\"port\":443,\"protocol_str\":\"h2\"},"