Cancel prerenders that spawn post requests.

chrome/browser/prerender/prerender_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_PRERENDER_PRERENDER_MANAGER_H_
 #define CHROME_BROWSER_PRERENDER_PRERENDER_MANAGER_H_
 #pragma once
 
 #include <list>
 #include <map>
@@ skipping 26 matching lines @@
 
 namespace prerender {
 
 void HandlePrefetchTagOnUIThread(
     const base::WeakPtr<PrerenderManager>& prerender_manager,
     const std::pair<int, int>& child_route_id_pair,
     const GURL& url,
     const GURL& referrer,
     bool make_pending);
 
+void DestroyPreloadForChildRouteIdPairOnUIThread(

[jam, 2011/05/02 16:21:33]

nit: this name seems a bit long.  we usually use "Child" when it's something
that applies for different child  process types, i.e. renderer/worker/plugin
etc.

in this case, prerendering is only for renderers, so it can be

void DestroyPreloadForRenderView and you can pass in "int render_process_id, int
render_view_id".  also, is the OnUIThread necessary in the name?  it can have a
DCHECK that it's being called on the right thread.  there should be a comment on
this function anyways, and it can specify which thread it's safe to call on.

[dominich, 2011/05/02 16:45:55]

Done and I will fix the HandlePrefetchTag above to have the same.
It has a DCHECK and will have a comment. I will also change the
HandlePrefetchTagOnUIThread above to not have the OnUIThread suffix and have a
comment instead.

+    const base::WeakPtr<PrerenderManager>& prerender_manager_weak_ptr,
+    const std::pair<int, int>& child_route_id_pair,
+    FinalStatus final_status);
+
 // PrerenderManager is responsible for initiating and keeping prerendered
 // views of webpages. All methods must be called on the UI thread unless
 // indicated otherwise.
 class PrerenderManager : public base::SupportsWeakPtr<PrerenderManager>,
                          public base::NonThreadSafe {
  public:
   // PrerenderManagerMode is used in a UMA_HISTOGRAM, so please do not
   // add in the middle.
   enum PrerenderManagerMode {
     PRERENDER_MODE_DISABLED,
@@ skipping 14 matching lines @@
   // Returns true if the URL was added, false if it was not.
   bool AddPreload(
       const std::pair<int, int>& child_route_id_pair,
       const GURL& url,
       const GURL& referrer);
 
   void AddPendingPreload(const std::pair<int, int>& child_route_id_pair,
                          const GURL& url,
                          const GURL& referrer);
 
+  // Destroy all preloads for the given child route id pair and assign a final
+  // status to them.
+  void DestroyPreloadForChildRouteIdPair(
+      const std::pair<int, int>& child_route_id_pair,
+      FinalStatus final_status);
+
   // For a given TabContents that wants to navigate to the URL supplied,
   // determines whether a preloaded version of the URL can be used,
   // and substitutes the prerendered RVH into the TabContents.  Returns
   // whether or not a prerendered RVH could be used or not.
   bool MaybeUsePreloadedPage(TabContents* tab_contents, const GURL& url);
 
   // Allows PrerenderContents to remove itself when prerendering should
   // be cancelled.
   void RemoveEntry(PrerenderContents* entry);
 
@@ skipping 47 matching lines @@
   void MarkTabContentsAsNotPrerendered(TabContents* tab_contents);
   bool IsTabContentsPrerendered(TabContents* tab_contents) const;
   bool WouldTabContentsBePrerendered(TabContents* tab_contents) const;
 
   // Extracts a urlencoded URL stored in a url= query parameter from a URL
   // supplied, if available, and stores it in alias_url.  Returns whether or not
   // the operation succeeded (i.e. a valid URL was found).
   static bool MaybeGetQueryStringBasedAliasURL(const GURL& url,
                                                GURL* alias_url);
 
+  // Returns true if the method given is invalid for prerendering.
+  static bool IsValidHttpMethod(const std::string& method);
+
  protected:
   struct PendingContentsData;
 
   void SetPrerenderContentsFactory(
       PrerenderContents::Factory* prerender_contents_factory);
   bool rate_limit_enabled_;
 
   PendingContentsData* FindPendingEntry(const GURL& url);
 
  private:
@@ skipping 19 matching lines @@
   virtual base::TimeTicks GetCurrentTimeTicks() const;
   virtual PrerenderContents* CreatePrerenderContents(
       const GURL& url,
       const GURL& referrer);
 
   // Finds the specified PrerenderContents and returns it, if it exists.
   // Returns NULL otherwise.  Unlike GetEntry, the PrerenderManager maintains
   // ownership of the PrerenderContents.
   PrerenderContents* FindEntry(const GURL& url);
 
+  // Returns the iterator to the PrerenderContentsData entry that is being
+  // prerendered from the given child route id pair.
+  std::list<PrerenderContentsData>::iterator
+      FindPrerenderContentsForChildRouteIdPair(
+          const std::pair<int, int>& child_route_id_pair);
+
   // Returns whether the PrerenderManager is currently within the prerender
   // window - effectively, up to 30 seconds after a prefetch tag has been
   // observed.
   bool WithinWindow() const;
 
   // Called when removing a preload to ensure we clean up any pending preloads
   // that might remain in the map.
   void RemovePendingPreload(PrerenderContents* entry);
 
   bool DoesRateLimitAllowPrerender() const;
@@ skipping 45 matching lines @@
 
   // Track time of last prerender to limit prerender spam.
   base::TimeTicks last_prerender_start_time_;
 
   DISALLOW_COPY_AND_ASSIGN(PrerenderManager);
 };
 
 }  // namespace prerender
 
 #endif  // CHROME_BROWSER_PRERENDER_PRERENDER_MANAGER_H_