predictors: move ResourcePrefetcher handling to LoadingPredictor.

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>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/predictors/loading_stats_collector.h"
 #include "chrome/browser/predictors/predictor_database.h"
 #include "chrome/browser/predictors/predictor_database_factory.h"
-#include "chrome/browser/predictors/resource_prefetcher_manager.h"
 #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 "components/precache/core/precache_manifest_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "net/http/http_response_headers.h"
@@ skipping 460 matching lines @@
     const base::TimeTicks& first_contentful_paint) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (initialization_state_ != INITIALIZED)
     return;
 
   NavigationMap::iterator nav_it = inflight_navigations_.find(navigation_id);
   if (nav_it != inflight_navigations_.end())
     nav_it->second->first_contentful_paint = first_contentful_paint;
 }
 
-void ResourcePrefetchPredictor::OnPrefetchingFinished(
-    const GURL& main_frame_url,
-    std::unique_ptr<ResourcePrefetcher::PrefetcherStats> stats) {
-  if (observer_)
-    observer_->OnPrefetchingFinished(main_frame_url);
-
-  if (stats_collector_)
-    stats_collector_->RecordPrefetcherStats(std::move(stats));
-}
-
 bool ResourcePrefetchPredictor::IsUrlPrefetchable(
     const GURL& main_frame_url) const {
   return GetPrefetchData(main_frame_url, nullptr);
 }
 
 bool ResourcePrefetchPredictor::IsResourcePrefetchable(
     const ResourceData& resource) const {
   float confidence = static_cast<float>(resource.number_of_hits()) /
                      (resource.number_of_hits() + resource.number_of_misses());
   return confidence >= config_.min_resource_confidence_to_trigger_prefetch &&
          resource.number_of_hits() >=
              config_.min_resource_hits_to_trigger_prefetch;
 }
 
 void ResourcePrefetchPredictor::SetObserverForTesting(TestObserver* observer) {
   observer_ = observer;
 }
 
 void ResourcePrefetchPredictor::SetStatsCollector(
     LoadingStatsCollector* stats_collector) {
   stats_collector_ = stats_collector;
 }
 
 void ResourcePrefetchPredictor::Shutdown() {
-  if (prefetch_manager_.get()) {
-    prefetch_manager_->ShutdownOnUIThread();
-    prefetch_manager_ = nullptr;
-  }
   history_service_observer_.RemoveAll();
 }
 
 void ResourcePrefetchPredictor::OnMainFrameRequest(
     const URLRequestSummary& request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(INITIALIZED, initialization_state_);
 
   CleanupAbandonedNavigations(request.navigation_id);
 
@@ skipping 306 matching lines @@
   manifest_data_ = std::move(manifest_data);
   origin_data_ = std::move(origin_data);
 
   ConnectToHistoryService();
 }
 
 void ResourcePrefetchPredictor::OnHistoryAndCacheLoaded() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(INITIALIZING, initialization_state_);
 
-  // Initialize the prefetch manager only if prefetching is enabled.
-  if (config_.IsPrefetchingEnabledForSomeOrigin(profile_)) {
-    prefetch_manager_ = new ResourcePrefetcherManager(
-        this, config_, profile_->GetRequestContext());
-  }
   initialization_state_ = INITIALIZED;
-
   if (observer_)
     observer_->OnPredictorInitialized();
 }
 
 void ResourcePrefetchPredictor::CleanupAbandonedNavigations(
     const NavigationID& navigation_id) {
   if (stats_collector_)
     stats_collector_->CleanupAbandonedStats();
 
   static const base::TimeDelta max_navigation_age =
@@ skipping 496 matching lines @@
   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();
   }
 }
 
-void ResourcePrefetchPredictor::StartPrefetching(
-    const GURL& url,
-    const ResourcePrefetchPredictor::Prediction& prediction) {
-  TRACE_EVENT1("browser", "ResourcePrefetchPredictor::StartPrefetching", "url",
-               url.spec());
-  if (!prefetch_manager_.get())  // Not enabled.
-    return;
-
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&ResourcePrefetcherManager::MaybeAddPrefetch,
-                     prefetch_manager_, url, prediction.subresource_urls));
-
-  if (observer_)
-    observer_->OnPrefetchingStarted(url);
-}
-
-void ResourcePrefetchPredictor::StopPrefetching(const GURL& url) {
-  TRACE_EVENT1("browser", "ResourcePrefetchPredictor::StopPrefetching", "url",
-               url.spec());
-  if (!prefetch_manager_.get())  // Not enabled.
-    return;
-
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&ResourcePrefetcherManager::MaybeRemovePrefetch,
-                     prefetch_manager_, url));
-
-  if (observer_)
-    observer_->OnPrefetchingStopped(url);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // TestObserver.
 
 TestObserver::~TestObserver() {
   predictor_->SetObserverForTesting(nullptr);
 }
 
 TestObserver::TestObserver(ResourcePrefetchPredictor* predictor)
     : predictor_(predictor) {
   predictor_->SetObserverForTesting(this);
 }
 
 }  // namespace predictors