Cancel prerenders that spawn post requests.

chrome/browser/prerender/prerender_manager.cc

 // Copyright (c) 2011 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_manager.h"
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/time.h"
@@ skipping 129 matching lines @@
   prerender_manager->RecordPrefetchTagObserved();
   // TODO(cbentzel): Should the decision to make pending be done on the
   //                 UI thread rather than the IO thread? The page may have
   //                 become activated at this point.
   if (make_pending)
     prerender_manager->AddPendingPreload(child_route_id_pair, url, referrer);
   else
     prerender_manager->AddPreload(child_route_id_pair, url, referrer);
 }
 
+void DestroyPreloadForChildRouteIdPairOnUIThread(
+    const base::WeakPtr<PrerenderManager>& prerender_manager_weak_ptr,
+    const std::pair<int, int>& child_route_id_pair,
+    FinalStatus final_status) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  PrerenderManager* prerender_manager = prerender_manager_weak_ptr.get();
+  if (!prerender_manager || !prerender_manager->is_enabled())
+    return;
+  prerender_manager->DestroyPreloadForChildRouteIdPair(child_route_id_pair,
+                                                       final_status);
+}
+
 PrerenderManager::PrerenderManager(Profile* profile)
     : rate_limit_enabled_(true),
       enabled_(true),
       profile_(profile),
       max_prerender_age_(base::TimeDelta::FromSeconds(
           kDefaultMaxPrerenderAgeSeconds)),
       max_prerender_memory_mb_(kDefaultMaxPrerenderMemoryMB),
       max_elements_(kDefaultMaxPrerenderElements),
       prerender_contents_factory_(PrerenderContents::CreateFactory()),
       last_prerender_start_time_(GetCurrentTimeTicks() -
@@ skipping 139 matching lines @@
       pending_prerender_list_.find(child_route_id_pair);
   if (it == pending_prerender_list_.end()) {
     PendingPrerenderList::value_type el = std::make_pair(child_route_id_pair,
                                             std::vector<PendingContentsData>());
     it = pending_prerender_list_.insert(el).first;
   }
 
   it->second.push_back(PendingContentsData(url, referrer));
 }
 
+void PrerenderManager::DestroyPreloadForChildRouteIdPair(
+    const std::pair<int, int>& child_route_id_pair,
+    FinalStatus final_status) {
+  DCHECK(CalledOnValidThread());
+  for (std::list<PrerenderContentsData>::iterator it = prerender_list_.begin();
+       it != prerender_list_.end();) {
+    PrerenderContents* prerender_contents = it->contents_;
+
+    int child_id;
+    int route_id;
+    bool has_child_id = prerender_contents->GetChildId(&child_id);
+    bool has_route_id = has_child_id &&
+                        prerender_contents->GetRouteId(&route_id);
+
+    if (has_child_id && has_route_id &&
+        child_id == child_route_id_pair.first &&
+        route_id == child_route_id_pair.second) {
+      prerender_contents->set_final_status(final_status);
+      RemovePendingPreload(prerender_contents);
+      delete prerender_contents;
+      it = prerender_list_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
 void PrerenderManager::DeleteOldEntries() {
   DCHECK(CalledOnValidThread());
   while (!prerender_list_.empty()) {
     PrerenderContentsData data = prerender_list_.front();
     if (IsPrerenderElementFresh(data.start_time_))
       return;
     prerender_list_.pop_front();
     data.contents_->set_final_status(FINAL_STATUS_TIMED_OUT);
     delete data.contents_;
   }
@@ skipping 359 matching lines @@
   return prerendered_tab_contents_set_.count(tab_contents) > 0;
 }
 
 bool PrerenderManager::WouldTabContentsBePrerendered(
     TabContents* tab_contents) const {
   DCHECK(CalledOnValidThread());
   return would_be_prerendered_tab_contents_set_.count(tab_contents) > 0;
 }
 
 }  // namespace prerender