chrome/browser/predictors/resource_prefetcher.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/predictors/resource_prefetcher.h"
   6
   7 #include <iterator>
   8
   9 #include "base/stl_util.h"
  10 #include "content/public/browser/browser_thread.h"
  11 #include "net/base/io_buffer.h"
  12 #include "net/base/request_priority.h"
  13 #include "net/url_request/url_request_context.h"
  14
  15 namespace {
  16
  17 // The size of the buffer used to read the resource.
  18 static const size_t kResourceBufferSizeBytes = 50000;
  19
  20 }  // namespace
  21
  22 namespace predictors {
  23
  24 ResourcePrefetcher::Request::Request(const GURL& i_resource_url)
  25     : resource_url(i_resource_url),
  26       prefetch_status(PREFETCH_STATUS_NOT_STARTED),
  27       usage_status(USAGE_STATUS_NOT_REQUESTED) {
  28 }
  29
  30 ResourcePrefetcher::Request::Request(const Request& other)
  31     : resource_url(other.resource_url),
  32       prefetch_status(other.prefetch_status),
  33       usage_status(other.usage_status) {
  34 }
  35
  36 ResourcePrefetcher::ResourcePrefetcher(
  37     Delegate* delegate,
  38     const ResourcePrefetchPredictorConfig& config,
  39     const NavigationID& navigation_id,
  40     PrefetchKeyType key_type,
  41     scoped_ptr<RequestVector> requests)
  42         : state_(INITIALIZED),
  43           delegate_(delegate),
  44           config_(config),
  45           navigation_id_(navigation_id),
  46           key_type_(key_type),
  47           request_vector_(requests.Pass()) {
  48   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
  49   DCHECK(request_vector_.get());
  50
  51   std::copy(request_vector_->begin(), request_vector_->end(),
  52             std::back_inserter(request_queue_));
  53 }
  54
  55 ResourcePrefetcher::~ResourcePrefetcher() {
  56   // Delete any pending net::URLRequests.
  57   STLDeleteContainerPairFirstPointers(inflight_requests_.begin(),
  58                                       inflight_requests_.end());
  59 }
  60
  61 void ResourcePrefetcher::Start() {
  62   DCHECK(thread_checker_.CalledOnValidThread());
  63
  64   CHECK_EQ(state_, INITIALIZED);
  65   state_ = RUNNING;
  66
  67   TryToLaunchPrefetchRequests();
  68 }
  69
  70 void ResourcePrefetcher::Stop() {
  71   DCHECK(thread_checker_.CalledOnValidThread());
  72
  73   if (state_ == FINISHED)
  74     return;
  75
  76   state_ = STOPPED;
  77 }
  78
  79 void ResourcePrefetcher::TryToLaunchPrefetchRequests() {
  80   CHECK(state_ == RUNNING || state_ == STOPPED);
  81
  82   // Try to launch new requests if the state is RUNNING.
  83   if (state_ == RUNNING) {
  84     bool request_available = true;
  85
  86     // Loop through the requests while we are under the
  87     // max_prefetches_inflight_per_host_per_navigation limit, looking for a URL
  88     // for which the max_prefetches_inflight_per_host_per_navigation limit has
  89     // not been reached. Try to launch as many requests as possible.
  90     while ((inflight_requests_.size() <
  91                 config_.max_prefetches_inflight_per_navigation) &&
  92            request_available) {
  93       std::list<Request*>::iterator request_it = request_queue_.begin();
  94       for (; request_it != request_queue_.end(); ++request_it) {
  95         const std::string& host = (*request_it)->resource_url.host();
  96
  97         std::map<std::string, size_t>::iterator host_it =
  98             host_inflight_counts_.find(host);
  99         if (host_it == host_inflight_counts_.end() ||
 100             host_it->second <
 101                 config_.max_prefetches_inflight_per_host_per_navigation)
 102           break;
 103       }
 104       request_available = request_it != request_queue_.end();
 105
 106       if (request_available) {
 107         SendRequest(*request_it);
 108         request_queue_.erase(request_it);
 109       }
 110     }
 111   }
 112
 113   // If the inflight_requests_ is empty, we cant launch any more. Finish.
 114   if (inflight_requests_.empty()) {
 115     CHECK(host_inflight_counts_.empty());
 116     CHECK(request_queue_.empty() || state_ == STOPPED);
 117
 118     state_ = FINISHED;
 119     delegate_->ResourcePrefetcherFinished(this, request_vector_.release());
 120   }
 121 }
 122
 123 void ResourcePrefetcher::SendRequest(Request* request) {
 124   request->prefetch_status = Request::PREFETCH_STATUS_STARTED;
 125
 126   net::URLRequest* url_request =
 127       delegate_->GetURLRequestContext()->CreateRequest(
 128           request->resource_url, net::LOW, this, NULL).release();
 129
 130   inflight_requests_[url_request] = request;
 131   host_inflight_counts_[url_request->original_url().host()] += 1;
 132
 133   url_request->set_method("GET");
 134   url_request->set_first_party_for_cookies(navigation_id_.main_frame_url);
 135   url_request->SetReferrer(navigation_id_.main_frame_url.spec());
 136   StartURLRequest(url_request);
 137 }
 138
 139 void ResourcePrefetcher::StartURLRequest(net::URLRequest* request) {
 140   request->Start();
 141 }
 142
 143 void ResourcePrefetcher::FinishRequest(net::URLRequest* request,
 144                                        Request::PrefetchStatus status) {
 145   std::map<net::URLRequest*, Request*>::iterator request_it =
 146       inflight_requests_.find(request);
 147   CHECK(request_it != inflight_requests_.end());
 148
 149   const std::string host = request->original_url().host();
 150   std::map<std::string, size_t>::iterator host_it = host_inflight_counts_.find(
 151       host);
 152   CHECK_GT(host_it->second, 0U);
 153   host_it->second -= 1;
 154   if (host_it->second == 0)
 155     host_inflight_counts_.erase(host);
 156
 157   request_it->second->prefetch_status = status;
 158   inflight_requests_.erase(request_it);
 159
 160   delete request;
 161
 162   TryToLaunchPrefetchRequests();
 163 }
 164
 165 void ResourcePrefetcher::ReadFullResponse(net::URLRequest* request) {
 166   bool status = true;
 167   while (status) {
 168     int bytes_read = 0;
 169     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(
 170         kResourceBufferSizeBytes));
 171     status = request->Read(buffer.get(), kResourceBufferSizeBytes, &bytes_read);
 172
 173     if (status) {
 174       status = ShouldContinueReadingRequest(request, bytes_read);
 175     } else if (request->status().error()) {
 176       FinishRequest(request, Request::PREFETCH_STATUS_FAILED);
 177       return;
 178     }
 179   }
 180 }
 181
 182 bool ResourcePrefetcher::ShouldContinueReadingRequest(net::URLRequest* request,
 183                                                       int bytes_read) {
 184   if (bytes_read == 0) {  // When bytes_read == 0, no more data.
 185     if (request->was_cached())
 186       FinishRequest(request, Request::PREFETCH_STATUS_FROM_CACHE);
 187     else
 188       FinishRequest(request, Request::PREFETCH_STATUS_FROM_NETWORK);
 189     return false;
 190   }
 191
 192   return true;
 193 }
 194
 195 void ResourcePrefetcher::OnReceivedRedirect(
 196     net::URLRequest* request,
 197     const net::RedirectInfo& redirect_info,
 198     bool* defer_redirect) {
 199   FinishRequest(request, Request::PREFETCH_STATUS_REDIRECTED);
 200 }
 201
 202 void ResourcePrefetcher::OnAuthRequired(net::URLRequest* request,
 203                                         net::AuthChallengeInfo* auth_info) {
 204   FinishRequest(request, Request::PREFETCH_STATUS_AUTH_REQUIRED);
 205 }
 206
 207 void ResourcePrefetcher::OnCertificateRequested(
 208     net::URLRequest* request,
 209     net::SSLCertRequestInfo* cert_request_info) {
 210   FinishRequest(request, Request::PREFETCH_STATUS_CERT_REQUIRED);
 211 }
 212
 213 void ResourcePrefetcher::OnSSLCertificateError(net::URLRequest* request,
 214                                                const net::SSLInfo& ssl_info,
 215                                                bool fatal) {
 216   FinishRequest(request, Request::PREFETCH_STATUS_CERT_ERROR);
 217 }
 218
 219 void ResourcePrefetcher::OnResponseStarted(net::URLRequest* request) {
 220   if (request->status().error()) {
 221     FinishRequest(request, Request::PREFETCH_STATUS_FAILED);
 222     return;
 223   }
 224
 225   // TODO(shishir): Do not read cached entries, or ones that are not cacheable.
 226   ReadFullResponse(request);
 227 }
 228
 229 void ResourcePrefetcher::OnReadCompleted(net::URLRequest* request,
 230                                          int bytes_read) {
 231   if (request->status().error()) {
 232     FinishRequest(request, Request::PREFETCH_STATUS_FAILED);
 233     return;
 234   }
 235
 236   if (ShouldContinueReadingRequest(request, bytes_read))
 237     ReadFullResponse(request);
 238 }
 239
 240 }  // namespace predictors