predictors: move ResourcePrefetcher handling to LoadingPredictor.

chrome/browser/predictors/resource_prefetcher.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_prefetcher.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
@@ skipping 31 matching lines @@
     : url(url) {}
 
 ResourcePrefetcher::PrefetcherStats::~PrefetcherStats() {}
 
 ResourcePrefetcher::PrefetcherStats::PrefetcherStats(
     const PrefetcherStats& other)
     : url(other.url),
       start_time(other.start_time),
       requests_stats(other.requests_stats) {}
 
-ResourcePrefetcher::ResourcePrefetcher(Delegate* delegate,
-                                       size_t max_concurrent_requests,
-                                       size_t max_concurrent_requests_per_host,
-                                       const GURL& main_frame_url,
-                                       const std::vector<GURL>& urls)
+ResourcePrefetcher::ResourcePrefetcher(
+    base::WeakPtr<Delegate> delegate,
+    scoped_refptr<net::URLRequestContextGetter> context_getter,
+    size_t max_concurrent_requests,
+    size_t max_concurrent_requests_per_host,
+    const GURL& main_frame_url,
+    const std::vector<GURL>& urls)
     : state_(INITIALIZED),
       delegate_(delegate),
+      context_getter_(context_getter),
       max_concurrent_requests_(max_concurrent_requests),
       max_concurrent_requests_per_host_(max_concurrent_requests_per_host),
       main_frame_url_(main_frame_url),
       prefetched_count_(0),
       prefetched_bytes_(0),
+      request_queue_(urls.begin(), urls.end()),

[alexilin, 2017/07/03 15:57:14]

std::move won't really help if we're copying vector content here anyway
oh, |request_queue_| is a list, feel free to drop my std::move() suggestion
above then.

[Benoit L, 2017/07/03 16:19:28]

Ah, indeed, dropping the move and keeping the const refererence should keep the
same number of allocations in the end.
Done.

       stats_(base::MakeUnique<PrefetcherStats>(main_frame_url)) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-
-  std::copy(urls.begin(), urls.end(), std::back_inserter(request_queue_));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 }
 
-ResourcePrefetcher::~ResourcePrefetcher() {}
+ResourcePrefetcher::~ResourcePrefetcher() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+}
 
 void ResourcePrefetcher::Start() {
   TRACE_EVENT_ASYNC_BEGIN0("browser", "ResourcePrefetcher::Prefetch", this);
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   CHECK_EQ(state_, INITIALIZED);
   state_ = RUNNING;
 
   stats_->start_time = base::TimeTicks::Now();
   TryToLaunchPrefetchRequests();
 }
 
 void ResourcePrefetcher::Stop() {
   TRACE_EVENT_ASYNC_END0("browser", "ResourcePrefetcher::Prefetch", this);
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (state_ == FINISHED)
     return;
 
   state_ = STOPPED;
 }
 
 void ResourcePrefetcher::TryToLaunchPrefetchRequests() {
   CHECK(state_ == RUNNING || state_ == STOPPED);
 
@@ skipping 32 matching lines @@
     CHECK(request_queue_.empty() || state_ == STOPPED);
 
     UMA_HISTOGRAM_COUNTS_100(
         internal::kResourcePrefetchPredictorPrefetchedCountHistogram,
         prefetched_count_);
     UMA_HISTOGRAM_COUNTS_10000(
         internal::kResourcePrefetchPredictorPrefetchedSizeHistogram,
         prefetched_bytes_ / 1024);
 
     state_ = FINISHED;
-    delegate_->ResourcePrefetcherFinished(this, std::move(stats_));
+
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::BindOnce(&Delegate::ResourcePrefetcherFinished, delegate_, this,
+                       base::Passed(std::move(stats_))));
   }
 }
 
 void ResourcePrefetcher::SendRequest(const GURL& url) {
   net::NetworkTrafficAnnotationTag traffic_annotation =
       net::DefineNetworkTrafficAnnotation("resource_prefetch", R"(
         semantics {
           sender: "Resource Prefetch"
           description:
             "Speculative Prefetch is based on the observation that users do "
@@ skipping 25 matching lines @@
             "load pages more quickly' setting under Privacy. The feature is "
             "enabled by default."
           chrome_policy {
             NetworkPredictionOptions {
               policy_options {mode: MANDATORY}
               NetworkPredictionOptions: 2
             }
           }
         })");
   std::unique_ptr<net::URLRequest> url_request =
-      delegate_->GetURLRequestContext()->CreateRequest(url, net::IDLE, this,
-                                                       traffic_annotation);
+      context_getter_->GetURLRequestContext()->CreateRequest(
+          url, net::IDLE, this, traffic_annotation);
   host_inflight_counts_[url.host()] += 1;
 
   url_request->set_method("GET");
   url_request->set_first_party_for_cookies(main_frame_url_);
   url_request->set_initiator(url::Origin(main_frame_url_));
 
   content::Referrer referrer(main_frame_url_, blink::kWebReferrerPolicyDefault);
   content::Referrer sanitized_referrer =
       content::Referrer::SanitizeForRequest(url, referrer);
   content::Referrer::SetReferrerForRequest(url_request.get(),
@@ skipping 83 matching lines @@
 
 void ResourcePrefetcher::OnResponseStarted(net::URLRequest* request,
                                            int net_error) {
   DCHECK_NE(net::ERR_IO_PENDING, net_error);
 
   if (net_error != net::OK) {
     FinishRequest(request);
     return;
   }
 
-  // TODO(shishir): Do not read cached entries, or ones that are not cacheable.
   ReadFullResponse(request);
 }
 
 void ResourcePrefetcher::OnReadCompleted(net::URLRequest* request,
                                          int bytes_read) {
   DCHECK_NE(net::ERR_IO_PENDING, bytes_read);
 
   if (bytes_read <= 0) {
     FinishRequest(request);
     return;
   }
 
   if (bytes_read > 0)
     ReadFullResponse(request);
 }
 
 }  // namespace predictors