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);
 
   static PrerenderManagerMode GetMode();
   static void SetMode(PrerenderManagerMode mode);
   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;
+  // is prerendering a page. The optional parameter |origin| is an output
+  // parameter which, if a prerender is found, is set to the Origin of the
+  // prerender |web_contents|.
+  bool IsWebContentsPrerendering(content::WebContents* web_contents,
+                                 Origin* origin) 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 MarkWebContentsAsWouldBePrerendered(content::WebContents* web_contents);
+  void MarkWebContentsAsPrerendered(content::WebContents* web_contents,
+                                    Origin origin);
+  void MarkWebContentsAsWouldBePrerendered(content::WebContents* web_contents,
+                                           Origin origin);
   void MarkWebContentsAsNotPrerendered(content::WebContents* web_contents);
-  bool IsWebContentsPrerendered(content::WebContents* web_contents) const;
-  bool WouldWebContentsBePrerendered(content::WebContents* web_contents) const;
+
+  // Returns true if |web_contents| was originally a prerender that has since
+  // been swapped in. The optional parameter |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,
+                                     Origin* origin) 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(); }
-
  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,
                   base::TimeTicks expiry_time);
@@ skipping 71 matching lines @@
 
  private:
   friend class PrerenderBrowserTest;
   friend class PrerenderContents;
   friend class PrerenderHandle;
   friend class UnitTestPrerenderManager;
 
   class OnCloseTabContentsDeleter;
   struct NavigationRecord;
 
-  typedef base::hash_map<content::WebContents*, bool> WouldBePrerenderedMap;
+  // For each WebContents that is swapped in, we store a
+  // PrerenderedWebContentsData so that we can track the origin of the
+  // prerender.
+  struct PrerenderedWebContentsData {
+    explicit PrerenderedWebContentsData(Origin origin);
+
+    Origin origin;
+  };
+
+  // In the control group experimental group for each WebContents "not swapped
+  // in" we create a WouldBePrerenderedWebContentsData to the origin of the
+  // "prerender" we did not launch. We also track a state machine to ensure
+  // the histogram reporting tracks what histograms would have done.
+  struct WouldBePrerenderedWebContentsData {
+    // When the WebContents gets a provisional load, we'd like to remove the
+    // WebContents from  the map since the new navigation would not have swapped
+    // in a prerender. But the first provisional load after the control
+    // prerender is not "swapped in" is actually to the prerendered location! So
+    // we don't remove the item from the map on the first provisional load, but
+    // we do for subsequent loads.
+    enum State {
+      WAITING_FOR_PROVISIONAL_LOAD,
+      SEEN_PROVISIONAL_LOAD,
+    };
+
+    explicit WouldBePrerenderedWebContentsData(Origin origin);
+
+    Origin origin;
+    State state;
+  };
 
   // 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);
 
   // Adds a prerender for |url| from |referrer| initiated from the process
@@ skipping 55 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
+  // the prerendered location. So, we need to keep a state 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_;
+  base::hash_map<content::WebContents*, WouldBePrerenderedWebContentsData>
+      would_be_prerendered_map_;
 
   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_