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 32 matching lines @@
 // Time window for which we will record windowed PLT's from the last
 // observed link rel=prefetch tag.
 const int kWindowDurationSeconds = 30;
 
 // Time interval at which periodic cleanups are performed.
 const int kPeriodicCleanupIntervalMs = 1000;
 
 // Time interval before a new prerender is allowed.
 const int kMinTimeBetweenPrerendersMs = 500;
 
+// Valid HTTP methods for prerendering.
+const char* const kValidHttpMethods[] = {
+  "OPTIONS",
+  "GET",
+  "HEAD",
+  "TRACE",
+};
+
 }  // namespace
 
 // static
 int PrerenderManager::prerenders_per_session_count_ = 0;
 
 // static
 PrerenderManager::PrerenderManagerMode PrerenderManager::mode_ =
     PRERENDER_MODE_ENABLED;
 
 // static
@@ skipping 41 matching lines @@
     GURL new_url(string16(decoded_url.data(), decoded_url.length()));
     if (!new_url.is_empty() && new_url.is_valid()) {
       *alias_url = new_url;
       return true;
     }
     return false;
   }
   return false;
 }
 
+// static
+bool PrerenderManager::IsValidHttpMethod(const std::string& method) {
+  // method has been canonicalized to upper case at this point so we can just
+  // compare them.
+  DCHECK_EQ(method, StringToUpperASCII(method));
+  for (size_t i = 0; i < arraysize(kValidHttpMethods); ++i) {
+    if (method.compare(kValidHttpMethods[i]) == 0)
+      return true;
+  }
+
+  return false;
+}
+
 struct PrerenderManager::PrerenderContentsData {
   PrerenderContents* contents_;
   base::Time start_time_;
   PrerenderContentsData(PrerenderContents* contents, base::Time start_time)
       : contents_(contents),
         start_time_(start_time) {
   }
 };
 
 struct PrerenderManager::PendingContentsData {
   PendingContentsData(const GURL& url,
                       const GURL& referrer)
       : url_(url), referrer_(referrer) { }
   ~PendingContentsData() {}
   GURL url_;
   GURL referrer_;
 };
 
-void HandlePrefetchTagOnUIThread(
+void HandlePrefetchTag(
     const base::WeakPtr<PrerenderManager>& prerender_manager_weak_ptr,
-    const std::pair<int, int>& child_route_id_pair,
+    int render_process_id,
+    int render_view_id,
     const GURL& url,
     const GURL& referrer,
     bool make_pending) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PrerenderManager* prerender_manager = prerender_manager_weak_ptr.get();
   if (!prerender_manager || !prerender_manager->is_enabled())
     return;
   prerender_manager->RecordPrefetchTagObserved();
+
+  std::pair<int, int> child_route_id_pair = std::make_pair(render_process_id,
+                                                           render_view_id);
   // 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 DestroyPreloadForRenderView(
+    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->DestroyPreloadForChildRouteIdPair(
+      std::make_pair(render_process_id, render_view_id),
+      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 98 matching lines @@
   StartSchedulingPeriodicCleanups();
   return true;
 }
 
 void PrerenderManager::AddPendingPreload(
     const std::pair<int, int>& child_route_id_pair,
     const GURL& url,
     const GURL& referrer) {
   DCHECK(CalledOnValidThread());
   // Check if this is coming from a valid prerender RenderViewHost.
-  bool is_valid_prerender = false;
-  for (std::list<PrerenderContentsData>::iterator it = prerender_list_.begin();
-       it != prerender_list_.end(); ++it) {
-    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) {
-      is_valid_prerender = true;
-      break;
-    }
-  }
+  bool is_valid_prerender =
+      (FindPrerenderContentsForChildRouteIdPair(child_route_id_pair) !=
+       prerender_list_.end());
 
   // If not, we could check to see if the RenderViewHost specified by the
   // child_route_id_pair exists and if so just start prerendering, as this
   // suggests that the link was clicked, though this might prerender something
   // that the user has already navigated away from. For now, we'll be
   // conservative and skip the prerender which will mean some prerender requests
   // from prerendered pages will be missed if the user navigates quickly.
   if (!is_valid_prerender) {
     RecordFinalStatus(FINAL_STATUS_PENDING_SKIPPED);
     return;
   }
 
   PendingPrerenderList::iterator it =
       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));
 }
 
+std::list<PrerenderManager::PrerenderContentsData>::iterator
+    PrerenderManager::FindPrerenderContentsForChildRouteIdPair(
+        const std::pair<int, int>& child_route_id_pair) {
+  std::list<PrerenderContentsData>::iterator it = prerender_list_.begin();
+  for (; it != prerender_list_.end(); ++it) {
+    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) {
+      break;
+    }
+  }
+  return it;
+}
+
+void PrerenderManager::DestroyPreloadForChildRouteIdPair(
+    const std::pair<int, int>& child_route_id_pair,
+    FinalStatus final_status) {
+  DCHECK(CalledOnValidThread());
+  std::list<PrerenderContentsData>::iterator it =
+      FindPrerenderContentsForChildRouteIdPair(child_route_id_pair);
+  if (it != prerender_list_.end()) {
+    PrerenderContents* prerender_contents = it->contents_;
+    prerender_contents->set_final_status(final_status);
+    RemovePendingPreload(prerender_contents);
+
+    delete prerender_contents;
+    prerender_list_.erase(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 449 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