Add code to keep track of what fraction of pageviews are top sites.

chrome/browser/prerender/prerender_observer.cc

 // Copyright (c) 2011 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.
 
 #include "chrome/browser/prerender/prerender_observer.h"
 
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "chrome/browser/prerender/prerender_manager.h"
@@ skipping 62 matching lines @@
         base::Histogram::kUmaTargetedHistogramFlag);
   }
   base::Histogram* count_hover_events() { return count_hover_events_; }
   base::Histogram* time_hover_until_click() { return time_hover_until_click_; }
 
  private:
   base::Histogram* count_hover_events_;
   base::Histogram* time_hover_until_click_;
 };
 
+enum PAGEVIEW_EVENTS {
+  PAGEVIEW_EVENT_NEW_URL = 0,
+  PAGEVIEW_EVENT_TOP_SITE_NEW_URL = 1,
+  PAGEVIEW_EVENT_LOAD_START = 2,
+  PAGEVIEW_EVENT_TOP_SITE_LOAD_START = 3,
+  PAGEVIEW_EVENT_MAX = 4
+};
+
+void RecordPageviewEvent(PAGEVIEW_EVENTS event) {
+  UMA_HISTOGRAM_ENUMERATION("Prerender.PageviewEvents",
+                            event, PAGEVIEW_EVENT_MAX);
+}
+
 }  // namespace
 
 class PrerenderObserver::HoverData {
  public:
   void SetHoverThreshold(int threshold_ms) {
     hover_threshold_ = base::TimeDelta::FromMilliseconds(threshold_ms);
     histograms_.reset(new PerHoverThresholdHistograms(threshold_ms));
   }
 
   void RecordHover(const GURL& url) {
@@ skipping 80 matching lines @@
       last_hovers_(new HoverData[kNumHoverThresholds]) {
   for (int i = 0; i < kNumHoverThresholds; i++)
     last_hovers_[i].SetHoverThreshold(kMinHoverThresholdsMs[i]);
 }
 
 PrerenderObserver::~PrerenderObserver() {
 }
 
 void PrerenderObserver::ProvisionalChangeToMainFrameUrl(const GURL& url,
                                                         bool has_opener_set) {
+  RecordPageviewEvent(PAGEVIEW_EVENT_NEW_URL);
+  if (IsTopSite(url))
+    RecordPageviewEvent(PAGEVIEW_EVENT_TOP_SITE_NEW_URL);
   if (!tab_->delegate())
     return;  // PrerenderManager needs a delegate to handle the swap.
   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
   if (!prerender_manager)
     return;
   if (prerender_manager->IsTabContentsPrerendering(tab_contents()))
     return;
   prerender_manager->MarkTabContentsAsNotPrerendered(tab_contents());
   MaybeUsePrerenderedPage(url, has_opener_set);
 }
 
 bool PrerenderObserver::OnMessageReceived(const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(PrerenderObserver, message)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DidStartProvisionalLoadForFrame,
                         OnDidStartProvisionalLoadForFrame)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateTargetURL, OnMsgUpdateTargetURL)
   IPC_END_MESSAGE_MAP()
   return false;
 }
 
 void PrerenderObserver::OnDidStartProvisionalLoadForFrame(int64 frame_id,
                                                           bool is_main_frame,
                                                           bool has_opener_set,
                                                           const GURL& url) {
   if (is_main_frame) {
+    RecordPageviewEvent(PAGEVIEW_EVENT_LOAD_START);
+    if (IsTopSite(url))
+      RecordPageviewEvent(PAGEVIEW_EVENT_TOP_SITE_LOAD_START);
+
     // Record the beginning of a new PPLT navigation.
     pplt_load_start_ = base::TimeTicks::Now();
 
     // Update hover stats.
     for (int i = 0; i < kNumHoverThresholds; i++)
       last_hovers_[i].RecordNavigation(url);
 
     MaybeLogCurrentHover(current_hover_url_ == url);
   }
 }
@@ skipping 16 matching lines @@
   // Compute the PPLT metric and report it in a histogram, if needed.
   if (!pplt_load_start_.is_null() && !IsPrerendering()) {
     PrerenderManager::RecordPerceivedPageLoadTime(
         base::TimeTicks::Now() - pplt_load_start_, tab_contents());
   }
 
   // Reset the PPLT metric.
   pplt_load_start_ = base::TimeTicks();
 }
 
-PrerenderManager* PrerenderObserver::MaybeGetPrerenderManager() {
+PrerenderManager* PrerenderObserver::MaybeGetPrerenderManager() const {
   Profile* profile =
       Profile::FromBrowserContext(tab_contents()->browser_context());
   return profile->GetPrerenderManager();
 }
 
 bool PrerenderObserver::MaybeUsePrerenderedPage(const GURL& url,
                                                 bool has_opener_set) {
   PrerenderManager* prerender_manager = MaybeGetPrerenderManager();
   if (!prerender_manager)
     return false;
@@ skipping 41 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("Prerender.HoverStats_TimeUntilClicked",
                               elapsed_ms, num_buckets);
   } else {
     UMA_HISTOGRAM_ENUMERATION("Prerender.HoverStats_TimeUntilDiscarded",
                               elapsed_ms, num_buckets);
   }
 
   current_hover_url_ = GURL();
 }
 
+bool PrerenderObserver::IsTopSite(const GURL& url) const {
+  PrerenderManager* pm = MaybeGetPrerenderManager();
+  return (pm && pm->IsTopSite(url));
+}
+
 }  // namespace prerender