New link rel=prerender api, using WebKit::WebPrerenderingPlatform

chrome/browser/prerender/prerender_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_PRERENDER_PRERENDER_MANAGER_H_
 #define CHROME_BROWSER_PRERENDER_PRERENDER_MANAGER_H_
 #pragma once
 
 #include <list>
 #include <string>
+#include <utility>
 
 #include "base/gtest_prod_util.h"
 #include "base/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "chrome/browser/prerender/prerender_config.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "chrome/browser/prerender/prerender_origin.h"
 #include "chrome/browser/profiles/profile_keyed_service.h"
 #include "googleurl/src/gurl.h"
 
 class Profile;
 
 namespace base {
 class DictionaryValue;
 }
 
 namespace content {
 class WebContents;
 }
 
+namespace gfx {
+class Size;
+}
+
 #if defined(COMPILER_GCC)
 
 namespace BASE_HASH_NAMESPACE {
 template <>
 struct hash<content::WebContents*> {
   std::size_t operator()(content::WebContents* value) const {
     return reinterpret_cast<std::size_t>(value);
   }
 };
 }
@@ skipping 43 matching lines @@
 
   virtual ~PrerenderManager();
 
   // ProfileKeyedService implementation.
   virtual void Shutdown() OVERRIDE;
 
   // Entry points for adding prerenders.
 
   // Adds a prerender for |url| if valid. |process_id| and |route_id| identify
   // the RenderViewHost that the prerender request came from and are used to
   // set the initial window size of the RenderViewHost used for prerendering.

[dominich, 2012/04/29 18:52:55]

this comment needs to be updated.

[gavinp, 2012/04/30 11:43:16]

Done.

   // Returns true if the URL was added, false if it was not.
   // If the RenderViewHost source is itself prerendering, the prerender is added
   // as a pending prerender.
-  bool AddPrerenderFromLinkRelPrerender(int process_id, int route_id,
-                                        const GURL& url,
-                                        const content::Referrer& referrer);
+  bool AddPrerenderFromLinkRelPrerender(
+      int process_id,
+      int route_id,
+      const GURL& url,
+      const content::Referrer& referrer,
+      const gfx::Size& size,
+      content::SessionStorageNamespace* session_storage_namespace);
 
   // Adds a prerender for |url| if valid. As the prerender request is coming
   // from a source without a RenderViewHost (i.e., the omnibox) we don't have a
   // child or route id, or a referrer. This method uses sensible values for
   // those. The |session_storage_namespace| matches the namespace of the active
   // tab at the time the prerender is generated from the omnibox.
   bool AddPrerenderFromOmnibox(
       const GURL& url,
       content::SessionStorageNamespace* session_storage_namespace);
 
+  // Request cancelation of a previously added prerender. If the add_count_ of
+  // the prerender is one, it will be canceled.  Otherwise, add_count_ will be
+  // decremented by one.
+  void MaybeCancelPrerender(const GURL& url);
+
   // Destroy all prerenders for the given child route id pair and assign a final
   // status to them.
-  virtual void DestroyPrerenderForRenderView(int process_id, int view_id,
+  virtual void DestroyPrerenderForRenderView(int process_id,
+                                             int view_id,
                                              FinalStatus final_status);
 
   // Cancels all active prerenders.
   void CancelAllPrerenders();
 
   // Cancels all active prerenders with the ORIGIN_OMNIBOX origin.
   void CancelOmniboxPrerenders();
 
   // If |url| matches a valid prerendered page, try to swap it into
   // |web_contents| and merge browsing histories. Returns |true| if a
@@ skipping 110 matching lines @@
  protected:
   void SetPrerenderContentsFactory(
       PrerenderContents::Factory* prerender_contents_factory);
 
   // Utility method that is called from the virtual Shutdown method on this
   // class but is called directly from the TestPrerenderManager in the unit
   // tests.
   void DoShutdown();
 
  private:
-  // Needs access to AddPrerender.
-  friend class PrerenderContents;
-
   // Test that needs needs access to internal functions.
   friend class PrerenderBrowserTest;
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, AliasURLTest);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, CancelAllTest);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest,
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, AliasURLTest);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, CancelAllTest);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest,
                            CancelOmniboxRemovesOmniboxTest);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest,
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest,
                            CancelOmniboxDoesNotRemoveLinkTest);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, ClearTest);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, ControlGroup);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, DropOldestRequestTest);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, DropSecondRequestTest);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, ExpireTest);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, FoundTest);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, FragmentMatchesFragmentTest);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, FragmentMatchesPageTest);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, PageMatchesFragmentTest);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, PendingPrerenderTest);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, RateLimitInWindowTest);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, RateLimitOutsideWindowTest);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, SourceRenderViewClosed);
-  FRIEND_TEST_ALL_PREFIXES(PrerenderManagerTest, TwoElementPrerenderTest);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, ClearTest);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, ControlGroup);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, DropOldestRequestTest);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, DropSecondRequestTest);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, ExpireTest);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, FoundTest);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, FragmentMatchesFragmentTest);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, FragmentMatchesPageTest);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, LinkManagerAddTwiceCancelTwice);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, LinkManagerCancel);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, LinkManagerCancelThenAddAgain);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, LinkManagerCancelTwice);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, LinkManagerExpireThenAddAgain);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, LinkManagerExpireThenCancel);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, PageMatchesFragmentTest);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, PendingPrerenderTest);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, RateLimitInWindowTest);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, RateLimitOutsideWindowTest);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, SourceRenderViewClosed);
+  FRIEND_TEST_ALL_PREFIXES(PrerenderTest, TwoElementPrerenderTest);
 
   struct PrerenderContentsData;
   struct NavigationRecord;
 
   class OnCloseTabContentsDeleter;
 
   class MostVisitedSites;
 
   typedef std::list<PrerenderContentsData> PrerenderContentsDataList;
 
   // Adds a prerender for |url| from referrer |referrer| initiated from the
   // RenderViewHost specified by |child_route_id_pair|. The |origin| specifies

[dominich, 2012/04/29 18:52:55]

update comment

[gavinp, 2012/04/30 11:43:16]

Done.

   // how the prerender was added. If the |session_storage_namespace| is NULL,
   // it is discovered using the RenderViewHost specified by
   // |child_route_id_pair|.
   bool AddPrerender(
       Origin origin,
-      const std::pair<int, int>& child_route_id_pair,
+      int child_id,
       const GURL& url,
       const content::Referrer& referrer,
+      const gfx::Size& size,
       content::SessionStorageNamespace* session_storage_namespace);
 
   // Retrieves the PrerenderContents object for the specified URL, if it
   // has been prerendered.  The caller will then have ownership of the
   // PrerenderContents object and is responsible for freeing it.
   // Returns NULL if the specified URL has not been prerendered.
   PrerenderContents* GetEntry(const GURL& url);
 
   // Identical to GetEntry, with one exception:
   // The WebContents specified indicates the WC in which to swap the
@@ skipping 29 matching lines @@
       Origin origin,
       uint8 experiment_id);
 
   // Checks if the PrerenderContents has been added to the pending delete list.
   bool IsPendingDelete(PrerenderContents* entry) const;
 
   // Deletes any PrerenderContents that have been added to the pending delete
   // list.
   void DeletePendingDeleteEntries();
 
-  // Finds the specified PrerenderContents and returns it, if it exists.
-  // Returns NULL otherwise.  Unlike GetEntry, the PrerenderManager maintains
-  // ownership of the PrerenderContents.
+  // Finds the specified PrerenderContentsData/PrerenderContents and returns it,
+  // if it exists. Returns NULL otherwise.  Unlike GetEntry, the
+  // PrerenderManager maintains ownership of the PrerenderContents.
+  PrerenderContentsData* FindEntryData(const GURL& url);
   PrerenderContents* FindEntry(const GURL& url) const;
 
   // Returns the iterator to the PrerenderContentsData entry that is being
   // prerendered from the given child route id pair.
   PrerenderContentsDataList::iterator
       FindPrerenderContentsForChildRouteIdPair(
           const std::pair<int, int>& child_route_id_pair);
 
+  PrerenderContentsDataList::iterator
+      FindPrerenderContentsForURL(const GURL& url);

[dominich, 2012/04/29 18:52:55]

should this also take a session storage namespace parameter?

[gavinp, 2012/04/30 11:43:16]

Yup, if we ever key prerenders on the session storage namespace.  But they're
still keyed only on URL, and we still just fail to use a prerender when a
request comes in for the same URL with a different session storage namespace. 
This CL doesn't change that behaviour; probably it will be fixed as part of any
effort to allow multiple prerenders at the same time.

We might also want to handle common cases of session webstorage being different;
the most sadmaking to me is different tab navigation.  We kill a prerender on
different tab clicks, because of the webstorage being different.  But the vast
majority of the time, the launching page hasn't mutated its storage since
launching the prerender, or the prerender target hasn't read its storage
namespace, or the prerender target is on a different site.  All of these are
fine, with differing amounts of effort.  But now we just kill them all...

[dominich, 2012/04/30 15:52:05]

Or the proposed CL to add a PrerenderHandle.
 

+
   bool DoesRateLimitAllowPrerender() const;
 
   // Deletes old WebContents that have been replaced by prerendered ones.  This
   // is needed because they're replaced in a callback from the old WebContents,
   // so cannot immediately be deleted.
   void DeleteOldTabContents();
 
   // Cleans up old NavigationRecord's.
   void CleanUpOldNavigations();
 
@@ skipping 97 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PrerenderManager);
 };
 
 PrerenderManager* FindPrerenderManagerUsingRenderProcessId(
     int render_process_id);
 
 }  // namespace prerender
 
 #endif  // CHROME_BROWSER_PRERENDER_PRERENDER_MANAGER_H_