Change http_server_properties_manager to always persist data to memory after 1s

net/http/http_server_properties_manager_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 "net/http/http_server_properties_manager.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/json/json_reader.h"
@@ skipping 67 matching lines @@
 
 class TestingHttpServerPropertiesManager : public HttpServerPropertiesManager {
  public:
   TestingHttpServerPropertiesManager(
       HttpServerPropertiesManager::PrefDelegate* pref_delegate,
       scoped_refptr<base::SingleThreadTaskRunner> pref_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> net_task_runner)
       : 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();
   }
 
   ~TestingHttpServerPropertiesManager() override {}
 
   // Make these methods public for testing.
   using HttpServerPropertiesManager::ScheduleUpdateCacheOnPrefThread;
 
   // Post tasks without a delay during tests.
   void StartPrefsUpdateTimerOnNetworkThread(base::TimeDelta delay) override {
     HttpServerPropertiesManager::StartPrefsUpdateTimerOnNetworkThread(
         pref_update_delay_);
   }
 
   void UpdateCacheFromPrefsOnUIConcrete() {
     HttpServerPropertiesManager::UpdateCacheFromPrefsOnPrefThread();
   }
 
   // Post tasks without a delay during tests.
   void StartCacheUpdateTimerOnPrefThread(base::TimeDelta delay) override {
     HttpServerPropertiesManager::StartCacheUpdateTimerOnPrefThread(
-        base::TimeDelta());
+        cache_update_delay_);
   }
 
   void UpdatePrefsFromCacheOnNetworkThreadConcrete(
       const base::Closure& callback) {
     HttpServerPropertiesManager::UpdatePrefsFromCacheOnNetworkThread(callback);
   }
 
   void ScheduleUpdatePrefsOnNetworkThreadConcrete(Location location) {
     HttpServerPropertiesManager::ScheduleUpdatePrefsOnNetworkThread(location);
   }
 
   void ScheduleUpdatePrefsOnNetworkThread() {
     // Picked a random Location as caller.
     HttpServerPropertiesManager::ScheduleUpdatePrefsOnNetworkThread(
         DETECTED_CORRUPTED_PREFS);
   }
 
   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));
   MOCK_METHOD6(UpdateCacheFromPrefsOnNetworkThread,
                void(std::vector<std::string>* spdy_servers,
                     AlternativeServiceMap* alternative_service_map,
                     IPAddress* last_quic_address,
                     ServerNetworkStatsMap* server_network_stats_map,
                     QuicServerInfoMap* quic_server_info_map,
                     bool detected_corrupted_prefs));
   MOCK_METHOD6(UpdatePrefsOnPrefThread,
                void(base::ListValue* spdy_server_list,
                     AlternativeServiceMap* alternative_service_map,
                     IPAddress* last_quic_address,
                     ServerNetworkStatsMap* server_network_stats_map,
                     QuicServerInfoMap* quic_server_info_map,
                     const base::Closure& completion));
 
  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);
 };
 
 }  // namespace
 
 // TODO(rtenneti): After we stop supporting version 3 and everyone has migrated
 // to version 4, delete the following code.
 static const int kHttpServerPropertiesVersions[] = {3, 4, 5};
 
 class HttpServerPropertiesManagerTest : public testing::TestWithParam<int> {
@@ skipping 1031 matching lines @@
       "\"version\":5}";
 
   const base::Value* http_server_properties =
       &pref_delegate_->GetServerProperties();
   std::string preferences_json;
   EXPECT_TRUE(
       base::JSONWriter::Write(*http_server_properties, &preferences_json));
   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\"},"
       "{\"port\":123,\"protocol_str\":\"quic\","
       "\"expiration\":\"9223372036854775807\"},{\"host\":\"example.org\","
       "\"port\":1234,\"protocol_str\":\"h2\","
       "\"expiration\":\"13758804000000000\"}]}");
   ASSERT_TRUE(server_value);
   base::DictionaryValue* server_dict;
   ASSERT_TRUE(server_value->GetAsDictionary(&server_dict));
@@ skipping 265 matching lines @@
   pref_test_task_runner_->FastForwardUntilNoTasksRemain();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
   http_server_props_manager_.reset();
   EXPECT_FALSE(net_test_task_runner_->HasPendingTask());
   EXPECT_FALSE(pref_test_task_runner_->HasPendingTask());
 }
 
 }  // namespace net