Remove the speculative resource prefetching code. This was experimental code added 1.5 years ago an…

chrome/browser/predictors/resource_prefetcher.cc

-// Copyright (c) 2012 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 <iterator>
-
-#include "chrome/browser/predictors/resource_prefetcher.h"
-
-#include "base/stl_util.h"
-#include "content/public/browser/browser_thread.h"
-#include "net/base/io_buffer.h"
-#include "net/base/request_priority.h"
-#include "net/url_request/url_request_context.h"
-
-namespace {
-
-// The size of the buffer used to read the resource.
-static const size_t kResourceBufferSizeBytes = 50000;
-
-}  // namespace
-
-namespace predictors {
-
-ResourcePrefetcher::Request::Request(const GURL& i_resource_url)
-    : resource_url(i_resource_url),
-      prefetch_status(PREFETCH_STATUS_NOT_STARTED),
-      usage_status(USAGE_STATUS_NOT_REQUESTED) {
-}
-
-ResourcePrefetcher::Request::Request(const Request& other)
-    : resource_url(other.resource_url),
-      prefetch_status(other.prefetch_status),
-      usage_status(other.usage_status) {
-}
-
-ResourcePrefetcher::ResourcePrefetcher(
-    Delegate* delegate,
-    const ResourcePrefetchPredictorConfig& config,
-    const NavigationID& navigation_id,
-    PrefetchKeyType key_type,
-    scoped_ptr<RequestVector> requests)
-        : state_(INITIALIZED),
-          delegate_(delegate),
-          config_(config),
-          navigation_id_(navigation_id),
-          key_type_(key_type),
-          request_vector_(requests.Pass()) {
-  CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  DCHECK(request_vector_.get());
-
-  std::copy(request_vector_->begin(), request_vector_->end(),
-            std::back_inserter(request_queue_));
-}
-
-ResourcePrefetcher::~ResourcePrefetcher() {
-  // Delete any pending net::URLRequests.
-  STLDeleteContainerPairFirstPointers(inflight_requests_.begin(),
-                                      inflight_requests_.end());
-}
-
-void ResourcePrefetcher::Start() {
-  CHECK(CalledOnValidThread());
-
-  CHECK_EQ(state_, INITIALIZED);
-  state_ = RUNNING;
-
-  TryToLaunchPrefetchRequests();
-}
-
-void ResourcePrefetcher::Stop() {
-  CHECK(CalledOnValidThread());
-
-  if (state_ == FINISHED)
-    return;
-
-  state_ = STOPPED;
-}
-
-void ResourcePrefetcher::TryToLaunchPrefetchRequests() {
-  CHECK(state_ == RUNNING || state_ == STOPPED);
-
-  // Try to launch new requests if the state is RUNNING.
-  if (state_ == RUNNING) {
-    bool request_available = true;
-
-    // Loop through the requests while we are under the
-    // max_prefetches_inflight_per_host_per_navigation limit, looking for a URL
-    // for which the max_prefetches_inflight_per_host_per_navigation limit has
-    // not been reached. Try to launch as many requests as possible.
-    while ((static_cast<int>(inflight_requests_.size()) <
-                config_.max_prefetches_inflight_per_navigation) &&
-           request_available) {
-      std::list<Request*>::iterator request_it = request_queue_.begin();
-      for (; request_it != request_queue_.end(); ++request_it) {
-        const std::string& host = (*request_it)->resource_url.host();
-
-        std::map<std::string, int>::iterator host_it =
-            host_inflight_counts_.find(host);
-        if (host_it == host_inflight_counts_.end() ||
-            host_it->second <
-                config_.max_prefetches_inflight_per_host_per_navigation)
-          break;
-      }
-      request_available = request_it != request_queue_.end();
-
-      if (request_available) {
-        SendRequest(*request_it);
-        request_queue_.erase(request_it);
-      }
-    }
-  }
-
-  // If the inflight_requests_ is empty, we cant launch any more. Finish.
-  if (inflight_requests_.empty()) {
-    CHECK(host_inflight_counts_.empty());
-    CHECK(request_queue_.empty() || state_ == STOPPED);
-
-    state_ = FINISHED;
-    delegate_->ResourcePrefetcherFinished(this, request_vector_.release());
-  }
-}
-
-void ResourcePrefetcher::SendRequest(Request* request) {
-  request->prefetch_status = Request::PREFETCH_STATUS_STARTED;
-
-  net::URLRequest* url_request = new net::URLRequest(
-      request->resource_url, net::LOW, this, delegate_->GetURLRequestContext());
-  inflight_requests_[url_request] = request;
-  host_inflight_counts_[url_request->original_url().host()] += 1;
-
-  url_request->set_method("GET");
-  url_request->set_first_party_for_cookies(navigation_id_.main_frame_url);
-  url_request->SetReferrer(navigation_id_.main_frame_url.spec());
-  StartURLRequest(url_request);
-}
-
-void ResourcePrefetcher::StartURLRequest(net::URLRequest* request) {
-  request->Start();
-}
-
-void ResourcePrefetcher::FinishRequest(net::URLRequest* request,
-                                       Request::PrefetchStatus status) {
-  std::map<net::URLRequest*, Request*>::iterator request_it =
-      inflight_requests_.find(request);
-  CHECK(request_it != inflight_requests_.end());
-
-  const std::string host = request->original_url().host();
-  std::map<std::string, int>::iterator host_it = host_inflight_counts_.find(
-      host);
-  CHECK_GT(host_it->second, 0);
-  host_it->second -= 1;
-  if (host_it->second == 0)
-    host_inflight_counts_.erase(host);
-
-  request_it->second->prefetch_status = status;
-  inflight_requests_.erase(request_it);
-
-  delete request;
-
-  TryToLaunchPrefetchRequests();
-}
-
-void ResourcePrefetcher::ReadFullResponse(net::URLRequest* request) {
-  bool status = true;
-  while (status) {
-    int bytes_read = 0;
-    scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(
-        kResourceBufferSizeBytes));
-    status = request->Read(buffer.get(), kResourceBufferSizeBytes, &bytes_read);
-
-    if (status) {
-      status = ShouldContinueReadingRequest(request, bytes_read);
-    } else if (request->status().error()) {
-      FinishRequest(request, Request::PREFETCH_STATUS_FAILED);
-      return;
-    }
-  }
-}
-
-bool ResourcePrefetcher::ShouldContinueReadingRequest(net::URLRequest* request,
-                                                      int bytes_read) {
-  if (bytes_read == 0) {  // When bytes_read == 0, no more data.
-    if (request->was_cached())
-      FinishRequest(request, Request::PREFETCH_STATUS_FROM_CACHE);
-    else
-      FinishRequest(request, Request::PREFETCH_STATUS_FROM_NETWORK);
-    return false;
-  }
-
-  return true;
-}
-
-void ResourcePrefetcher::OnReceivedRedirect(net::URLRequest* request,
-                                            const GURL& new_url,
-                                            bool* defer_redirect) {
-  FinishRequest(request, Request::PREFETCH_STATUS_REDIRECTED);
-}
-
-void ResourcePrefetcher::OnAuthRequired(net::URLRequest* request,
-                                        net::AuthChallengeInfo* auth_info) {
-  FinishRequest(request, Request::PREFETCH_STATUS_AUTH_REQUIRED);
-}
-
-void ResourcePrefetcher::OnCertificateRequested(
-    net::URLRequest* request,
-    net::SSLCertRequestInfo* cert_request_info) {
-  FinishRequest(request, Request::PREFETCH_STATUS_CERT_REQUIRED);
-}
-
-void ResourcePrefetcher::OnSSLCertificateError(net::URLRequest* request,
-                                               const net::SSLInfo& ssl_info,
-                                               bool fatal) {
-  FinishRequest(request, Request::PREFETCH_STATUS_CERT_ERROR);
-}
-
-void ResourcePrefetcher::OnResponseStarted(net::URLRequest* request) {
-  if (request->status().error()) {
-    FinishRequest(request, Request::PREFETCH_STATUS_FAILED);
-    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) {
-  if (request->status().error()) {
-    FinishRequest(request, Request::PREFETCH_STATUS_FAILED);
-    return;
-  }
-
-  if (ShouldContinueReadingRequest(request, bytes_read))
-    ReadFullResponse(request);
-}
-
-}  // namespace predictors