Fix prerender histograms for multiple prerender case.

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_
 
 #include <list>
 #include <map>
 #include <string>
@@ skipping 141 matching lines @@
   // 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,
       double fraction_plt_elapsed_at_swap_in,
       content::WebContents* web_contents,
       const GURL& url);
 
+  // Records the percentage of pixels of the final page in place at swap-in.
+  void RecordFractionPixelsFinalAtSwapin(
+      content::WebContents* web_contents,
+      double fraction);
+
   // Set whether prerendering is currently enabled for this manager.
   // Must be called on the UI thread.
   // If |enabled| is false, existing prerendered pages will still persist until
   // they time out, but new ones will not be generated.
   void set_enabled(bool enabled);
 
   // Controls if we launch or squash prefetch requests as they arrive from
   // renderers.
   static bool IsPrefetchEnabled();
   static void SetIsPrefetchEnabled(bool enabled);
@@ skipping 10 matching lines @@
   // is prerendering a page.
   bool IsWebContentsPrerendering(content::WebContents* web_contents) const;
 
   // Returns the PrerenderContents object for the given web_contents if it's
   // used for an active prerender page, otherwise returns NULL.
   PrerenderContents* GetPrerenderContents(
       content::WebContents* web_contents) 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 MarkWebContentsAsPrerendered(content::WebContents* web_contents,
+                                    Origin origin);
+
   void MarkWebContentsAsWouldBePrerendered(content::WebContents* web_contents);
   void MarkWebContentsAsNotPrerendered(content::WebContents* web_contents);
-  bool IsWebContentsPrerendered(content::WebContents* web_contents) const;
+
+  // Returns true if |web_contents| is being prerendered. The optional parameter

[mmenke, 2012/10/08 18:20:07]

Could you fix this comment as well?  It's actually if |web_contents| *was*
prerendered.

"Is being prerenered" really sounds like what "IsWebContentsPrerendering"
returns.

[gavinp, 2012/10/10 18:14:56]

Done.

+  // |origin| is an output parameter which, if a prerender is found, is set to
+  // the Origin of the prerender of |web_contents|.
+  bool IsWebContentsPrerendered(content::WebContents* web_contents,
+                                Origin* origin) const;
+
   bool WouldWebContentsBePrerendered(content::WebContents* web_contents) const;
 
   // Checks whether |url| has been recently navigated to.
-  bool HasRecentlyBeenNavigatedTo(const GURL& url);
+  bool HasRecentlyBeenNavigatedTo(Origin origin, const GURL& url);
 
   // Returns true if the method given is invalid for prerendering.
   static bool IsValidHttpMethod(const std::string& method);
 
   // Returns a Value object containing the active pages being prerendered, and
   // a history of pages which were prerendered. The caller is responsible for
   // deleting the return value.
   base::DictionaryValue* GetAsValue() const;
 
   // Clears the data indicated by which bits of clear_flags are set.
@@ skipping 25 matching lines @@
 
   // Adds a condition. This is owned by the PrerenderManager.
   void AddCondition(const PrerenderCondition* condition);
 
   // Records that some visible tab navigated (or was redirected) to the
   // provided URL.
   void RecordNavigation(const GURL& url);
 
   Profile* profile() const { return profile_; }
 
-  PrerenderHistograms* histograms() const { return histograms_.get(); }
+  PrerenderHistograms* histograms() { return histograms_.get(); }
 
  protected:
   class PrerenderData : public base::SupportsWeakPtr<PrerenderData> {
    public:
     // Constructor for a pending prerender, which will get its contents later.
     explicit PrerenderData(PrerenderManager* manager);
 
     // Constructor for an active prerender.
     PrerenderData(PrerenderManager* manager,
                   PrerenderContents* contents,
@@ skipping 71 matching lines @@
   void DoShutdown();
 
  private:
   friend class PrerenderBrowserTest;
   friend class PrerenderContents;
   friend class PrerenderHandle;
   friend class UnitTestPrerenderManager;
 
   class OnCloseTabContentsDeleter;
   struct NavigationRecord;
+  struct PrerenderedWebContentsData {
+    Origin origin;
+
+    explicit PrerenderedWebContentsData(Origin origin);
+  };
 
   typedef base::hash_map<content::WebContents*, bool> WouldBePrerenderedMap;
 
   // Time interval before a new prerender is allowed.
   static const int kMinTimeBetweenPrerendersMs = 500;
 
   // Time window for which we record old navigations, in milliseconds.
   static const int kNavigationRecordWindowMs = 5000;
 
   void OnCancelPrerenderHandle(PrerenderData* prerender_data);
@@ skipping 57 matching lines @@
   // If |child_id| and |route_id| correspond to a RenderView that is an active
   // prerender, returns the PrerenderData object for that prerender. Otherwise,
   // returns NULL.
   PrerenderData* FindPrerenderDataForChildAndRoute(int child_id, int route_id);
 
   // Given the |prerender_contents|, find the iterator in active_prerender_list_
   // correponding to the given prerender.
   std::list<linked_ptr<PrerenderData> >::iterator
       FindIteratorForPrerenderContents(PrerenderContents* prerender_contents);
 
-  bool DoesRateLimitAllowPrerender() const;
+  bool DoesRateLimitAllowPrerender(Origin origin) 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();
 
   // Arrange for the given tab contents to be deleted asap. If deleter is not
@@ skipping 52 matching lines @@
   // List of all pending prerenders.
   std::list<linked_ptr<PrerenderData> > pending_prerender_list_;
 
   // List of recent navigations in this profile, sorted by ascending
   // navigate_time_.
   std::list<NavigationRecord> navigations_;
 
   // List of prerender elements to be deleted
   std::list<PrerenderContents*> pending_delete_list_;
 
-  // Set of WebContents which are currently displaying a prerendered page.
-  base::hash_set<content::WebContents*> prerendered_tab_contents_set_;
+  // This map is from all WebContents which are currently displaying a
+  // prerendered page which has already been swapped in to a
+  // PrerenderedWebContentsData for tracking full lifetime information
+  // on prerenders.
+  base::hash_map<content::WebContents*, PrerenderedWebContentsData>
+      prerendered_web_contents_data_;
 
   // WebContents that would have been swapped out for a prerendered WebContents
   // if the user was not part of the control group for measurement. When the
   // WebContents gets a provisional load, the WebContents is removed from
   // the map since the new navigation would not have swapped in a prerender.
   // However, one complication exists because the first provisional load after
   // the WebContents is marked as "Would Have Been Prerendered" is actually to
   // the prerendered location. So, we need to keep a boolean around that does
   // not clear the item from the map on the first provisional load, but does
   // for subsequent loads.
   WouldBePrerenderedMap would_be_prerendered_map_;

[tburkard, 2012/10/05 21:54:04]

In order for this to work symmetrically for control group and prerender group,
you must duplicate the map for would_be_prerendered.  However, this already is a
map.  So you'd have to use a struct instead of the bool, and put the bool & the
origin in the struct.

[gavinp, 2012/10/10 18:14:56]

Done, but I used an enum, since bools always confuse me.

 
   scoped_ptr<PrerenderContents::Factory> prerender_contents_factory_;
 
   static PrerenderManagerMode mode_;
 
   // A count of how many prerenders we do per session. Initialized to 0 then
   // incremented and emitted to a histogram on each successful prerender.
   static int prerenders_per_session_count_;
 
   // RepeatingTimer to perform periodic cleanups of pending prerendered
@@ skipping 20 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PrerenderManager);
 };
 
 PrerenderManager* FindPrerenderManagerUsingRenderProcessId(
     int render_process_id);
 
 }  // namespace prerender
 
 #endif  // CHROME_BROWSER_PRERENDER_PRERENDER_MANAGER_H_