Remove PrerenderResourceThrottle and related infrastructure.

chrome/browser/prerender/prerender_tracker.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 "chrome/browser/prerender/prerender_tracker.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_context.h"
 #include "net/base/load_flags.h"
 
 using content::BrowserThread;
 using content::RenderViewHost;
 
 namespace prerender {
 
 namespace {
 
-bool ShouldCancelRequest(
-    int child_id,
-    int route_id) {
-  // Check if the RenderViewHost associated with (child_id, route_id) no
-  // longer exists, or has already been swapped out for a prerendered page.
-  // If that happens, then we do not want to issue the request which originated
-  // from it. Otherwise, keep it going.
-  // The RenderViewHost may exist for a couple of different reasons: such as
-  // being an XHR from the originating page, being included as an iframe,
-  // being requested as a favicon or stylesheet, and many other corner cases.
-  RenderViewHost* render_view_host =
-      RenderViewHost::FromID(child_id, route_id);
-  if (!render_view_host)
-    return true;
-  PrerenderManager* prerender_manager =
-      FindPrerenderManagerUsingRenderProcessId(child_id);
-  return (prerender_manager &&
-          prerender_manager->IsOldRenderViewHost(render_view_host));
-}
-
-void HandleDelayedRequestOnUIThread(
-    int child_id,
-    int route_id,
-    const PrerenderTracker::CheckURLCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  bool should_cancel = ShouldCancelRequest(child_id, route_id);
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE, base::Bind(callback, !should_cancel));
-}
-
 void DestroyPrerenderForRenderViewOnUI(
     const base::WeakPtr<PrerenderManager>& prerender_manager_weak_ptr,
     int render_process_id,
     int render_view_id,
     FinalStatus final_status) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PrerenderManager* prerender_manager = prerender_manager_weak_ptr.get();
   if (!prerender_manager)
     return;
 
   prerender_manager->DestroyPrerenderForRenderView(
       render_process_id, render_view_id, final_status);
 }
 
-
-void AddURL(const GURL& url, URLCounter* counter) {
-  DCHECK(counter);
-  counter->AddURL(url);
-}
-
-void RemoveURLs(const std::vector<GURL>& urls, URLCounter* counter) {
-  DCHECK(counter);
-  counter->RemoveURLs(urls);
-}
-
 }  // namespace
 
-URLCounter::URLCounter() {
-  // URLCounter is currently constructed on the UI thread but
-  // accessed on the IO thread.
-  DetachFromThread();
-}
-
-URLCounter::~URLCounter() {
-  // URLCounter is currently destructed on the UI thread but
-  // accessed on the IO thread.
-  DetachFromThread();
-}
-
-bool URLCounter::MatchesURL(const GURL& url) const {
-  DCHECK(CalledOnValidThread());
-  URLCountMap::const_iterator it = url_count_map_.find(url);
-  if (it == url_count_map_.end())
-    return false;
-  DCHECK(it->second > 0);
-  return true;
-}
-
-void URLCounter::AddURL(const GURL& url) {
-  DCHECK(CalledOnValidThread());
-  URLCountMap::iterator it = url_count_map_.find(url);
-  if (it == url_count_map_.end())
-    url_count_map_[url] = 1;
-  else
-    it->second++;
-}
-
-void URLCounter::RemoveURLs(const std::vector<GURL>& urls) {
-  DCHECK(CalledOnValidThread());
-  for (std::vector<GURL>::const_iterator it = urls.begin();
-       it != urls.end();
-       ++it) {
-    URLCountMap::iterator map_entry = url_count_map_.find(*it);
-    DCHECK(url_count_map_.end() != map_entry);
-    DCHECK(map_entry->second > 0);
-    --map_entry->second;
-    if (map_entry->second == 0)
-      url_count_map_.erase(map_entry);
-  }
-}
-
 struct RenderViewInfo {
   explicit RenderViewInfo(PrerenderManager* prerender_manager)
       : final_status(FINAL_STATUS_MAX),
         prerender_manager(prerender_manager->AsWeakPtr()) {
   }
   ~RenderViewInfo() {}
 
   FinalStatus final_status;
   base::WeakPtr<PrerenderManager> prerender_manager;
 };
@@ skipping 28 matching lines @@
     int route_id,
     FinalStatus final_status) {
   DCHECK_NE(FINAL_STATUS_USED, final_status);
   DCHECK(final_status >= 0 && final_status < FINAL_STATUS_MAX);
 
   if (!IsPrerenderingOnIOThread(child_id, route_id))
     return false;
   return TryCancel(child_id, route_id, final_status);
 }
 
-bool PrerenderTracker::PotentiallyDelayRequestOnIOThread(
-    const GURL& gurl,
-    int process_id,
-    int route_id,
-    const CheckURLCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (!url_counter_.MatchesURL(gurl))
-    return false;
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&HandleDelayedRequestOnUIThread, process_id, route_id,
-                 callback));
-  return true;
-}
-
-void PrerenderTracker::AddPrerenderURLOnUIThread(const GURL& url) {
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE, base::Bind(&AddURL, url, &url_counter_));
-}
-
-void PrerenderTracker::RemovePrerenderURLsOnUIThread(
-    const std::vector<GURL>& urls) {
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&RemoveURLs, urls, &url_counter_));
-}
-
 bool PrerenderTracker::GetFinalStatus(int child_id, int route_id,
                                       FinalStatus* final_status) const {
   ChildRouteIdPair child_route_id_pair(child_id, route_id);
 
   base::AutoLock lock(final_status_map_lock_);
   FinalStatusMap::const_iterator final_status_it =
       final_status_map_.find(child_route_id_pair);
   if (final_status_map_.end() == final_status_map_.find(child_route_id_pair))
     return false;
   *final_status = final_status_it->second.final_status;
@@ skipping 114 matching lines @@
   GetDefault()->AddPrerenderOnIOThread(child_route_id_pair);
 }
 
 // static
 void PrerenderTracker::RemovePrerenderOnIOThreadTask(
     const ChildRouteIdPair& child_route_id_pair) {
   GetDefault()->RemovePrerenderOnIOThread(child_route_id_pair);
 }
 
 }  // namespace prerender