predictors: Pass manifests from Bork to store in ResourcePrefetchPredictor.

chrome/browser/predictors/resource_prefetch_predictor.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 "chrome/browser/predictors/resource_prefetch_predictor.h"
 
 #include <map>
 #include <set>
 #include <utility>
 
@@ skipping 1069 matching lines @@
   }
 
   data_map->erase(key_to_delete);
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(
           &ResourcePrefetchPredictorTables::DeleteSingleRedirectDataPoint,
           tables_, key_to_delete, key_type));
 }
 
+void ResourcePrefetchPredictor::RemoveOldestEntryInManifestDataMap(
+    ManifestDataMap* data_map) {
+  if (data_map->empty())
+    return;
+
+  auto oldest_entry = std::min_element(
+      data_map->begin(), data_map->end(),
+      [](const std::pair<const std::string, precache::PrecacheManifest>& lhs,
+         const std::pair<const std::string, precache::PrecacheManifest>& rhs) {
+        return lhs.second.id().id() < rhs.second.id().id();

[Benoit L, 2017/03/21 13:24:15]

This means that there is now a constraint that the ID should always be
increasing. Is this checked anywhere?

[alexilin, 2017/03/21 15:32:13]

ID = creation time. So yes, it's always increasing.

+      });
+
+  std::string key_to_delete = oldest_entry->first;
+  data_map->erase(oldest_entry);
+  BrowserThread::PostTask(
+      BrowserThread::DB, FROM_HERE,
+      base::Bind(&ResourcePrefetchPredictorTables::DeleteManifestData, tables_,
+                 std::vector<std::string>({key_to_delete})));
+}
+
 void ResourcePrefetchPredictor::OnVisitCountLookup(
     size_t url_visit_count,
     const PageRequestSummary& summary) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   UMA_HISTOGRAM_COUNTS("ResourcePrefetchPredictor.HistoryVisitCountForUrl",
                        url_visit_count);
 
   // TODO(alexilin): make only one request to DB thread.
 
@@ skipping 316 matching lines @@
   }
 }
 
 void ResourcePrefetchPredictor::OnHistoryServiceLoaded(
     history::HistoryService* history_service) {
   if (initialization_state_ == INITIALIZING) {
     OnHistoryAndCacheLoaded();
   }
 }
 
+void ResourcePrefetchPredictor::OnManifestFetched(
+    const std::string& host,
+    const precache::PrecacheManifest& manifest) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (initialization_state_ != INITIALIZED)
+    return;
+
+  if (host.length() > ResourcePrefetchPredictorTables::kMaxStringLength ||
+      static_cast<uint32_t>(manifest.ByteSize()) >
+          ResourcePrefetchPredictorTables::kMaxManifestByteSize) {
+    return;
+  }
+
+  auto cache_entry = manifest_table_cache_->find(host);
+  if (cache_entry == manifest_table_cache_->end()) {
+    if (manifest_table_cache_->size() >= config_.max_hosts_to_track)
+      RemoveOldestEntryInManifestDataMap(manifest_table_cache_.get());
+    cache_entry =
+        manifest_table_cache_->insert(std::make_pair(host, manifest)).first;
+  } else {
+    cache_entry->second = manifest;
+  }
+
+  BrowserThread::PostTask(
+      BrowserThread::DB, FROM_HERE,
+      base::Bind(&ResourcePrefetchPredictorTables::UpdateManifestData, tables_,
+                 host, cache_entry->second));
+}
+
 void ResourcePrefetchPredictor::ConnectToHistoryService() {
   // Register for HistoryServiceLoading if it is not ready.
   history::HistoryService* history_service =
       HistoryServiceFactory::GetForProfile(profile_,
                                            ServiceAccessType::EXPLICIT_ACCESS);
   if (!history_service)
     return;
   DCHECK(!history_service_observer_.IsObserving(history_service));
   history_service_observer_.Add(history_service);
   if (history_service->BackendLoaded()) {
     // HistoryService is already loaded. Continue with Initialization.
     OnHistoryAndCacheLoaded();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TestObserver.
 
 TestObserver::~TestObserver() {
   predictor_->SetObserverForTesting(nullptr);
 }
 
 TestObserver::TestObserver(ResourcePrefetchPredictor* predictor)
     : predictor_(predictor) {
   predictor_->SetObserverForTesting(this);
 }
 
 }  // namespace predictors