predictors: Add Manifest table to ResourcePrefetchPredictor.

The very first step to reuse Bork manifests in ResourcePrefetchPredictor. This
CL adds a new table to the predictor database.

BUG=699115

Review-Url: https://codereview.chromium.org/2738613003
Cr-Commit-Position: refs/heads/master@{#455798}

chrome/browser/BUILD.gn

@@ -1483,6 +1483,7 @@ split_static_library("browser") {
     "//components/policy:generated",
     "//components/policy/core/browser",
     "//components/policy/proto",
+    "//components/precache/core:proto",
     "//components/prefs:prefs",
     "//components/previews/core",
     "//components/profile_metrics",

chrome/browser/predictors/resource_prefetch_predictor.cc

@@ -21,6 +21,7 @@
 #include "chrome/browser/profiles/profile.h"
 #include "components/history/core/browser/history_database.h"
 #include "components/history/core/browser/history_service.h"
+#include "components/history/core/browser/url_utils.h"
 #include "components/mime_util/mime_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_request_info.h"
@@ -503,6 +504,7 @@ void ResourcePrefetchPredictor::StartInitialization() {
   auto host_data_map = base::MakeUnique<PrefetchDataMap>();
   auto url_redirect_data_map = base::MakeUnique<RedirectDataMap>();
   auto host_redirect_data_map = base::MakeUnique<RedirectDataMap>();
+  auto manifest_data_map = base::MakeUnique<ManifestDataMap>();
 
   // Get raw pointers to pass to the first task. Ownership of the unique_ptrs
   // will be passed to the reply task.
@@ -510,16 +512,18 @@ void ResourcePrefetchPredictor::StartInitialization() {
   auto* host_data_map_ptr = host_data_map.get();
   auto* url_redirect_data_map_ptr = url_redirect_data_map.get();
   auto* host_redirect_data_map_ptr = host_redirect_data_map.get();
+  auto* manifest_data_map_ptr = manifest_data_map.get();
 
   BrowserThread::PostTaskAndReply(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&ResourcePrefetchPredictorTables::GetAllData, tables_,
                  url_data_map_ptr, host_data_map_ptr, url_redirect_data_map_ptr,
-                 host_redirect_data_map_ptr),
+                 host_redirect_data_map_ptr, manifest_data_map_ptr),
       base::Bind(&ResourcePrefetchPredictor::CreateCaches, AsWeakPtr(),
                  base::Passed(&url_data_map), base::Passed(&host_data_map),
                  base::Passed(&url_redirect_data_map),
-                 base::Passed(&host_redirect_data_map)));
+                 base::Passed(&host_redirect_data_map),
+                 base::Passed(&manifest_data_map)));
 }
 
 void ResourcePrefetchPredictor::RecordURLRequest(
@@ -860,7 +864,8 @@ void ResourcePrefetchPredictor::CreateCaches(
     std::unique_ptr<PrefetchDataMap> url_data_map,
     std::unique_ptr<PrefetchDataMap> host_data_map,
     std::unique_ptr<RedirectDataMap> url_redirect_data_map,
-    std::unique_ptr<RedirectDataMap> host_redirect_data_map) {
+    std::unique_ptr<RedirectDataMap> host_redirect_data_map,
+    std::unique_ptr<ManifestDataMap> manifest_data_map) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   DCHECK_EQ(INITIALIZING, initialization_state_);
@@ -868,12 +873,14 @@ void ResourcePrefetchPredictor::CreateCaches(
   DCHECK(!host_table_cache_);
   DCHECK(!url_redirect_table_cache_);
   DCHECK(!host_redirect_table_cache_);
+  DCHECK(!manifest_table_cache_);
   DCHECK(inflight_navigations_.empty());
 
   url_table_cache_ = std::move(url_data_map);
   host_table_cache_ = std::move(host_data_map);
   url_redirect_table_cache_ = std::move(url_redirect_data_map);
   host_redirect_table_cache_ = std::move(host_redirect_data_map);
+  manifest_table_cache_ = std::move(manifest_data_map);
 
   ConnectToHistoryService();
 }
@@ -943,6 +950,7 @@ void ResourcePrefetchPredictor::DeleteAllUrls() {
   host_table_cache_->clear();
   url_redirect_table_cache_->clear();
   host_redirect_table_cache_->clear();
+  manifest_table_cache_->clear();
 
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::Bind(&ResourcePrefetchPredictorTables::DeleteAllData, tables_));
@@ -953,6 +961,7 @@ void ResourcePrefetchPredictor::DeleteUrls(const history::URLRows& urls) {
   // in the cache.
   std::vector<std::string> urls_to_delete, hosts_to_delete;
   std::vector<std::string> url_redirects_to_delete, host_redirects_to_delete;
+  std::vector<std::string> manifest_hosts_to_delete;
 
   for (const auto& it : urls) {
     const std::string& url_spec = it.url().spec();
@@ -978,6 +987,13 @@ void ResourcePrefetchPredictor::DeleteUrls(const history::URLRows& urls) {
       host_redirects_to_delete.push_back(host);
       host_redirect_table_cache_->erase(host);
     }
+
+    std::string manifest_host = history::HostForTopHosts(it.url());
+    if (manifest_table_cache_->find(manifest_host) !=
+        manifest_table_cache_->end()) {
+      manifest_hosts_to_delete.push_back(manifest_host);
+      manifest_table_cache_->erase(manifest_host);
+    }
   }
 
   if (!urls_to_delete.empty() || !hosts_to_delete.empty()) {
@@ -993,6 +1009,13 @@ void ResourcePrefetchPredictor::DeleteUrls(const history::URLRows& urls) {
         base::Bind(&ResourcePrefetchPredictorTables::DeleteRedirectData,
                    tables_, url_redirects_to_delete, host_redirects_to_delete));
   }
+
+  if (!manifest_hosts_to_delete.empty()) {
+    BrowserThread::PostTask(
+        BrowserThread::DB, FROM_HERE,
+        base::Bind(&ResourcePrefetchPredictorTables::DeleteManifestData,
+                   tables_, manifest_hosts_to_delete));
+  }
 }
 
 void ResourcePrefetchPredictor::RemoveOldestEntryInPrefetchDataMap(

chrome/browser/predictors/resource_prefetch_predictor.h

@@ -265,6 +265,7 @@ class ResourcePrefetchPredictor
   };
   typedef ResourcePrefetchPredictorTables::PrefetchDataMap PrefetchDataMap;
   typedef ResourcePrefetchPredictorTables::RedirectDataMap RedirectDataMap;
+  typedef ResourcePrefetchPredictorTables::ManifestDataMap ManifestDataMap;
 
   typedef std::map<NavigationID, std::unique_ptr<PageRequestSummary>>
       NavigationMap;
@@ -323,7 +324,8 @@ class ResourcePrefetchPredictor
   void CreateCaches(std::unique_ptr<PrefetchDataMap> url_data_map,
                     std::unique_ptr<PrefetchDataMap> host_data_map,
                     std::unique_ptr<RedirectDataMap> url_redirect_data_map,
-                    std::unique_ptr<RedirectDataMap> host_redirect_data_map);
+                    std::unique_ptr<RedirectDataMap> host_redirect_data_map,
+                    std::unique_ptr<ManifestDataMap> manifest_data_map);
 
   // Called during initialization when history is read and the predictor
   // database has been read.
@@ -409,6 +411,7 @@ class ResourcePrefetchPredictor
   std::unique_ptr<PrefetchDataMap> host_table_cache_;
   std::unique_ptr<RedirectDataMap> url_redirect_table_cache_;
   std::unique_ptr<RedirectDataMap> host_redirect_table_cache_;
+  std::unique_ptr<ManifestDataMap> manifest_table_cache_;
 
   std::map<GURL, base::TimeTicks> inflight_prefetches_;
   NavigationMap inflight_navigations_;

chrome/browser/predictors/resource_prefetch_predictor_tables.cc

@@ -24,6 +24,7 @@ const char kUrlRedirectTableName[] = "resource_prefetch_predictor_url_redirect";
 const char kHostResourceTableName[] = "resource_prefetch_predictor_host";
 const char kHostRedirectTableName[] =
     "resource_prefetch_predictor_host_redirect";
+const char kManifestTableName[] = "resource_prefetch_predictor_manifest";
 
 const char kCreateGlobalMetadataStatementTemplate[] =
     "CREATE TABLE %s ( "
@@ -112,7 +113,8 @@ void ResourcePrefetchPredictorTables::GetAllData(
     PrefetchDataMap* url_data_map,
     PrefetchDataMap* host_data_map,
     RedirectDataMap* url_redirect_data_map,
-    RedirectDataMap* host_redirect_data_map) {
+    RedirectDataMap* host_redirect_data_map,
+    ManifestDataMap* manifest_map) {
   TRACE_EVENT0("browser", "ResourcePrefetchPredictor::GetAllData");
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
@@ -126,11 +128,13 @@ void ResourcePrefetchPredictorTables::GetAllData(
   host_data_map->clear();
   url_redirect_data_map->clear();
   host_redirect_data_map->clear();
+  manifest_map->clear();
 
   GetAllResourceDataHelper(PREFETCH_KEY_TYPE_URL, url_data_map);
   GetAllResourceDataHelper(PREFETCH_KEY_TYPE_HOST, host_data_map);
   GetAllRedirectDataHelper(PREFETCH_KEY_TYPE_URL, url_redirect_data_map);
   GetAllRedirectDataHelper(PREFETCH_KEY_TYPE_HOST, host_redirect_data_map);
+  GetAllManifestDataHelper(manifest_map);
 }
 
 void ResourcePrefetchPredictorTables::UpdateData(
@@ -168,6 +172,23 @@ void ResourcePrefetchPredictorTables::UpdateData(
     DB()->CommitTransaction();
 }
 
+void ResourcePrefetchPredictorTables::UpdateManifestData(
+    const std::string& host,
+    const precache::PrecacheManifest& manifest_data) {
+  DCHECK_CURRENTLY_ON(BrowserThread::DB);
+  if (CantAccessDatabase())
+    return;
+
+  DB()->BeginTransaction();
+  bool success = UpdateDataHelper(
+      PREFETCH_KEY_TYPE_HOST, PrefetchDataType::MANIFEST, host, manifest_data);
+
+  if (!success)
+    DB()->RollbackTransaction();
+  else
+    DB()->CommitTransaction();
+}
+
 void ResourcePrefetchPredictorTables::DeleteResourceData(
     const std::vector<std::string>& urls,
     const std::vector<std::string>& hosts) {
@@ -218,6 +239,15 @@ void ResourcePrefetchPredictorTables::DeleteSingleRedirectDataPoint(
   DeleteDataHelper(key_type, PrefetchDataType::REDIRECT, {key});
 }
 
+void ResourcePrefetchPredictorTables::DeleteManifestData(
+    const std::vector<std::string>& hosts) {
+  DCHECK_CURRENTLY_ON(BrowserThread::DB);
+  if (CantAccessDatabase())
+    return;
+
+  DeleteDataHelper(PREFETCH_KEY_TYPE_HOST, PrefetchDataType::MANIFEST, hosts);
+}
+
 void ResourcePrefetchPredictorTables::DeleteAllData() {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
@@ -226,7 +256,7 @@ void ResourcePrefetchPredictorTables::DeleteAllData() {
   sql::Statement deleter;
   for (const char* table_name :
        {kUrlResourceTableName, kUrlRedirectTableName, kHostResourceTableName,
-        kHostRedirectTableName}) {
+        kHostRedirectTableName, kManifestTableName}) {
     deleter.Assign(DB()->GetUniqueStatement(
         base::StringPrintf("DELETE FROM %s", table_name).c_str()));
     deleter.Run();
@@ -274,6 +304,18 @@ void ResourcePrefetchPredictorTables::GetAllRedirectDataHelper(
   }
 }
 
+void ResourcePrefetchPredictorTables::GetAllManifestDataHelper(
+    ManifestDataMap* manifest_map) {
+  sql::Statement manifest_reader(DB()->GetUniqueStatement(
+      base::StringPrintf("SELECT * FROM %s", kManifestTableName).c_str()));
+
+  precache::PrecacheManifest data;
+  std::string key;
+  while (StepAndInitializeProtoData(&manifest_reader, &key, &data)) {
+    manifest_map->insert(std::make_pair(key, data));
+  }
+}
+
 bool ResourcePrefetchPredictorTables::UpdateDataHelper(
     PrefetchKeyType key_type,
     PrefetchDataType data_type,
@@ -367,8 +409,8 @@ bool ResourcePrefetchPredictorTables::DropTablesIfOutdated(
   if (incompatible_version) {
     for (const char* table_name :
          {kMetadataTableName, kUrlResourceTableName, kHostResourceTableName,
-          kUrlRedirectTableName, kHostRedirectTableName, kUrlMetadataTableName,
-          kHostMetadataTableName}) {
+          kUrlRedirectTableName, kHostRedirectTableName, kManifestTableName,
+          kUrlMetadataTableName, kHostMetadataTableName}) {
       success =
           success &&
           db->Execute(base::StringPrintf("DROP TABLE IF EXISTS %s", table_name)
@@ -425,7 +467,7 @@ void ResourcePrefetchPredictorTables::CreateTableIfNonExistent() {
 
   for (const char* table_name :
        {kUrlResourceTableName, kHostResourceTableName, kUrlRedirectTableName,
-        kHostRedirectTableName}) {
+        kHostRedirectTableName, kManifestTableName}) {
     success = success &&
               (db->DoesTableExist(table_name) ||
                db->Execute(base::StringPrintf(
@@ -468,7 +510,7 @@ ResourcePrefetchPredictorTables::GetTableUpdateStatement(
     PrefetchDataType data_type,
     TableOperationType op_type) {
   sql::StatementID id(__FILE__, key_type | (static_cast<int>(data_type) << 1) |
-                                    (static_cast<int>(op_type) << 2));
+                                    (static_cast<int>(op_type) << 3));
   const char* statement_template = (op_type == TableOperationType::REMOVE
                                         ? kDeleteProtoTableStatementTemplate
                                         : kInsertProtoTableStatementTemplate);
@@ -487,6 +529,8 @@ const char* ResourcePrefetchPredictorTables::GetTableName(
       return is_host ? kHostResourceTableName : kUrlResourceTableName;
     case PrefetchDataType::REDIRECT:
       return is_host ? kHostRedirectTableName : kUrlRedirectTableName;
+    case PrefetchDataType::MANIFEST:
+      return kManifestTableName;
   }
 
   NOTREACHED();

chrome/browser/predictors/resource_prefetch_predictor_tables.h

@@ -16,6 +16,7 @@
 #include "chrome/browser/predictors/predictor_table_base.h"
 #include "chrome/browser/predictors/resource_prefetch_common.h"
 #include "chrome/browser/predictors/resource_prefetch_predictor.pb.h"
+#include "components/precache/core/proto/precache.pb.h"
 
 namespace sql {
 class Statement;
@@ -37,17 +38,16 @@ using RedirectStat = RedirectData_RedirectStat;
 //  - HostRedirectTable - redirects per host.
 class ResourcePrefetchPredictorTables : public PredictorTableBase {
  public:
-  // Map from primary key to PrefetchData for the key.
   typedef std::map<std::string, PrefetchData> PrefetchDataMap;
-
-  // Map from primary key to RedirectData for the key.
   typedef std::map<std::string, RedirectData> RedirectDataMap;
+  typedef std::map<std::string, precache::PrecacheManifest> ManifestDataMap;
 
   // Returns data for all Urls and Hosts.
   virtual void GetAllData(PrefetchDataMap* url_data_map,
                           PrefetchDataMap* host_data_map,
                           RedirectDataMap* url_redirect_data_map,
-                          RedirectDataMap* host_redirect_data_map);
+                          RedirectDataMap* host_redirect_data_map,
+                          ManifestDataMap* manifest_map);
 
   // Updates data for a Url and a host. If either of the |url_data| or
   // |host_data| or |url_redirect_data| or |host_redirect_data| has an empty
@@ -60,6 +60,11 @@ class ResourcePrefetchPredictorTables : public PredictorTableBase {
                           const RedirectData& url_redirect_data,
                           const RedirectData& host_redirect_data);
 
+  // Updates manifest data for the input |host|.
+  virtual void UpdateManifestData(
+      const std::string& host,
+      const precache::PrecacheManifest& manifest_data);
+
   // Delete data for the input |urls| and |hosts|.
   virtual void DeleteResourceData(const std::vector<std::string>& urls,
                                   const std::vector<std::string>& hosts);
@@ -76,6 +81,9 @@ class ResourcePrefetchPredictorTables : public PredictorTableBase {
   virtual void DeleteSingleRedirectDataPoint(const std::string& key,
                                              PrefetchKeyType key_type);
 
+  // Delete data for the input |hosts|.
+  virtual void DeleteManifestData(const std::vector<std::string>& hosts);
+
   // Deletes all data in all the tables.
   virtual void DeleteAllData();
 
@@ -104,7 +112,7 @@ class ResourcePrefetchPredictorTables : public PredictorTableBase {
 
  private:
   // Represents the type of information that is stored in prefetch database.
-  enum class PrefetchDataType { RESOURCE, REDIRECT };
+  enum class PrefetchDataType { RESOURCE, REDIRECT, MANIFEST };
 
   enum class TableOperationType { INSERT, REMOVE };
 
@@ -116,7 +124,7 @@ class ResourcePrefetchPredictorTables : public PredictorTableBase {
 
   // Database version. Always increment it when any change is made to the data
   // schema (including the .proto).
-  static constexpr int kDatabaseVersion = 5;
+  static constexpr int kDatabaseVersion = 6;
 
   // Helper functions below help perform functions on the Url and host table
   // using the same code.
@@ -124,6 +132,8 @@ class ResourcePrefetchPredictorTables : public PredictorTableBase {
                                 PrefetchDataMap* data_map);
   void GetAllRedirectDataHelper(PrefetchKeyType key_type,
                                 RedirectDataMap* redirect_map);
+  void GetAllManifestDataHelper(ManifestDataMap* manifest_map);
+
   bool UpdateDataHelper(PrefetchKeyType key_type,
                         PrefetchDataType data_type,
                         const std::string& key,

chrome/browser/predictors/resource_prefetch_predictor_test_util.cc

@@ -4,6 +4,8 @@
 
 #include "chrome/browser/predictors/resource_prefetch_predictor_test_util.h"
 
+#include <limits>
+
 #include "chrome/browser/predictors/resource_prefetch_predictor_tables.h"
 
 namespace predictors {
@@ -44,6 +46,13 @@ void InitializeRedirectStat(RedirectStat* redirect,
   redirect->set_consecutive_misses(consecutive_misses);
 }
 
+void InitializePrecacheResource(precache::PrecacheResource* resource,
+                                const std::string& url,
+                                double weight_ratio) {
+  resource->set_url(url);
+  resource->set_weight_ratio(weight_ratio);
+}
+
 PrefetchData CreatePrefetchData(const std::string& primary_key,
                                 uint64_t last_visit_time) {
   PrefetchData data;
@@ -220,3 +229,38 @@ bool operator==(const URLRequestSummary& lhs, const URLRequestSummary& rhs) {
 }
 
 }  // namespace predictors
+
+namespace precache {
+
+std::ostream& operator<<(std::ostream& os, const PrecacheManifest& manifest) {
+  os << "[" << manifest.id().id() << "]" << std::endl;
+  for (const PrecacheResource& resource : manifest.resource())
+    os << "\t\t" << resource << std::endl;
+  return os;
+}
+
+std::ostream& operator<<(std::ostream& os, const PrecacheResource& resource) {
+  return os << "[" << resource.url() << "," << resource.top_host_name() << ","
+            << resource.weight_ratio() << "," << resource.weight() << "]";
+}
+
+bool operator==(const PrecacheManifest& lhs, const PrecacheManifest& rhs) {
+  bool equal = lhs.id().id() == rhs.id().id() &&
+               lhs.resource_size() == rhs.resource_size();
+
+  if (!equal)
+    return false;
+
+  for (int i = 0; i < lhs.resource_size(); ++i)
+    equal = equal && lhs.resource(i) == rhs.resource(i);
+
+  return equal;
+}
+
+bool operator==(const PrecacheResource& lhs, const PrecacheResource& rhs) {
+  return lhs.url() == rhs.url() &&
+         std::fabs(lhs.weight_ratio() - rhs.weight_ratio()) <
+             std::numeric_limits<double>::epsilon();
+}
+
+}  // namespace precache

chrome/browser/predictors/resource_prefetch_predictor_test_util.h

@@ -30,6 +30,10 @@ void InitializeRedirectStat(RedirectStat* redirect,
                             int number_of_misses,
                             int consecutive_misses);
 
+void InitializePrecacheResource(precache::PrecacheResource* resource,
+                                const std::string& url,
+                                double weight_ratio);
+
 PrefetchData CreatePrefetchData(const std::string& primary_key,
                                 uint64_t last_visit_time = 0);
 RedirectData CreateRedirectData(const std::string& primary_key,
@@ -80,4 +84,16 @@ bool operator==(const ResourcePrefetchPredictor::URLRequestSummary& lhs,
 
 }  // namespace predictors
 
+namespace precache {
+
+std::ostream& operator<<(std::ostream& stream,
+                         const PrecacheManifest& manifest);
+std::ostream& operator<<(std::ostream& stream,
+                         const PrecacheResource& resource);
+
+bool operator==(const PrecacheManifest& lhs, const PrecacheManifest& rhs);
+bool operator==(const PrecacheResource& lhs, const PrecacheResource& rhs);
+
+}  // namespace precache
+
 #endif  // CHROME_BROWSER_PREDICTORS_RESOURCE_PREFETCH_PREDICTOR_TEST_UTIL_H_

chrome/browser/predictors/resource_prefetch_predictor_unittest.cc

@@ -41,6 +41,7 @@ using URLRequestSummary = ResourcePrefetchPredictor::URLRequestSummary;
 using PageRequestSummary = ResourcePrefetchPredictor::PageRequestSummary;
 using PrefetchDataMap = ResourcePrefetchPredictorTables::PrefetchDataMap;
 using RedirectDataMap = ResourcePrefetchPredictorTables::RedirectDataMap;
+using ManifestDataMap = ResourcePrefetchPredictorTables::ManifestDataMap;
 
 scoped_refptr<net::HttpResponseHeaders> MakeResponseHeaders(
     const char* headers) {
@@ -130,11 +131,12 @@ class MockResourcePrefetchPredictorTables
  public:
   MockResourcePrefetchPredictorTables() { }
 
-  MOCK_METHOD4(GetAllData,
+  MOCK_METHOD5(GetAllData,
                void(PrefetchDataMap* url_data_map,
                     PrefetchDataMap* host_data_map,
                     RedirectDataMap* url_redirect_data_map,
-                    RedirectDataMap* host_redirect_data_map));
+                    RedirectDataMap* host_redirect_data_map,
+                    ManifestDataMap* manifest_data_map));
   MOCK_METHOD4(UpdateData,
                void(const PrefetchData& url_data,
                     const PrefetchData& host_data,
@@ -257,6 +259,7 @@ class ResourcePrefetchPredictorTest : public testing::Test {
   PrefetchDataMap test_host_data_;
   RedirectDataMap test_url_redirect_data_;
   RedirectDataMap test_host_redirect_data_;
+  ManifestDataMap test_manifest_data_;
   PrefetchData empty_resource_data_;
   RedirectData empty_redirect_data_;
 
@@ -293,7 +296,8 @@ void ResourcePrefetchPredictorTest::SetUp() {
               GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(RedirectDataMap())),
-                         Pointee(ContainerEq(RedirectDataMap()))));
+                         Pointee(ContainerEq(RedirectDataMap())),
+                         Pointee(ContainerEq(ManifestDataMap()))));
   InitializePredictor();
   EXPECT_TRUE(predictor_->inflight_navigations_.empty());
   EXPECT_EQ(predictor_->initialization_state_,
@@ -501,11 +505,13 @@ TEST_F(ResourcePrefetchPredictorTest, LazilyInitializeWithData) {
               GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(RedirectDataMap())),
-                         Pointee(ContainerEq(RedirectDataMap()))))
+                         Pointee(ContainerEq(RedirectDataMap())),
+                         Pointee(ContainerEq(ManifestDataMap()))))
       .WillOnce(DoAll(SetArgPointee<0>(test_url_data_),
                       SetArgPointee<1>(test_host_data_),
                       SetArgPointee<2>(test_url_redirect_data_),
-                      SetArgPointee<3>(test_host_redirect_data_)));
+                      SetArgPointee<3>(test_host_redirect_data_),
+                      SetArgPointee<4>(test_manifest_data_)));
 
   ResetPredictor();
   InitializePredictor();
@@ -519,6 +525,7 @@ TEST_F(ResourcePrefetchPredictorTest, LazilyInitializeWithData) {
   EXPECT_EQ(test_host_data_, *predictor_->host_table_cache_);
   EXPECT_EQ(test_url_redirect_data_, *predictor_->url_redirect_table_cache_);
   EXPECT_EQ(test_host_redirect_data_, *predictor_->host_redirect_table_cache_);
+  EXPECT_EQ(test_manifest_data_, *predictor_->manifest_table_cache_);
 }
 
 // Single navigation but history count is low, so should not record.
@@ -667,7 +674,8 @@ TEST_F(ResourcePrefetchPredictorTest, NavigationUrlInDB) {
               GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(RedirectDataMap())),
-                         Pointee(ContainerEq(RedirectDataMap()))))
+                         Pointee(ContainerEq(RedirectDataMap())),
+                         Pointee(ContainerEq(ManifestDataMap()))))
       .WillOnce(DoAll(SetArgPointee<0>(test_url_data_),
                       SetArgPointee<1>(test_host_data_)));
   ResetPredictor();
@@ -772,7 +780,8 @@ TEST_F(ResourcePrefetchPredictorTest, NavigationUrlNotInDBAndDBFull) {
               GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(RedirectDataMap())),
-                         Pointee(ContainerEq(RedirectDataMap()))))
+                         Pointee(ContainerEq(RedirectDataMap())),
+                         Pointee(ContainerEq(ManifestDataMap()))))
       .WillOnce(DoAll(SetArgPointee<0>(test_url_data_),
                       SetArgPointee<1>(test_host_data_)));
   ResetPredictor();
@@ -892,7 +901,8 @@ TEST_F(ResourcePrefetchPredictorTest, RedirectUrlInDB) {
               GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(RedirectDataMap())),
-                         Pointee(ContainerEq(RedirectDataMap()))))
+                         Pointee(ContainerEq(RedirectDataMap())),
+                         Pointee(ContainerEq(ManifestDataMap()))))
       .WillOnce(DoAll(SetArgPointee<2>(test_url_redirect_data_),
                       SetArgPointee<3>(test_host_redirect_data_)));
   ResetPredictor();

components/precache/core/proto/precache.proto

@@ -33,6 +33,8 @@ message PrecacheManifestId {
 };
 
 // A manifest of cacheable resources to be precached for a specific host.
+// CAUTION: When any change is done here, bump kDatabaseVersion in
+// chrome/browser/predictors/resource_prefetch_predictor_tables.h
 message PrecacheManifest {
   // List of resources that we predict that the user will need if they are
   // likely to fetch the host.