predictors: Add Manifest table to ResourcePrefetchPredictor.

chrome/browser/predictors/resource_prefetch_predictor_tables_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 <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
@@ skipping 25 matching lines @@
   void TestDeleteSingleDataPoint();
   void TestDeleteAllData();
 
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   std::unique_ptr<PredictorDatabase> db_;
   scoped_refptr<ResourcePrefetchPredictorTables> tables_;
 
   using PrefetchDataMap = ResourcePrefetchPredictorTables::PrefetchDataMap;
   using RedirectDataMap = ResourcePrefetchPredictorTables::RedirectDataMap;
+  using ManifestDataMap = ResourcePrefetchPredictorTables::ManifestDataMap;
 
  private:
   // Initializes the tables, |test_url_data_| and |test_host_data_|.
   void InitializeSampleData();
 
   // Checks that the input PrefetchData are the same, although the resources
   // can be in different order.
   void TestPrefetchDataAreEqual(const PrefetchDataMap& lhs,
                                 const PrefetchDataMap& rhs) const;
   void TestResourcesAreEqual(const std::vector<ResourceData>& lhs,
                              const std::vector<ResourceData>& rhs) const;
 
   // Checks that the input RedirectData are the same, although the redirects
   // can be in different order.
   void TestRedirectDataAreEqual(const RedirectDataMap& lhs,
                                 const RedirectDataMap& rhs) const;
   void TestRedirectsAreEqual(const std::vector<RedirectStat>& lhs,
                              const std::vector<RedirectStat>& rhs) const;
 
+  // Checks that the input ManifestData are the same, although the resources
+  // can be in different order.
+  void TestManifestDataAreEqual(const ManifestDataMap& lhs,
+                                const ManifestDataMap& rhs) const;
+  void TestManifestResourcesAreEqual(
+      const std::vector<precache::PrecacheResource>& lhs,
+      const std::vector<precache::PrecacheResource>& rhs) const;
+
   void AddKey(PrefetchDataMap* m, const std::string& key) const;
   void AddKey(RedirectDataMap* m, const std::string& key) const;
+  void AddKey(ManifestDataMap* m, const std::string& key) const;
 
   PrefetchDataMap test_url_data_;
   PrefetchDataMap test_host_data_;
   RedirectDataMap test_url_redirect_data_;
   RedirectDataMap test_host_redirect_data_;
+  ManifestDataMap test_manifest_data_;
 };
 
 class ResourcePrefetchPredictorTablesReopenTest
     : public ResourcePrefetchPredictorTablesTest {
  public:
   void SetUp() override {
     // Write data to the table, and then reopen the db.
     ResourcePrefetchPredictorTablesTest::SetUp();
     ResourcePrefetchPredictorTablesTest::TearDown();
 
@@ skipping 17 matching lines @@
 
 void ResourcePrefetchPredictorTablesTest::TearDown() {
   tables_ = NULL;
   db_.reset();
   base::RunLoop().RunUntilIdle();
 }
 
 void ResourcePrefetchPredictorTablesTest::TestGetAllData() {
   PrefetchDataMap actual_url_data, actual_host_data;
   RedirectDataMap actual_url_redirect_data, actual_host_redirect_data;
+  ManifestDataMap actual_manifest_data;
   tables_->GetAllData(&actual_url_data, &actual_host_data,
-                      &actual_url_redirect_data, &actual_host_redirect_data);
+                      &actual_url_redirect_data, &actual_host_redirect_data,
+                      &actual_manifest_data);
 
   TestPrefetchDataAreEqual(test_url_data_, actual_url_data);
   TestPrefetchDataAreEqual(test_host_data_, actual_host_data);
   TestRedirectDataAreEqual(test_url_redirect_data_, actual_url_redirect_data);
   TestRedirectDataAreEqual(test_host_redirect_data_, actual_host_redirect_data);
+  TestManifestDataAreEqual(test_manifest_data_, actual_manifest_data);
 }
 
 void ResourcePrefetchPredictorTablesTest::TestDeleteData() {
   std::vector<std::string> urls_to_delete = {"http://www.google.com",
                                              "http://www.yahoo.com"};
   std::vector<std::string> hosts_to_delete = {"www.yahoo.com"};
-
   tables_->DeleteResourceData(urls_to_delete, hosts_to_delete);
 
   urls_to_delete = {"http://fb.com/google", "http://google.com"};
   hosts_to_delete = {"microsoft.com"};
+  tables_->DeleteRedirectData(urls_to_delete, hosts_to_delete);
 
-  tables_->DeleteRedirectData(urls_to_delete, hosts_to_delete);
+  hosts_to_delete = {"en.wikipedia.org"};
+  tables_->DeleteManifestData(hosts_to_delete);
 
   PrefetchDataMap actual_url_data, actual_host_data;
   RedirectDataMap actual_url_redirect_data, actual_host_redirect_data;
+  ManifestDataMap actual_manifest_data;
   tables_->GetAllData(&actual_url_data, &actual_host_data,
-                      &actual_url_redirect_data, &actual_host_redirect_data);
+                      &actual_url_redirect_data, &actual_host_redirect_data,
+                      &actual_manifest_data);
 
   PrefetchDataMap expected_url_data, expected_host_data;
   RedirectDataMap expected_url_redirect_data, expected_host_redirect_data;
+  ManifestDataMap expected_manifest_data;
   AddKey(&expected_url_data, "http://www.reddit.com");
   AddKey(&expected_host_data, "www.facebook.com");
   AddKey(&expected_url_redirect_data, "http://nyt.com");
   AddKey(&expected_host_redirect_data, "bbc.com");
+  AddKey(&expected_manifest_data, "youtube.com");
 
   TestPrefetchDataAreEqual(expected_url_data, actual_url_data);
   TestPrefetchDataAreEqual(expected_host_data, actual_host_data);
   TestRedirectDataAreEqual(expected_url_redirect_data,
                            actual_url_redirect_data);
   TestRedirectDataAreEqual(expected_host_redirect_data,
                            actual_host_redirect_data);
+  TestManifestDataAreEqual(expected_manifest_data, actual_manifest_data);
 }
 
 void ResourcePrefetchPredictorTablesTest::TestDeleteSingleDataPoint() {
   // Delete a URL.
   tables_->DeleteSingleResourceDataPoint("http://www.reddit.com",
                                          PREFETCH_KEY_TYPE_URL);
 
   PrefetchDataMap actual_url_data, actual_host_data;
   RedirectDataMap actual_url_redirect_data, actual_host_redirect_data;
+  ManifestDataMap actual_manifest_data;
   tables_->GetAllData(&actual_url_data, &actual_host_data,
-                      &actual_url_redirect_data, &actual_host_redirect_data);
+                      &actual_url_redirect_data, &actual_host_redirect_data,
+                      &actual_manifest_data);
 
   PrefetchDataMap expected_url_data;
   AddKey(&expected_url_data, "http://www.google.com");
   AddKey(&expected_url_data, "http://www.yahoo.com");
 
   TestPrefetchDataAreEqual(expected_url_data, actual_url_data);
   TestPrefetchDataAreEqual(test_host_data_, actual_host_data);
   TestRedirectDataAreEqual(test_url_redirect_data_, actual_url_redirect_data);
   TestRedirectDataAreEqual(test_host_redirect_data_, actual_host_redirect_data);
 
   // Delete a host.
   tables_->DeleteSingleResourceDataPoint("www.facebook.com",
                                          PREFETCH_KEY_TYPE_HOST);
   actual_url_data.clear();
   actual_host_data.clear();
   actual_url_redirect_data.clear();
   actual_host_redirect_data.clear();
+  actual_manifest_data.clear();
   tables_->GetAllData(&actual_url_data, &actual_host_data,
-                      &actual_url_redirect_data, &actual_host_redirect_data);
+                      &actual_url_redirect_data, &actual_host_redirect_data,
+                      &actual_manifest_data);
 
   PrefetchDataMap expected_host_data;
   AddKey(&expected_host_data, "www.yahoo.com");
 
   TestPrefetchDataAreEqual(expected_url_data, actual_url_data);
   TestPrefetchDataAreEqual(expected_host_data, actual_host_data);
   TestRedirectDataAreEqual(test_url_redirect_data_, actual_url_redirect_data);
   TestRedirectDataAreEqual(test_host_redirect_data_, actual_host_redirect_data);
 
   // Delete a URL redirect.
   tables_->DeleteSingleRedirectDataPoint("http://nyt.com",
                                          PREFETCH_KEY_TYPE_URL);
   actual_url_data.clear();
   actual_host_data.clear();
   actual_url_redirect_data.clear();
   actual_host_redirect_data.clear();
+  actual_manifest_data.clear();
   tables_->GetAllData(&actual_url_data, &actual_host_data,
-                      &actual_url_redirect_data, &actual_host_redirect_data);
+                      &actual_url_redirect_data, &actual_host_redirect_data,
+                      &actual_manifest_data);
 
   RedirectDataMap expected_url_redirect_data;
   AddKey(&expected_url_redirect_data, "http://fb.com/google");
   AddKey(&expected_url_redirect_data, "http://google.com");
 
   TestPrefetchDataAreEqual(expected_url_data, actual_url_data);
   TestPrefetchDataAreEqual(expected_host_data, actual_host_data);
   TestRedirectDataAreEqual(expected_url_redirect_data,
                            actual_url_redirect_data);
   TestRedirectDataAreEqual(test_host_redirect_data_, actual_host_redirect_data);
 
   // Delete a host redirect.
   tables_->DeleteSingleRedirectDataPoint("bbc.com", PREFETCH_KEY_TYPE_HOST);
   actual_url_data.clear();
   actual_host_data.clear();
   actual_url_redirect_data.clear();
   actual_host_redirect_data.clear();
+  actual_manifest_data.clear();
   tables_->GetAllData(&actual_url_data, &actual_host_data,
-                      &actual_url_redirect_data, &actual_host_redirect_data);
+                      &actual_url_redirect_data, &actual_host_redirect_data,
+                      &actual_manifest_data);
 
   RedirectDataMap expected_host_redirect_data;
   AddKey(&expected_host_redirect_data, "microsoft.com");
 
   TestPrefetchDataAreEqual(expected_url_data, actual_url_data);
   TestPrefetchDataAreEqual(expected_host_data, actual_host_data);
   TestRedirectDataAreEqual(expected_url_redirect_data,
                            actual_url_redirect_data);
   TestRedirectDataAreEqual(expected_host_redirect_data,
                            actual_host_redirect_data);
@@ skipping 25 matching lines @@
                          "https://facebook.fr/google", 4, 2, 1);
 
   RedirectData microsoft = CreateRedirectData("microsoft.com", 21);
   InitializeRedirectStat(microsoft.add_redirect_endpoints(), "m.microsoft.com",
                          5, 7, 1);
   InitializeRedirectStat(microsoft.add_redirect_endpoints(), "microsoft.org", 7,
                          2, 0);
 
   tables_->UpdateData(google, yahoo, facebook, microsoft);
 
+  precache::PrecacheManifest theverge;
+  InitializePrecacheResource(theverge.add_resource(),
+                             "https://www.theverge.com/main.js", 0.7);
+
+  tables_->UpdateManifestData("theverge.com", theverge);
+
   PrefetchDataMap actual_url_data, actual_host_data;
   RedirectDataMap actual_url_redirect_data, actual_host_redirect_data;
+  ManifestDataMap actual_manifest_data;
   tables_->GetAllData(&actual_url_data, &actual_host_data,
-                      &actual_url_redirect_data, &actual_host_redirect_data);
+                      &actual_url_redirect_data, &actual_host_redirect_data,
+                      &actual_manifest_data);
 
   PrefetchDataMap expected_url_data, expected_host_data;
   RedirectDataMap expected_url_redirect_data, expected_host_redirect_data;
+  ManifestDataMap expected_manifest_data;
   AddKey(&expected_url_data, "http://www.reddit.com");
   AddKey(&expected_url_data, "http://www.yahoo.com");
   expected_url_data.insert(std::make_pair("http://www.google.com", google));
 
   AddKey(&expected_host_data, "www.facebook.com");
   expected_host_data.insert(std::make_pair("www.yahoo.com", yahoo));
 
   AddKey(&expected_url_redirect_data, "http://nyt.com");
   AddKey(&expected_url_redirect_data, "http://google.com");
   expected_url_redirect_data.insert(
       std::make_pair("http://fb.com/google", facebook));
 
   AddKey(&expected_host_redirect_data, "bbc.com");
   expected_host_redirect_data.insert(
       std::make_pair("microsoft.com", microsoft));
 
+  AddKey(&expected_manifest_data, "youtube.com");
+  AddKey(&expected_manifest_data, "en.wikipedia.org");
+  expected_manifest_data.insert(std::make_pair("theverge.com", theverge));
+
   TestPrefetchDataAreEqual(expected_url_data, actual_url_data);
   TestPrefetchDataAreEqual(expected_host_data, actual_host_data);
   TestRedirectDataAreEqual(expected_url_redirect_data,
                            actual_url_redirect_data);
   TestRedirectDataAreEqual(expected_host_redirect_data,
                            actual_host_redirect_data);
+  TestManifestDataAreEqual(expected_manifest_data, actual_manifest_data);
 }
 
 void ResourcePrefetchPredictorTablesTest::TestDeleteAllData() {
   tables_->DeleteAllData();
 
   PrefetchDataMap actual_url_data, actual_host_data;
   RedirectDataMap actual_url_redirect_data, actual_host_redirect_data;
+  ManifestDataMap actual_manifest_data;
   tables_->GetAllData(&actual_url_data, &actual_host_data,
-                      &actual_url_redirect_data, &actual_host_redirect_data);
+                      &actual_url_redirect_data, &actual_host_redirect_data,
+                      &actual_manifest_data);
   EXPECT_TRUE(actual_url_data.empty());
   EXPECT_TRUE(actual_host_data.empty());
   EXPECT_TRUE(actual_url_redirect_data.empty());
   EXPECT_TRUE(actual_host_redirect_data.empty());
+  EXPECT_TRUE(actual_manifest_data.empty());
 }
 
 void ResourcePrefetchPredictorTablesTest::TestPrefetchDataAreEqual(
     const PrefetchDataMap& lhs,
     const PrefetchDataMap& rhs) const {
   EXPECT_EQ(lhs.size(), rhs.size());
 
   for (const auto& p : rhs) {
     const auto lhs_it = lhs.find(p.first);
     ASSERT_TRUE(lhs_it != lhs.end()) << p.first;
@@ skipping 70 matching lines @@
       EXPECT_EQ(r, lhs_it->second);
       lhs_index.erase(lhs_it);
     } else {
       ADD_FAILURE() << r.url();
     }
   }
 
   EXPECT_TRUE(lhs_index.empty());
 }
 
+void ResourcePrefetchPredictorTablesTest::TestManifestDataAreEqual(
+    const ManifestDataMap& lhs,
+    const ManifestDataMap& rhs) const {
+  EXPECT_EQ(lhs.size(), rhs.size());
+
+  for (const auto& m : rhs) {
+    const auto lhs_it = lhs.find(m.first);
+    ASSERT_TRUE(lhs_it != lhs.end()) << m.first;
+    EXPECT_EQ(lhs_it->second.id().id(), m.second.id().id());
+
+    std::vector<precache::PrecacheResource> lhs_resources(
+        lhs_it->second.resource().begin(), lhs_it->second.resource().end());
+    std::vector<precache::PrecacheResource> rhs_resources(
+        m.second.resource().begin(), m.second.resource().end());
+
+    TestManifestResourcesAreEqual(lhs_resources, rhs_resources);
+  }
+}
+
+void ResourcePrefetchPredictorTablesTest::TestManifestResourcesAreEqual(
+    const std::vector<precache::PrecacheResource>& lhs,
+    const std::vector<precache::PrecacheResource>& rhs) const {
+  EXPECT_EQ(lhs.size(), rhs.size());
+
+  std::map<std::string, precache::PrecacheResource> lhs_index;
+  // Repeated resources are not allowed.
+  for (const auto& r : lhs)
+    EXPECT_TRUE(lhs_index.insert(std::make_pair(r.url(), r)).second);
+
+  for (const auto& r : rhs) {
+    auto lhs_it = lhs_index.find(r.url());
+    if (lhs_it != lhs_index.end()) {
+      EXPECT_EQ(r, lhs_it->second);
+      lhs_index.erase(lhs_it);
+    } else {
+      ADD_FAILURE() << r.url();
+    }
+  }
+
+  EXPECT_TRUE(lhs_index.empty());
+}
+
 void ResourcePrefetchPredictorTablesTest::AddKey(PrefetchDataMap* m,
                                                  const std::string& key) const {
   PrefetchDataMap::const_iterator it = test_url_data_.find(key);
   if (it != test_url_data_.end()) {
     m->insert(*it);
     return;
   }
   it = test_host_data_.find(key);
   ASSERT_TRUE(it != test_host_data_.end());
   m->insert(*it);
 }
 
 void ResourcePrefetchPredictorTablesTest::AddKey(RedirectDataMap* m,
                                                  const std::string& key) const {
   auto it = test_url_redirect_data_.find(key);
   if (it != test_url_redirect_data_.end()) {
     m->insert(*it);
     return;
   }
   it = test_host_redirect_data_.find(key);
   ASSERT_TRUE(it != test_host_redirect_data_.end());
   m->insert(*it);
 }
 
+void ResourcePrefetchPredictorTablesTest::AddKey(ManifestDataMap* m,
+                                                 const std::string& key) const {
+  auto it = test_manifest_data_.find(key);
+  ASSERT_TRUE(it != test_manifest_data_.end());
+  m->insert(*it);
+}
+
 void ResourcePrefetchPredictorTablesTest::InitializeSampleData() {
   PrefetchData empty_resource_data;
   RedirectData empty_redirect_data;
 
   {  // Url data.
     PrefetchData google = CreatePrefetchData("http://www.google.com", 1);
     InitializeResourceData(google.add_resources(),
                            "http://www.google.com/style.css",
                            content::RESOURCE_TYPE_STYLESHEET, 5, 2, 1, 1.1,
                            net::MEDIUM, false, false);
@@ skipping 120 matching lines @@
 
     test_host_redirect_data_.clear();
     test_host_redirect_data_.insert(std::make_pair(bbc.primary_key(), bbc));
     test_host_redirect_data_.insert(
         std::make_pair(microsoft.primary_key(), microsoft));
     tables_->UpdateData(empty_resource_data, empty_resource_data,
                         empty_redirect_data, bbc);
     tables_->UpdateData(empty_resource_data, empty_resource_data,
                         empty_redirect_data, microsoft);
   }
+
+  {  // Manifest data.
+    precache::PrecacheManifest wikipedia;
+    InitializePrecacheResource(wikipedia.add_resource(),
+                               "https://en.wikipedia.org/script.js", 0.7);
+    InitializePrecacheResource(wikipedia.add_resource(),
+                               "https://en.wikipedia.org/image.png", 0.3);
+
+    precache::PrecacheManifest youtube;
+    InitializePrecacheResource(youtube.add_resource(),
+                               "https://youtube.com/photo.jpg", 0.5);
+    InitializePrecacheResource(youtube.add_resource(),
+                               "https://youtube.com/base.js", 0.2);
+
+    test_manifest_data_.clear();
+    test_manifest_data_.insert(std::make_pair("en.wikipedia.org", wikipedia));
+    test_manifest_data_.insert(std::make_pair("youtube.com", youtube));
+    tables_->UpdateManifestData("en.wikipedia.org", wikipedia);
+    tables_->UpdateManifestData("youtube.com", youtube);
+  }
 }
 
 void ResourcePrefetchPredictorTablesTest::ReopenDatabase() {
   db_.reset(new PredictorDatabase(&profile_));
   base::RunLoop().RunUntilIdle();
   tables_ = db_->resource_prefetch_tables();
 }
 
 // Test cases.
 
@@ skipping 76 matching lines @@
   EXPECT_EQ(version + 1,
             ResourcePrefetchPredictorTables::GetDatabaseVersion(db));
 
   ReopenDatabase();
 
   db = tables_->DB();
   ASSERT_EQ(version, ResourcePrefetchPredictorTables::GetDatabaseVersion(db));
 
   PrefetchDataMap url_data, host_data;
   RedirectDataMap url_redirect_data, host_redirect_data;
+  ManifestDataMap manifest_data;
   tables_->GetAllData(&url_data, &host_data, &url_redirect_data,
-                      &host_redirect_data);
+                      &host_redirect_data, &manifest_data);
   EXPECT_TRUE(url_data.empty());
   EXPECT_TRUE(host_data.empty());
   EXPECT_TRUE(url_redirect_data.empty());
   EXPECT_TRUE(host_redirect_data.empty());
+  EXPECT_TRUE(manifest_data.empty());
 }
 
 TEST_F(ResourcePrefetchPredictorTablesReopenTest, GetAllData) {
   TestGetAllData();
 }
 
 TEST_F(ResourcePrefetchPredictorTablesReopenTest, UpdateData) {
   TestUpdateData();
 }
 
 TEST_F(ResourcePrefetchPredictorTablesReopenTest, DeleteData) {
   TestDeleteData();
 }
 
 TEST_F(ResourcePrefetchPredictorTablesReopenTest, DeleteSingleDataPoint) {
   TestDeleteSingleDataPoint();
 }
 
 TEST_F(ResourcePrefetchPredictorTablesReopenTest, DeleteAllData) {
   TestDeleteAllData();
 }
 
 }  // namespace predictors