Separate prefs from HttpServerPropertiesManager.

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 "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
-#include "base/prefs/pref_registry_simple.h"
-#include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "net/base/ip_address_number.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
 using base::StringPrintf;
 using ::testing::_;
 using ::testing::Invoke;
 using ::testing::Mock;
 using ::testing::StrictMock;
 
-const char kTestHttpServerProperties[] = "TestHttpServerProperties";
+class MockPrefDelegate : public net::HttpServerPropertiesManager::PrefDelegate {
+ public:
+  MockPrefDelegate() {}
+  ~MockPrefDelegate() override {}
+
+  // HttpServerPropertiesManager::PrefDelegate implementation.
+  bool HasServerProperties() override { return true; }
+  const base::DictionaryValue& GetServerProperties() const override {
+    return prefs_;
+  }
+  void SetServerProperties(const base::Value& value) override {
+    const base::DictionaryValue* value_dict = nullptr;
+    CHECK(value.GetAsDictionary(&value_dict));
+
+    prefs_.Clear();
+    prefs_.MergeDictionary(value_dict);
+    if (!prefs_changed_callback_.is_null())
+      prefs_changed_callback_.Run();
+  }
+  void StartListeningForUpdates(const base::Closure& callback) override {
+    CHECK(prefs_changed_callback_.is_null());
+    prefs_changed_callback_ = callback;
+  }
+  void StopListeningForUpdates() override {
+    CHECK(!prefs_changed_callback_.is_null());
+    prefs_changed_callback_ = base::Closure();
+  }
+
+  void SetPrefs(const base::DictionaryValue& value) {
+    // prefs_ = value;
+    prefs_.Clear();
+    prefs_.MergeDictionary(&value);
+    if (!prefs_changed_callback_.is_null())
+      prefs_changed_callback_.Run();
+  }
+
+ private:
+  base::DictionaryValue prefs_;
+  base::Closure prefs_changed_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockPrefDelegate);
+};
 
 class TestingHttpServerPropertiesManager : public HttpServerPropertiesManager {
  public:
   TestingHttpServerPropertiesManager(
-      PrefService* pref_service,
-      const char* pref_path,
+      HttpServerPropertiesManager::PrefDelegate* pref_delegate,
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
-      : HttpServerPropertiesManager(pref_service, pref_path, io_task_runner) {
+      : HttpServerPropertiesManager(pref_delegate, io_task_runner) {
     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 {
@@ skipping 55 matching lines @@
 // 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};
 
 class HttpServerPropertiesManagerTest : public testing::TestWithParam<int> {
  protected:
   HttpServerPropertiesManagerTest() {}
 
   void SetUp() override {
     one_day_from_now_ = base::Time::Now() + base::TimeDelta::FromDays(1);
-    pref_service_.registry()->RegisterDictionaryPref(kTestHttpServerProperties);
+    pref_delegate_ = new MockPrefDelegate;
     http_server_props_manager_.reset(
         new StrictMock<TestingHttpServerPropertiesManager>(
-            &pref_service_, kTestHttpServerProperties,
-            base::ThreadTaskRunnerHandle::Get()));
+            pref_delegate_, base::ThreadTaskRunnerHandle::Get()));
     ExpectCacheUpdate();
     base::RunLoop().RunUntilIdle();
   }
 
   void TearDown() override {
     if (http_server_props_manager_.get())
       http_server_props_manager_->ShutdownOnPrefThread();
     base::RunLoop().RunUntilIdle();
     http_server_props_manager_.reset();
   }
@@ skipping 37 matching lines @@
                    &TestingHttpServerPropertiesManager::
                        UpdatePrefsFromCacheOnNetworkThreadConcrete));
   }
 
   bool HasAlternativeService(const HostPortPair& server) {
     const AlternativeServiceVector alternative_service_vector =
         http_server_props_manager_->GetAlternativeServices(server);
     return !alternative_service_vector.empty();
   }
 
-  //base::RunLoop loop_;
-  TestingPrefServiceSimple pref_service_;
+  MockPrefDelegate* pref_delegate_;  // Owned by HttpServerPropertiesManager.
   scoped_ptr<TestingHttpServerPropertiesManager> http_server_props_manager_;
   base::Time one_day_from_now_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HttpServerPropertiesManagerTest);
 };
 
 INSTANTIATE_TEST_CASE_P(Tests,
                         HttpServerPropertiesManagerTest,
                         ::testing::ValuesIn(kHttpServerPropertiesVersions));
@@ skipping 56 matching lines @@
   server_pref_dict1->SetWithoutPathExpansion("alternative_service",
                                              alternative_service_list1);
 
   // Set up ServerNetworkStats for mail.google.com:80 and it is the MRU server.
   base::DictionaryValue* stats1 = new base::DictionaryValue;
   stats1->SetInteger("srtt", 20);
   server_pref_dict1->SetWithoutPathExpansion("network_stats", stats1);
   // Set the server preference for mail.google.com:80.
   servers_dict->SetWithoutPathExpansion("mail.google.com:80",
                                         server_pref_dict1);
-  base::DictionaryValue* http_server_properties_dict =
-      new base::DictionaryValue;
+  base::DictionaryValue http_server_properties_dict;
   if (GetParam() == 4) {
     // |servers_list| takes ownership of |servers_dict|.
     servers_list->AppendIfNotPresent(servers_dict);
-    HttpServerPropertiesManager::SetVersion(http_server_properties_dict, -1);
-    http_server_properties_dict->SetWithoutPathExpansion("servers",
-                                                         servers_list);
+    HttpServerPropertiesManager::SetVersion(&http_server_properties_dict, -1);
+    http_server_properties_dict.SetWithoutPathExpansion("servers",
+                                                        servers_list);
   } else {
-    HttpServerPropertiesManager::SetVersion(http_server_properties_dict,
+    HttpServerPropertiesManager::SetVersion(&http_server_properties_dict,
                                             GetParam());
-    http_server_properties_dict->SetWithoutPathExpansion("servers",
-                                                         servers_dict);
+    http_server_properties_dict.SetWithoutPathExpansion("servers",
+                                                        servers_dict);
   }
   base::DictionaryValue* supports_quic = new base::DictionaryValue;
   supports_quic->SetBoolean("used_quic", true);
   supports_quic->SetString("address", "127.0.0.1");
-  http_server_properties_dict->SetWithoutPathExpansion("supports_quic",
-                                                       supports_quic);
+  http_server_properties_dict.SetWithoutPathExpansion("supports_quic",
+                                                      supports_quic);
 
   // Set quic_server_info for www.google.com:80, mail.google.com:80 and
   // play.google.com:80 and verify the MRU.
   http_server_props_manager_->SetMaxServerConfigsStoredInProperties(3);
   base::DictionaryValue* quic_servers_dict = new base::DictionaryValue;
   base::DictionaryValue* quic_server_pref_dict1 = new base::DictionaryValue;
   std::string quic_server_info1("quic_server_info1");
   quic_server_pref_dict1->SetStringWithoutPathExpansion("server_info",
                                                         quic_server_info1);
   base::DictionaryValue* quic_server_pref_dict2 = new base::DictionaryValue;
   std::string quic_server_info2("quic_server_info2");
   quic_server_pref_dict2->SetStringWithoutPathExpansion("server_info",
                                                         quic_server_info2);
   base::DictionaryValue* quic_server_pref_dict3 = new base::DictionaryValue;
   std::string quic_server_info3("quic_server_info3");
   quic_server_pref_dict3->SetStringWithoutPathExpansion("server_info",
                                                         quic_server_info3);
   // Set the quic_server_info1 for www.google.com server.
   QuicServerId google_quic_server_id("www.google.com", 80);
   quic_servers_dict->SetWithoutPathExpansion(google_quic_server_id.ToString(),
                                              quic_server_pref_dict1);
   // Set the quic_server_info2 for mail.google.com server.
   QuicServerId mail_quic_server_id("mail.google.com", 80);
   quic_servers_dict->SetWithoutPathExpansion(mail_quic_server_id.ToString(),
                                              quic_server_pref_dict2);
   // Set the quic_server_info3 for play.google.com server.
   QuicServerId play_quic_server_id("play.google.com", 80);
   quic_servers_dict->SetWithoutPathExpansion(play_quic_server_id.ToString(),
                                              quic_server_pref_dict3);
-  http_server_properties_dict->SetWithoutPathExpansion("quic_servers",
-                                                       quic_servers_dict);
+  http_server_properties_dict.SetWithoutPathExpansion("quic_servers",
+                                                      quic_servers_dict);
 
   // Set the same value for kHttpServerProperties multiple times.
-  pref_service_.SetManagedPref(kTestHttpServerProperties,
-                               http_server_properties_dict);
-  base::DictionaryValue* http_server_properties_dict2 =
-      http_server_properties_dict->DeepCopy();
-  pref_service_.SetManagedPref(kTestHttpServerProperties,
-                               http_server_properties_dict2);
+  pref_delegate_->SetPrefs(http_server_properties_dict);
+  pref_delegate_->SetPrefs(http_server_properties_dict);
 
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
   // Verify SupportsSpdy.
   EXPECT_TRUE(
       http_server_props_manager_->SupportsRequestPriority(google_server));
   EXPECT_TRUE(http_server_props_manager_->SupportsRequestPriority(mail_server));
   EXPECT_FALSE(http_server_props_manager_->SupportsRequestPriority(
       HostPortPair::FromString("foo.google.com:1337")));
@@ skipping 93 matching lines @@
 
   // Set up ServerNetworkStats for www.google.com:65536.
   base::DictionaryValue* stats = new base::DictionaryValue;
   stats->SetInteger("srtt", 10);
   server_pref_dict->SetWithoutPathExpansion("network_stats", stats);
 
   // Set the server preference for www.google.com:65536.
   base::DictionaryValue* servers_dict = new base::DictionaryValue;
   servers_dict->SetWithoutPathExpansion("www.google.com:65536",
                                         server_pref_dict);
-  base::DictionaryValue* http_server_properties_dict =
-      new base::DictionaryValue;
+  base::DictionaryValue http_server_properties_dict;
   if (GetParam() == 4) {
     base::ListValue* servers_list = new base::ListValue;
     // |servers_list| takes ownership of |servers_dict|.
     servers_list->AppendIfNotPresent(servers_dict);
-    HttpServerPropertiesManager::SetVersion(http_server_properties_dict, -1);
-    http_server_properties_dict->SetWithoutPathExpansion("servers",
-                                                         servers_list);
+    HttpServerPropertiesManager::SetVersion(&http_server_properties_dict, -1);
+    http_server_properties_dict.SetWithoutPathExpansion("servers",
+                                                        servers_list);
   } else {
-    HttpServerPropertiesManager::SetVersion(http_server_properties_dict,
+    HttpServerPropertiesManager::SetVersion(&http_server_properties_dict,
                                             GetParam());
-    http_server_properties_dict->SetWithoutPathExpansion("servers",
-                                                         servers_dict);
+    http_server_properties_dict.SetWithoutPathExpansion("servers",
+                                                        servers_dict);
   }
 
   // Set quic_server_info for www.google.com:65536.
   base::DictionaryValue* quic_servers_dict = new base::DictionaryValue;
   base::DictionaryValue* quic_server_pref_dict1 = new base::DictionaryValue;
   quic_server_pref_dict1->SetStringWithoutPathExpansion("server_info",
                                                         "quic_server_info1");
   quic_servers_dict->SetWithoutPathExpansion("http://mail.google.com:65536",
                                              quic_server_pref_dict1);
 
-  http_server_properties_dict->SetWithoutPathExpansion("quic_servers",
-                                                       quic_servers_dict);
+  http_server_properties_dict.SetWithoutPathExpansion("quic_servers",
+                                                      quic_servers_dict);
 
   // Set up the pref.
-  pref_service_.SetManagedPref(kTestHttpServerProperties,
-                               http_server_properties_dict);
+  pref_delegate_->SetPrefs(http_server_properties_dict);
 
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
   // Verify that nothing is set.
   EXPECT_FALSE(http_server_props_manager_->SupportsRequestPriority(
       HostPortPair::FromString("www.google.com:65536")));
   EXPECT_FALSE(
       HasAlternativeService(HostPortPair::FromString("www.google.com:65536")));
   const ServerNetworkStats* stats1 =
@@ skipping 19 matching lines @@
   alternative_service_dict->SetString("protocol_str", "npn-h2");
   alternative_service_dict->SetInteger("port", 65536);
   base::ListValue* alternative_service_list = new base::ListValue;
   alternative_service_list->Append(alternative_service_dict);
   server_pref_dict->SetWithoutPathExpansion("alternative_service",
                                             alternative_service_list);
 
   // Set the server preference for www.google.com:80.
   base::DictionaryValue* servers_dict = new base::DictionaryValue;
   servers_dict->SetWithoutPathExpansion("www.google.com:80", server_pref_dict);
-  base::DictionaryValue* http_server_properties_dict =
-      new base::DictionaryValue;
+  base::DictionaryValue http_server_properties_dict;
   if (GetParam() == 4) {
     base::ListValue* servers_list = new base::ListValue;
     // |servers_list| takes ownership of |servers_dict|.
     servers_list->AppendIfNotPresent(servers_dict);
-    HttpServerPropertiesManager::SetVersion(http_server_properties_dict, -1);
-    http_server_properties_dict->SetWithoutPathExpansion("servers",
-                                                         servers_list);
+    HttpServerPropertiesManager::SetVersion(&http_server_properties_dict, -1);
+    http_server_properties_dict.SetWithoutPathExpansion("servers",
+                                                        servers_list);
   } else {
-    HttpServerPropertiesManager::SetVersion(http_server_properties_dict,
+    HttpServerPropertiesManager::SetVersion(&http_server_properties_dict,
                                             GetParam());
-    http_server_properties_dict->SetWithoutPathExpansion("servers",
-                                                         servers_dict);
+    http_server_properties_dict.SetWithoutPathExpansion("servers",
+                                                        servers_dict);
   }
 
   // Set up the pref.
-  pref_service_.SetManagedPref(kTestHttpServerProperties,
-                               http_server_properties_dict);
+  pref_delegate_->SetPrefs(http_server_properties_dict);
 
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
   // Verify alternative service is not set.
   EXPECT_FALSE(
       HasAlternativeService(HostPortPair::FromString("www.google.com:80")));
 }
 
 TEST_P(HttpServerPropertiesManagerTest, SupportsSpdy) {
@@ skipping 435 matching lines @@
           StringPrintf("www.google.com:%d", i), server_pref_dict);
     }
   }
 
   // Set the preference for mail.google.com server.
   base::DictionaryValue* server_pref_dict1 = new base::DictionaryValue;
 
   // Set the server preference for mail.google.com:80.
   servers_dict->SetWithoutPathExpansion("mail.google.com:80",
                                         server_pref_dict1);
-  base::DictionaryValue* http_server_properties_dict =
-      new base::DictionaryValue;
+  base::DictionaryValue http_server_properties_dict;
   if (GetParam() == 4) {
     // |servers_list| takes ownership of |servers_dict|.
     servers_list->AppendIfNotPresent(servers_dict);
-    HttpServerPropertiesManager::SetVersion(http_server_properties_dict, -1);
-    http_server_properties_dict->SetWithoutPathExpansion("servers",
-                                                         servers_list);
+    HttpServerPropertiesManager::SetVersion(&http_server_properties_dict, -1);
+    http_server_properties_dict.SetWithoutPathExpansion("servers",
+                                                        servers_list);
   } else {
-    HttpServerPropertiesManager::SetVersion(http_server_properties_dict,
+    HttpServerPropertiesManager::SetVersion(&http_server_properties_dict,
                                             GetParam());
-    http_server_properties_dict->SetWithoutPathExpansion("servers",
-                                                         servers_dict);
+    http_server_properties_dict.SetWithoutPathExpansion("servers",
+                                                        servers_dict);
   }
 
   // Set up SupportsQuic for 127.0.0.1
   base::DictionaryValue* supports_quic = new base::DictionaryValue;
   supports_quic->SetBoolean("used_quic", true);
   supports_quic->SetString("address", "127.0.0.1");
-  http_server_properties_dict->SetWithoutPathExpansion("supports_quic",
-                                                       supports_quic);
+  http_server_properties_dict.SetWithoutPathExpansion("supports_quic",
+                                                      supports_quic);
 
   // Set up the pref.
-  pref_service_.SetManagedPref(kTestHttpServerProperties,
-                               http_server_properties_dict);
+  pref_delegate_->SetPrefs(http_server_properties_dict);
 
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
 
   // Verify alternative service.
   for (int i = 0; i < 200; ++i) {
     std::string server = StringPrintf("www.google.com:%d", i);
     AlternativeServiceVector alternative_service_vector =
         http_server_props_manager_->GetAlternativeServices(
             HostPortPair::FromString(server));
@@ skipping 70 matching lines @@
       "\"port\":1234,\"probability\":0.7,\"protocol_str\":\"npn-h2\"}]}},"
       "{\"mail.google.com:80\":{\"alternative_service\":[{"
       "\"expiration\":\"9223372036854775807\",\"host\":\"foo.google.com\","
       "\"port\":444,\"probability\":0.2,\"protocol_str\":\"npn-spdy/3.1\"}],"
       "\"network_stats\":{\"srtt\":42}}}"
       "],"
       "\"supports_quic\":{\"address\":\"127.0.0.1\",\"used_quic\":true},"
       "\"version\":4}";
 
   const base::Value* http_server_properties =
-      pref_service_.GetUserPref(kTestHttpServerProperties);
-  ASSERT_NE(nullptr, 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, AddToAlternativeServiceMap) {
   scoped_ptr<base::Value> server_value = base::JSONReader::Read(
       "{\"alternative_service\":[{\"port\":443,\"protocol_str\":\"npn-h2\"},"
       "{\"port\":123,\"protocol_str\":\"quic\",\"probability\":0.7,"
@@ skipping 78 matching lines @@
   const HostPortPair host_port_pair("www.example.com", 443);
   http_server_props_manager_->SetAlternativeServices(
       host_port_pair, alternative_service_info_vector);
 
   // Update cache.
   ExpectPrefsUpdate();
   ExpectCacheUpdate();
   http_server_props_manager_->ScheduleUpdateCacheOnPrefThread();
   base::RunLoop().RunUntilIdle();
 
-  const base::Value* pref_value =
-      pref_service_.GetUserPref(kTestHttpServerProperties);
-  ASSERT_NE(nullptr, pref_value);
-
-  const base::DictionaryValue* pref_dict;
-  ASSERT_TRUE(pref_value->GetAsDictionary(&pref_dict));
+  const base::DictionaryValue& pref_dict =
+      pref_delegate_->GetServerProperties();
 
   const base::ListValue* servers_list = nullptr;
-  ASSERT_TRUE(pref_dict->GetListWithoutPathExpansion("servers", &servers_list));
+  ASSERT_TRUE(pref_dict.GetListWithoutPathExpansion("servers", &servers_list));
   base::ListValue::const_iterator it = servers_list->begin();
   const base::DictionaryValue* server_pref_dict;
   ASSERT_TRUE((*it)->GetAsDictionary(&server_pref_dict));
 
   const base::DictionaryValue* example_pref_dict;
   ASSERT_TRUE(server_pref_dict->GetDictionaryWithoutPathExpansion(
       "www.example.com:443", &example_pref_dict));
 
   const base::ListValue* altsvc_list;
   ASSERT_TRUE(example_pref_dict->GetList("alternative_service", &altsvc_list));
@@ skipping 121 matching lines @@
   // Shutdown comes before the task is executed.
   http_server_props_manager_->ShutdownOnPrefThread();
   // Run the task after shutdown, but before deletion.
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(http_server_props_manager_.get());
   http_server_props_manager_.reset();
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace net