Handle interface to prerenders.

chrome/browser/prerender/prerender_contents.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_CONTENTS_H_
 #define CHROME_BROWSER_PRERENDER_PRERENDER_CONTENTS_H_
 #pragma once
 
 #include <list>
 #include <string>
@@ skipping 19 matching lines @@
 }
 
 namespace content {
 class RenderViewHost;
 class SessionStorageNamespace;
 class WebContents;
 }
 
 namespace prerender {
 
+class PrerenderHandle;
 class PrerenderManager;
 class PrerenderRenderViewHostObserver;
 class PrerenderTracker;
 
 class PrerenderContents : public content::NotificationObserver,
                           public content::WebContentsObserver {
  public:
   // PrerenderContents::Create uses the currently registered Factory to create
   // the PrerenderContents. Factory is intended for testing.
   class Factory {
    public:
     Factory() {}
     virtual ~Factory() {}
 
     // Ownership is not transfered through this interface as prerender_manager,
     // prerender_tracker, and profile are stored as weak pointers.
     virtual PrerenderContents* CreatePrerenderContents(
         PrerenderManager* prerender_manager,
         PrerenderTracker* prerender_tracker,
         Profile* profile,
         const GURL& url,
         const content::Referrer& referrer,
         Origin origin,
         uint8 experiment_id) = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Factory);
   };
 
+  // Predicate functor used in maps to sort by load start time.
+  class LessThanByLoadStartTime {

[dominich, 2012/06/22 15:36:16]

public?

+   public:
+    bool operator() (const PrerenderContents* lhs,
+                     const PrerenderContents* rhs) const;
+  };
+
   // Information on pages that the prerendered page has tried to prerender.
   struct PendingPrerenderInfo;
   typedef std::list<PendingPrerenderInfo> PendingPrerenderList;
 
   // Indicates how this PrerenderContents relates to MatchComplete. This is to
   // figure out which histograms to use to record the FinalStatus, Match (record
   // all prerenders and control group prerenders) or MatchComplete (record
   // running prerenders only in the way they would have been recorded in the
   // control group).
   enum MatchCompleteStatus {
     // A regular prerender which will be recorded both in Match and
     // MatchComplete.
     MATCH_COMPLETE_DEFAULT,
     // A prerender that used to be a regular prerender, but has since been
-    // replaced by a MatchComplete dummy.  Therefore, we will record this only
+    // replaced by a MatchComplete dummy. Therefore, we will record this only
     // for Match, but not for MatchComplete.
     MATCH_COMPLETE_REPLACED,
     // A prerender that is a MatchComplete dummy replacing a regular prerender.
     // In the control group, our prerender never would have been canceled, so
     // we record in MatchComplete but not Match.
     MATCH_COMPLETE_REPLACEMENT,
     // A prerender that is a MatchComplete dummy, early in the process of being
     // created. This prerender should not fail. Record for MatchComplete, but
     // not Match.
     MATCH_COMPLETE_REPLACEMENT_PENDING,
   };
 
   virtual ~PrerenderContents();
 
+  // For MatchComplete correctness, create a dummy replacement prerender contents
+  // to stand in for this prerender contents that (which we are about to destroy).
+  PrerenderContents* CreateDummyReplacement() const;
+
   bool Init();
 
   static Factory* CreateFactory();
 
   // Start rendering the contents in the prerendered state. If
   // |is_control_group| is true, this will go through some of the mechanics of
   // starting a prerender, without actually creating the RenderView.
   // |creator_child_id| is the id of the child process that caused the prerender
   // to be created, and is needed so that the prerendered URLs can be sent to it
   // so render-initiated navigations will swap in the prerendered page. |size|
@@ skipping 38 matching lines @@
 
   // Set the final status for how the PrerenderContents was used. This
   // should only be called once, and should be called before the prerender
   // contents are destroyed.
   void set_final_status(FinalStatus final_status);
   FinalStatus final_status() const { return final_status_; }
 
   Origin origin() const { return origin_; }
   uint8 experiment_id() const { return experiment_id_; }
 
+  int client_count() const { return client_count_; }

[dominich, 2012/06/22 15:36:16]

naming nit: I don't know what a client is or what this count is counting.

+  void IncrementClientCount();
+  void DecrementClientCount();
+
   base::TimeTicks load_start_time() const { return load_start_time_; }
 
   // Indicates whether this prerendered page can be used for the provided
   // URL, i.e. whether there is a match. |matching_url| is optional and will be

[dominich, 2012/06/22 15:36:16]

comment needs updating

   // set to the URL that is found as a match if it is provided.
   // TODO(gavinp,mmenke): Rework matching to be based on both the URL
   // and the session WebStorage.
-  bool MatchesURL(const GURL& url, GURL* matching_url) const;
+  bool Matches(
+      const GURL& url,
+      const content::SessionStorageNamespace* session_storage_namespace);
 
   void OnJSOutOfMemory();
   bool ShouldSuppressDialogs();
 
   // content::WebContentsObserver implementation.
   virtual void DidStopLoading() OVERRIDE;
   virtual void DidStartProvisionalLoadForFrame(
       int64 frame_id,
       bool is_main_frame,
       const GURL& validated_url,
@@ skipping 35 matching lines @@
   void CommitHistory(TabContents* tab);
 
   base::Value* GetAsValue() const;
 
   // Returns whether a pending cross-site navigation is happening.
   // This could happen with renderer-issued navigations, such as a
   // MouseEvent being dispatched by a link to a website installed as an app.
   bool IsCrossSiteNavigationPending() const;
 
   // Adds a pending prerender to the list.
-  virtual void AddPendingPrerender(const GURL& url,
+  virtual void AddPendingPrerender(scoped_ptr<PrerenderHandle> prerender_handle,

[dominich, 2012/06/22 15:36:16]

I don't know why, but seeing a scoped_ptr<> passed in here is causing me to
quirk an eyebrow. I'll revert when I've examined the .cc.

+                                   const GURL& url,
                                    const content::Referrer& referrer,
                                    const gfx::Size& size);
 
   // Returns true if |url| corresponds to a pending prerender.
-  bool IsPendingEntry(const GURL& url) const;
+  bool IsPendingEntry(const PrerenderHandle* prerender_handle) const;

[dominich, 2012/06/22 15:36:16]

if |prerender_handle| can never be NULL, prefer passing a reference. Even
better, make PrerenderHandle have sensible copy semantics and pass-by-value. I
know that seems wrong, but when I see 'Handle' I expect something that can be
passed by value. YMMV.

 
   // Reissues any pending prerender requests from the prerendered page.  Also
   // clears the list of pending requests.
   void StartPendingPrerenders();
 
  protected:
   PrerenderContents(PrerenderManager* prerender_manager,
                     PrerenderTracker* prerender_tracker,
                     Profile* profile,
                     const GURL& url,
@@ skipping 16 matching lines @@
 
   bool prerendering_has_been_cancelled() const {
     return prerendering_has_been_cancelled_;
   }
 
   virtual content::WebContents* CreateWebContents(
       content::SessionStorageNamespace* session_storage_namespace);
 
   bool prerendering_has_started_;
 
+  // Time at which we started to load the URL.  This is used to compute
+  // the time elapsed from initiating a prerender until the time the
+  // (potentially only partially) prerendered page is shown to the user.

[dominich, 2012/06/22 15:36:16]

Is it not used to potentially expire stale prerendered pages?

+  base::TimeTicks load_start_time_;

[dominich, 2012/06/22 15:36:16]

 The move to protected is unexpected as I thought PrerenderContents was a leaf
class. Unless this is exposed for tests?

+
  private:
   class TabContentsDelegateImpl;
 
   // Needs to be able to call the constructor.
   friend class PrerenderContentsFactoryImpl;
 
   friend class PrerenderRenderViewHostObserver;
 
   // Message handlers.
   void OnUpdateFaviconURL(int32 page_id, const std::vector<FaviconURL>& urls);
@@ skipping 28 matching lines @@
   int32 page_id_;
   GURL url_;
   GURL icon_url_;
   content::NotificationRegistrar notification_registrar_;
 
   // A vector of URLs that this prerendered page matches against.
   // This array can contain more than element as a result of redirects,
   // such as HTTP redirects or javascript redirects.
   std::vector<GURL> alias_urls_;
 
+  // Number of distinct clients of this prerendered page (distinct link elements
+  // for instance).

[dominich, 2012/06/22 15:36:16]

Ah - maybe instance_count_ ?

+  int client_count_;
+
   bool has_stopped_loading_;
 
   // True when the main frame has finished loading.
   bool has_finished_loading_;
 
   // This must be the same value as the PrerenderTracker has recorded for
   // |this|, when |this| has a RenderView.
   FinalStatus final_status_;
 
   // The MatchComplete status of the prerender, indicating how it relates
   // to being a MatchComplete dummy (see definition of MatchCompleteStatus
   // above).
   MatchCompleteStatus match_complete_status_;
 
   // Tracks whether or not prerendering has been cancelled by calling Destroy.
   // Used solely to prevent double deletion.
   bool prerendering_has_been_cancelled_;
 
-  // Time at which we started to load the URL.  This is used to compute
-  // the time elapsed from initiating a prerender until the time the
-  // (potentially only partially) prerendered page is shown to the user.
-  base::TimeTicks load_start_time_;
-
   // Process Metrics of the render process associated with the
   // RenderViewHost for this object.
   scoped_ptr<base::ProcessMetrics> process_metrics_;
 
   // The prerendered TabContents; may be null.
   scoped_ptr<TabContents> prerender_contents_;
 
   scoped_ptr<PrerenderRenderViewHostObserver> render_view_host_observer_;
 
   scoped_ptr<TabContentsDelegateImpl> tab_contents_delegate_;
@@ skipping 16 matching lines @@
 
   // The size of the WebView from the launching page.
   gfx::Size size_;
 
   DISALLOW_COPY_AND_ASSIGN(PrerenderContents);
 };
 
 }  // namespace prerender
 
 #endif  // CHROME_BROWSER_PRERENDER_PRERENDER_CONTENTS_H_