Add additional histograms to assess the effectiveness of prerendering.

BUG=71061,70955
TEST=none

Review URL: http://codereview.chromium.org/6410040

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

5 files changed, 91 insertions, 3 deletions

diff --git a/chrome/browser/prerender/prerender_contents.cc b/chrome/browser/prerender/prerender_contents.cc
index c4b2be3..f97fca8 100644
--- a/chrome/browser/prerender/prerender_contents.cc
+++ b/chrome/browser/prerender/prerender_contents.cc
@@ -74,6 +74,9 @@ void PrerenderContents::StartPrerendering() {
                  Source<Profile>(profile_));
   render_view_host_->CreateRenderView(string16());
 
+  DCHECK(load_start_time_.is_null());
+  load_start_time_ = base::TimeTicks::Now();
+
   ViewMsg_Navigate_Params params;
   params.url = prerender_url_;
   params.transition = PageTransition::LINK;
diff --git a/chrome/browser/prerender/prerender_contents.h b/chrome/browser/prerender/prerender_contents.h
index b875c2b..782ea36 100644
--- a/chrome/browser/prerender/prerender_contents.h
+++ b/chrome/browser/prerender/prerender_contents.h
@@ -9,6 +9,7 @@
 #include <string>
 #include <vector>
 
+#include "base/time.h"
 #include "chrome/browser/renderer_host/render_view_host_delegate.h"
 #include "chrome/browser/tab_contents/render_view_host_delegate_helper.h"
 #include "chrome/browser/ui/app_modal_dialogs/js_modal_dialog.h"
@@ -90,6 +91,8 @@ class PrerenderContents : public RenderViewHostDelegate,
   void set_final_status(FinalStatus final_status);
   FinalStatus final_status() const;
 
+  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.
   bool MatchesURL(const GURL& url) const;
@@ -237,6 +240,11 @@ class PrerenderContents : public RenderViewHostDelegate,
 
   FinalStatus final_status_;
 
+  // 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_;
+
   DISALLOW_COPY_AND_ASSIGN(PrerenderContents);
 };
 
diff --git a/chrome/browser/prerender/prerender_manager.cc b/chrome/browser/prerender/prerender_manager.cc
index 1747ff9..7e17a9d 100644
--- a/chrome/browser/prerender/prerender_manager.cc
+++ b/chrome/browser/prerender/prerender_manager.cc
@@ -16,6 +16,9 @@
 #include "chrome/common/render_messages.h"
 
 // static
+base::TimeTicks PrerenderManager::last_prefetch_seen_time_;
+
+// static
 PrerenderManager::PrerenderManagerMode PrerenderManager::mode_ =
     PRERENDER_MODE_ENABLED;
 
@@ -121,6 +124,8 @@ bool PrerenderManager::MaybeUsePreloadedPage(TabContents* tc, const GURL& url) {
   if (pc.get() == NULL)
     return false;
 
+  if (!pc->load_start_time().is_null())
+    RecordTimeUntilUsed(base::TimeTicks::Now() - pc->load_start_time());
   pc->set_final_status(PrerenderContents::FINAL_STATUS_USED);
 
   RenderViewHost* rvh = pc->render_view_host();
@@ -172,18 +177,34 @@ PrerenderContents* PrerenderManager::CreatePrerenderContents(
 }
 
 void PrerenderManager::RecordPerceivedPageLoadTime(base::TimeDelta pplt) {
+  bool record_windowed_pplt = ShouldRecordWindowedPPLT();
   switch (mode_) {
     case PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP:
       UMA_HISTOGRAM_TIMES("PLT.PerceivedPageLoadTime_PrerenderControl", pplt);
+      if (record_windowed_pplt) {
+        UMA_HISTOGRAM_TIMES(
+            "PLT.PerceivedPageLoadTime_WindowPrerenderControl", pplt);
+      }
       break;
     case PRERENDER_MODE_EXPERIMENT_PRERENDER_GROUP:
       UMA_HISTOGRAM_TIMES("PLT.PerceivedPageLoadTime_PrerenderTreatment", pplt);
+      if (record_windowed_pplt) {
+        UMA_HISTOGRAM_TIMES(
+            "PLT.PerceivedPageLoadTime_WindowPrerenderTreatment", pplt);
+      }
       break;
     default:
       break;
   }
 }
 
+void PrerenderManager::RecordTimeUntilUsed(base::TimeDelta time_until_used) {
+  if (mode_ == PRERENDER_MODE_EXPERIMENT_PRERENDER_GROUP) {
+    UMA_HISTOGRAM_TIMES("PLT.TimeUntilUsed_PrerenderTreatment",
+                        time_until_used);
+  }
+}
+
 PrerenderContents* PrerenderManager::FindEntry(const GURL& url) {
   for (std::list<PrerenderContentsData>::iterator it = prerender_list_.begin();
        it != prerender_list_.end();
@@ -194,3 +215,36 @@ PrerenderContents* PrerenderManager::FindEntry(const GURL& url) {
   // Entry not found.
   return NULL;
 }
+
+void PrerenderManager::RecordPrefetchTagObserved() {
+  // Ensure that we are in the UI thread, and post to the UI thread if
+  // necessary.
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        NewRunnableFunction(
+            &PrerenderManager::RecordPrefetchTagObservedOnUIThread));
+  } else {
+    RecordPrefetchTagObservedOnUIThread();
+  }
+}
+
+void PrerenderManager::RecordPrefetchTagObservedOnUIThread() {
+  // Once we get here, we have to be on the UI thread.
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // If we observe multiple tags within the 30 second window, we will still
+  // reset the window to begin at the most recent occurrence, so that we will
+  // always be in a window in the 30 seconds from each occurrence.
+  last_prefetch_seen_time_ = base::TimeTicks::Now();
+}
+
+bool PrerenderManager::ShouldRecordWindowedPPLT() const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (last_prefetch_seen_time_.is_null())
+    return false;
+  base::TimeDelta elapsed_time =
+      base::TimeTicks::Now() - last_prefetch_seen_time_;
+  return elapsed_time <= base::TimeDelta::FromSeconds(kWindowedPPLTSeconds);
+}
diff --git a/chrome/browser/prerender/prerender_manager.h b/chrome/browser/prerender/prerender_manager.h
index 7b8533c..de54500 100644
--- a/chrome/browser/prerender/prerender_manager.h
+++ b/chrome/browser/prerender/prerender_manager.h
@@ -55,7 +55,9 @@ class PrerenderManager : public base::RefCounted<PrerenderManager> {
   // Returns NULL if the specified URL has not been prerendered.
   PrerenderContents* GetEntry(const GURL& url);
 
+  // The following two methods should only be called from the UI thread.
   void RecordPerceivedPageLoadTime(base::TimeDelta pplt);
+  void RecordTimeUntilUsed(base::TimeDelta time_until_used);
 
   base::TimeDelta max_prerender_age() const { return max_prerender_age_; }
   void set_max_prerender_age(base::TimeDelta td) { max_prerender_age_ = td; }
@@ -65,6 +67,10 @@ class PrerenderManager : public base::RefCounted<PrerenderManager> {
   static PrerenderManagerMode GetMode();
   static void SetMode(PrerenderManagerMode mode);
 
+  // The following static method can be called from any thread, but will result
+  // in posting a task to the UI thread if we are not in the UI thread.
+  static void RecordPrefetchTagObserved();
+
  protected:
   virtual ~PrerenderManager();
 
@@ -90,6 +96,10 @@ class PrerenderManager : public base::RefCounted<PrerenderManager> {
   // ownership of the PrerenderContents.
   PrerenderContents* FindEntry(const GURL& url);
 
+  bool ShouldRecordWindowedPPLT() const;
+
+  static void RecordPrefetchTagObservedOnUIThread();
+
   Profile* profile_;
 
   base::TimeDelta max_prerender_age_;
@@ -104,10 +114,20 @@ class PrerenderManager : public base::RefCounted<PrerenderManager> {
   // Default maximum age a prerendered element may have, in seconds.
   static const int kDefaultMaxPrerenderAgeSeconds = 20;
 
+  // Time window for which we will record windowed PLT's from the last
+  // observed link rel=prefetch tag.
+  static const int kWindowedPPLTSeconds = 30;
+
   scoped_ptr<PrerenderContents::Factory> prerender_contents_factory_;
 
   static PrerenderManagerMode mode_;
 
+  // The time when we last saw a prefetch request coming from a renderer.
+  // This is used to record perceived PLT's for a certain amount of time
+  // from the point that we last saw a <link rel=prefetch> tag.
+  // This static variable should only be modified on the UI thread.
+  static base::TimeTicks last_prefetch_seen_time_;
+
   DISALLOW_COPY_AND_ASSIGN(PrerenderManager);
 };
 
diff --git a/chrome/browser/renderer_host/resource_dispatcher_host.cc b/chrome/browser/renderer_host/resource_dispatcher_host.cc
index 726242a..50c3a81 100644
--- a/chrome/browser/renderer_host/resource_dispatcher_host.cc
+++ b/chrome/browser/renderer_host/resource_dispatcher_host.cc
@@ -31,6 +31,7 @@
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/net/url_request_tracking.h"
 #include "chrome/browser/plugin_service.h"
+#include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_resource_handler.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/async_resource_handler.h"
@@ -127,9 +128,11 @@ bool ShouldServiceRequest(ChildProcessInfo::ProcessType process_type,
   if (process_type == ChildProcessInfo::PLUGIN_PROCESS)
     return true;
 
-  if (request_data.resource_type == ResourceType::PREFETCH &&
-      !ResourceDispatcherHost::is_prefetch_enabled())
-    return false;
+  if (request_data.resource_type == ResourceType::PREFETCH) {
+    PrerenderManager::RecordPrefetchTagObserved();
+    if (!ResourceDispatcherHost::is_prefetch_enabled())
+      return false;
+  }
 
   ChildProcessSecurityPolicy* policy =
       ChildProcessSecurityPolicy::GetInstance();