Remove prerendering RenderView histograms.

TBR=ben@chromium.org
BUG=none

Review URL: https://chromiumcodereview.appspot.com/11415030

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@168361 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 22 insertions, 148 deletions

diff --git a/chrome/renderer/prerender/prerender_helper.cc b/chrome/renderer/prerender/prerender_helper.cc
index 853a2f7..7d8b1b3 100644
--- a/chrome/renderer/prerender/prerender_helper.cc
+++ b/chrome/renderer/prerender/prerender_helper.cc
@@ -14,25 +14,26 @@
 
 using content::DocumentState;
 
-// Helper macro for histograms.
-#define RECORD_PLT(tag, perceived_page_load_time) { \
-    UMA_HISTOGRAM_CUSTOM_TIMES( \
-        base::FieldTrial::MakeName(std::string("Prerender.") + tag, \
-                                   "Prerender"), \
-        perceived_page_load_time, \
-        base::TimeDelta::FromMilliseconds(10), \
-        base::TimeDelta::FromSeconds(60), \
-        100); \
+namespace {
+
+// Updates the visibility state of the RenderView.  Must be called whenever
+// prerendering starts or finishes and the page is about to be show.  At both
+// those times, the RenderView is hidden.
+void UpdateVisibilityState(content::RenderView* render_view) {
+  if (render_view->GetWebView()) {
+    render_view->GetWebView()->setVisibilityState(
+        render_view->GetVisibilityState(), false);
   }
+}
+
+}  // namespace
 
 namespace prerender {
 
 PrerenderHelper::PrerenderHelper(content::RenderView* render_view)
     : content::RenderViewObserver(render_view),
-      content::RenderViewObserverTracker<PrerenderHelper>(render_view),
-      is_prerendering_(true),
-      has_unrecorded_data_(false) {
-  UpdateVisibilityState();
+      content::RenderViewObserverTracker<PrerenderHelper>(render_view) {
+  UpdateVisibilityState(render_view);
 }
 
 PrerenderHelper::~PrerenderHelper() {
@@ -40,92 +41,7 @@ PrerenderHelper::~PrerenderHelper() {
 
 // static.
 bool PrerenderHelper::IsPrerendering(const content::RenderView* render_view) {
-  PrerenderHelper* prerender_helper = PrerenderHelper::Get(render_view);
-  return (prerender_helper && prerender_helper->is_prerendering_);
-}
-
-// static.
-void PrerenderHelper::RecordHistograms(
-    content::RenderView* render_view,
-    const base::Time& finish_all_loads,
-    const base::TimeDelta& begin_to_finish_all_loads) {
-  static bool use_prerender_histogram =
-      base::FieldTrialList::TrialExists("Prerender");
-  if (!use_prerender_histogram)
-    return;
-
-  PrerenderHelper* prerender_helper = PrerenderHelper::Get(render_view);
-
-  // Load time for non-prerendered pages.
-  if (!prerender_helper) {
-    RECORD_PLT("RendererPerceivedPLT", begin_to_finish_all_loads);
-    return;
-  }
-
-  if (!prerender_helper->is_prerendering_ &&
-      !prerender_helper->HasUnrecordedData()) {
-    // If the RenderView has a PrerenderHelper and a histogram is being
-    // recorded, it should either be prerendering or have histogram data that
-    // has yet to be recorded.
-    NOTREACHED();
-    delete prerender_helper;
-    return;
-  }
-
-  // There should be a start time, since the first provisional load should have
-  // occured before recording any histograms.
-  DCHECK(!prerender_helper->prerender_start_time_.is_null());
-
-  // The only case where this should happen is if a page is being redirected
-  // prior to display.  No histograms are currently recorded when the renderer
-  // is shutting down, so this point will never be reached in that case.
-  if (prerender_helper->is_prerendering_) {
-    DCHECK(!prerender_helper->HasUnrecordedData());
-    return;
-  }
-
-  // There should be a display time, since HasUnrecordedData() returned true.
-  DCHECK(!prerender_helper->prerender_display_time_.is_null());
-
-  // The RenderView still has a PrerenderHelper and is not currently being
-  // prerendered, so the page was prerendered and then displayed.  Record
-  // histograms for the prerender, before deleting the PrerenderHelper.
-  base::Time prerender_display_time =
-      prerender_helper->prerender_display_time_;
-  base::Time prerender_start_time = prerender_helper->prerender_start_time_;
-
-  RECORD_PLT("RendererTimeUntilDisplayed",
-             prerender_display_time - prerender_start_time);
-  base::TimeDelta perceived_load_time = finish_all_loads -
-                                        prerender_display_time;
-  if (perceived_load_time < base::TimeDelta::FromSeconds(0)) {
-    RECORD_PLT("RendererIdleTime", -perceived_load_time);
-    perceived_load_time = base::TimeDelta::FromSeconds(0);
-  }
-  RECORD_PLT("RendererPerceivedPLT", perceived_load_time);
-  RECORD_PLT("RendererPerceivedPLTMatched", perceived_load_time);
-
-  // Once a prerendered page is displayed and its histograms recorded, it no
-  // longer needs a PrerenderHelper.
-  delete prerender_helper;
-}
-
-void PrerenderHelper::DidStartProvisionalLoad(WebKit::WebFrame* frame) {
-  // If this is the first provisional load since prerendering started, get its
-  // request time.
-  if (is_prerendering_ && prerender_start_time_.is_null()) {
-    WebKit::WebDataSource* data_source = frame->provisionalDataSource();
-    if (!data_source) {
-      NOTREACHED();
-      return;
-    }
-    DocumentState* document_state =
-        DocumentState::FromDataSource(data_source);
-    prerender_start_time_ = document_state->request_time();
-    // The first navigation for prerendering RenderViews can only be triggered
-    // from PrerenderContents, so there should be a request_time.
-    DCHECK(!prerender_start_time_.is_null());
-  }
+  return PrerenderHelper::Get(render_view) != NULL;
 }
 
 bool PrerenderHelper::OnMessageReceived(
@@ -143,23 +59,14 @@ void PrerenderHelper::OnSetIsPrerendering(bool is_prerendering) {
   // triggered its creation.  If so, ignore it.
   if (is_prerendering)
     return;
-  DCHECK(!is_prerendering);
-  DCHECK(!HasUnrecordedData());
 
-  is_prerendering_ = false;
-  prerender_display_time_ = base::Time::Now();
-  UpdateVisibilityState();
-}
+  content::RenderView* view = render_view();
+  // |this| must be deleted so PrerenderHelper::IsPrerendering returns false
+  // when the visibility state is updated, so the visibility state string will
+  // not be "prerendered".
+  delete this;
 
-bool PrerenderHelper::HasUnrecordedData() const {
-  return !prerender_display_time_.is_null();
-}
-
-void PrerenderHelper::UpdateVisibilityState() {
-  if (render_view()->GetWebView()) {
-    render_view()->GetWebView()->setVisibilityState(
-        render_view()->GetVisibilityState(), false);
-  }
+  UpdateVisibilityState(view);
 }
 
 }  // namespace prerender
diff --git a/chrome/renderer/prerender/prerender_helper.h b/chrome/renderer/prerender/prerender_helper.h
index 8028bca..a9879c1 100644
--- a/chrome/renderer/prerender/prerender_helper.h
+++ b/chrome/renderer/prerender/prerender_helper.h
@@ -13,11 +13,7 @@
 namespace prerender {
 
 // Helper class to track whether its RenderView is currently being prerendered.
-// Also records prerendering-related histograms information and cancels
-// prerendering when necessary, based on observed events.  Created when
-// prerendering starts and deleted as soon as just after the prerendering
-// histograms have been recorded for a displayed prerendered page.  For
-// non-displayed pages, deleted on destruction of the RenderView.
+// Created when prerendering starts and deleted as soon as it stops.
 class PrerenderHelper
     : public content::RenderViewObserver,
       public content::RenderViewObserverTracker<PrerenderHelper> {
@@ -28,41 +24,12 @@ class PrerenderHelper
   // Returns true if |render_view| is currently prerendering.
   static bool IsPrerendering(const content::RenderView* render_view);
 
-  // Records prerender histograms.  These are recorded even for pages that are
-  // not prerendered, for comparison to pages that are.
-  static void RecordHistograms(
-      content::RenderView* render_view,
-      const base::Time& finish_all_loads,
-      const base::TimeDelta& begin_to_finish_all_loads);
-
  private:
   // RenderViewObserver implementation
-  virtual void DidStartProvisionalLoad(WebKit::WebFrame* frame) OVERRIDE;
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
   void OnSetIsPrerendering(bool is_prerendering);
 
-  // Returns true if the page is no longer being prerendered, but no histograms
-  // for the prerender have been recorded.
-  bool HasUnrecordedData() const;
-
-  // Updates the visibility state of the RenderView.  Must be called whenever
-  // prerendering starts or finishes.
-  void UpdateVisibilityState();
-
-  // Tracks whether or not observed RenderView is currently prerendering.
-  bool is_prerendering_;
-
-  // Time when the prerender started.
-  base::Time prerender_start_time_;
-  // Time when the prerendered page was displayed.
-  base::Time prerender_display_time_;
-
-  // Set to true when a prerendered page is displayed to prevent deletion from
-  // when a prerendered page is displayed until after the histograms for the
-  // page load have been recorded.
-  bool has_unrecorded_data_;
-
   DISALLOW_COPY_AND_ASSIGN(PrerenderHelper);
 };