Handle interface to prerenders.

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_handle.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;
 }
 
@@ skipping 66 matching lines @@
 
   // Entry points for adding prerenders.
 
   // Adds a prerender for |url| if valid. |process_id| and |route_id| identify
   // the RenderView that the prerender request came from.  The |size| may be
   // empty, and the current tab size will be used if it is. If the current
   // active tab size cannot be found, we use a default from PrerenderConfig.
   // Returns true if the URL was added, false if it was not.
   // If the launching RenderView is itself prerendering, the prerender is added
   // as a pending prerender.
-  bool AddPrerenderFromLinkRelPrerender(
+  PrerenderHandle AddPrerenderFromLinkRelPrerender(
       int process_id,
       int route_id,
       const GURL& url,
       const content::Referrer& referrer,
       const gfx::Size& size);
 
   // 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(
+  PrerenderHandle AddPrerenderFromOmnibox(
       const GURL& url,
       content::SessionStorageNamespace* session_storage_namespace);
 
-  // Request cancelation of a previously added prerender. If the |active_count_|
-  // of the prerender is one, it will be canceled.  Otherwise, |active_count_|
-  // will be decremented by one.
-  void MaybeCancelPrerender(const GURL& url);

[dominich, 2012/06/18 15:32:44]

explicit cancellation is the bomb. Why would you remove it? If nothing in this
class takes a PrerenderHandle as a parameter, then why do you return one from
the public interface?

-
   // 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,
                                              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
   // prerendered page is swapped in, |false| otherwise.
   bool MaybeUsePrerenderedPage(content::WebContents* web_contents,
                                const GURL& url);
 
   // Moves a PrerenderContents to the pending delete list from the list of
   // active prerenders when prerendering should be cancelled.
-  void MoveEntryToPendingDelete(PrerenderContents* entry,
+  void MoveEntryToPendingDelete(WeakPrerenderHandle prerender,
                                 FinalStatus final_status);
 
   // Records the perceived page load time for a page - effectively the time from
   // when the user navigates to a page to when it finishes loading. The actual
   // load may have started prior to navigation due to prerender hints.
   // This must be called on the UI thread.
   // |fraction_plt_elapsed_at_swap_in| must either be in [0.0, 1.0], or a value
   // outside that range indicating that it doesn't apply.
   static void RecordPerceivedPageLoadTime(
       base::TimeDelta perceived_page_load_time,
@@ skipping 17 matching lines @@
   static const char* GetModeString();
   static bool IsPrerenderingPossible();
   static bool ActuallyPrerendering();
   static bool IsControlGroup();
   static bool IsNoUseGroup();
 
   // Query the list of current prerender pages to see if the given web contents
   // is prerendering a page.
   bool IsWebContentsPrerendering(content::WebContents* web_contents) const;
 
-  // Returns true if there is a prerendered page for the given URL and it has
-  // finished loading. Only valid if called before MaybeUsePrerenderedPage.
-  bool DidPrerenderFinishLoading(const GURL& url) const;
-
   // Maintaining and querying the set of WebContents belonging to this
   // PrerenderManager that are currently showing prerendered pages.
   void MarkWebContentsAsPrerendered(content::WebContents* web_contents);
   void MarkWebContentsAsWouldBePrerendered(content::WebContents* web_contents);
   void MarkWebContentsAsNotPrerendered(content::WebContents* web_contents);
   bool IsWebContentsPrerendered(content::WebContents* web_contents) const;
   bool WouldWebContentsBePrerendered(content::WebContents* web_contents) const;
 
   // Checks whether |url| has been recently navigated to.
   bool HasRecentlyBeenNavigatedTo(const GURL& url);
@@ skipping 51 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();
 
+  const PrerenderContents* FindPrerender(const GURL& url) const;

[dominich, 2012/06/18 15:32:44]

Should this still be needed? I thought the point was to get rid of interfaces
like this. If it is, it should take a SessionStorageNamespace at least.

+
+  PrerenderContents* ClaimPrerender(
+      content::WebContents* web_contents,
+      const GURL& url,
+      content::SessionStorageNamespace* session_storage_namespace);
+
  private:
   // Test that needs needs access to internal functions.
   friend class PrerenderBrowserTest;
+  friend class PrerenderTest;
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest, AliasURLTest);
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest, CancelAllTest);
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest,
                            CancelOmniboxRemovesOmniboxTest);
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest,
                            CancelOmniboxDoesNotRemoveLinkTest);
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest, ClearTest);
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest, ControlGroup);
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest, DropOldestRequestTest);
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest, DropSecondRequestTest);
@@ skipping 15 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest, NotSoRecentlyVisited);
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest, PageMatchesFragmentTest);
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest, PendingPrerenderTest);
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest, PPLTDummy);
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest, RateLimitInWindowTest);
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest, RateLimitOutsideWindowTest);
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest, RecentlyVisitedPPLTDummy);
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest, SourceRenderViewClosed);
   FRIEND_TEST_ALL_PREFIXES(PrerenderTest, TwoElementPrerenderTest);
 
-  struct PrerenderContentsData;
+  class OnCloseTabContentsDeleter;
+  class PrerenderContentsData;
   struct NavigationRecord;
 
-  class OnCloseTabContentsDeleter;
-
-  typedef std::list<PrerenderContentsData> PrerenderContentsDataList;
+  typedef std::list<base::WeakPtr<PrerenderContentsData> >

[dominich, 2012/06/18 15:32:44]

Shouldn't this now be a list of PrerenderHandles from which the
PrerenderContentsData can be determined?

[gavinp, 2012/06/18 16:40:48]

I was really hoping to avoid a lot of "IsCanceled" logic. So that's why the
WeakPtrs.

But now I'm thinking an Observer interface with OnDestroy is the way to go;
Observers can do things like take themselves out of this list.

So yes, explicit cancellation, and sure, PrerenderHandles here, but they will
remove themselves from the list when they get OnDestroy

+      PrerenderContentsDataList;
   typedef base::hash_map<content::WebContents*, bool> WouldBePrerenderedMap;
 
   // Time window for which we record old navigations, in milliseconds.
   static const int kNavigationRecordWindowMs = 5000;
 
   // Adds a prerender for |url| from referrer |referrer| initiated from the
   // child process specified by |child_id|. The |origin| specifies how the
   // prerender was added. If the |size| is empty, then
   // PrerenderContents::StartPrerendering will instead use the size of the
   // currently active tab. If the current active tab size cannot be found, it
   // then uses a default from PrerenderConfig.
-  bool AddPrerender(
+  PrerenderHandle AddPrerender(
       Origin origin,
       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
-  // prerendering into.  If the WebContents specified is the one
-  // to doing the prerendered itself, will return NULL.
-  PrerenderContents* GetEntryButNotSpecifiedWC(const GURL& url,
-                                               content::WebContents* wc);
-
   // Starts scheduling periodic cleanups.
   void StartSchedulingPeriodicCleanups();
   // Stops scheduling periodic cleanups if they're no longer needed.
   void MaybeStopSchedulingPeriodicCleanups();
 
   // Deletes stale and cancelled prerendered PrerenderContents, as well as
   // WebContents that have been replaced by prerendered WebContents.
   // Also identifies and kills PrerenderContents that use too much
   // resources.
   void PeriodicCleanup();
 
   // Posts a task to call PeriodicCleanup.  Results in quicker destruction of
   // objects.  If |this| is deleted before the task is run, the task will
   // automatically be cancelled.
   void PostCleanupTask();
 
   base::TimeDelta GetMaxAge() const;
-  bool IsPrerenderElementFresh(const base::Time start) const;
   void DeleteOldEntries();
   virtual base::Time GetCurrentTime() const;
   virtual base::TimeTicks GetCurrentTimeTicks() const;
   virtual PrerenderContents* CreatePrerenderContents(
       const GURL& url,
       const content::Referrer& referrer,
       Origin origin,
       uint8 experiment_id);
 
   // Deletes any PrerenderContents that have been added to the pending delete
   // list.
   void DeletePendingDeleteEntries();
 
-  // 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;
+  const PrerenderContentsData* FindContentsData(PrerenderHandle handle) const;
+  PrerenderContentsData* FindContentsDataMutable(PrerenderHandle handle);
 
-  // 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);
+  PrerenderContentsData*
+      FindContentsDataForChildAndRouteId(int child_id, int route_id);
 
   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 103 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PrerenderManager);
 };
 
 PrerenderManager* FindPrerenderManagerUsingRenderProcessId(
     int render_process_id);
 
 }  // namespace prerender
 
 #endif  // CHROME_BROWSER_PRERENDER_PRERENDER_MANAGER_H_