Updating histograms to allow for experiments & log origin-based histograms.

chrome/browser/prerender/prerender_manager.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_manager.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "chrome/browser/prerender/prerender_history.h"
 #include "chrome/browser/prerender/prerender_observer.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
+#include "chrome/browser/prerender/prerender_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper_delegate.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/tab_contents/render_view_host_manager.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_delegate.h"
 #include "content/common/notification_service.h"
-#include "googleurl/src/url_canon.h"
-#include "googleurl/src/url_parse.h"
-#include "googleurl/src/url_util.h"
 
 namespace prerender {
 
 namespace {
 
 // Time window for which we will record windowed PLT's from the last
 // observed link rel=prefetch tag.
 const int kWindowDurationSeconds = 30;
 
 // Time interval at which periodic cleanups are performed.
@@ skipping 12 matching lines @@
   "OPTIONS",
   "POST",
   "TRACE",
 };
 
 // Length of prerender history, for display in chrome://net-internals
 const int kHistoryLength = 100;
 
 }  // namespace
 
+// Helper macros for experiment-based and origin-based histogram reporting.
+#define PREFIXED_HISTOGRAM(histogram) \
+  PREFIXED_HISTOGRAM_INTERNAL(GetCurrentOrigin(), GetCurrentExperimentId(), \
+                              IsOriginExperimentWash(), histogram)
+
+#define PREFIXED_HISTOGRAM_PRERENDER_MANAGER(pm, histogram) \
+  PREFIXED_HISTOGRAM_INTERNAL(pm->GetCurrentOrigin(), \
+                              pm->GetCurrentExperimentId(), \
+                              pm->IsOriginExperimentWash(), histogram)
+
+#define PREFIXED_HISTOGRAM_ORIGIN_EXPERIMENT(origin, experiment, histogram) \
+  PREFIXED_HISTOGRAM_INTERNAL(origin, experiment, false, histogram)
+
+#define PREFIXED_HISTOGRAM_INTERNAL(origin, experiment, wash, histogram) { \
+  static uint8 recording_experiment = kNoExperiment; \
+  if (recording_experiment == kNoExperiment && experiment != kNoExperiment) \
+    recording_experiment = experiment; \
+  if (wash) { \
+    histogram; \
+  } else if (experiment != kNoExperiment && \
+             (origin != ORIGIN_LINK_REL_PRERENDER || \
+              experiment != recording_experiment)) { \
+  } else if (experiment != kNoExperiment) { \
+    histogram; \
+  } else if (origin == ORIGIN_OMNIBOX) { \
+    histogram; \
+  } else { \
+    histogram; \
+  } \
+}
+
 class PrerenderManager::OnCloseTabContentsDeleter : public TabContentsDelegate {
  public:
   OnCloseTabContentsDeleter(PrerenderManager* manager,
                             TabContentsWrapper* tab)
       : manager_(manager),
         tab_(tab) {
     tab_->tab_contents()->set_delegate(this);
   }
 
   virtual void CloseContents(TabContents* source) OVERRIDE {
@@ skipping 36 matching lines @@
       GetMode() == PRERENDER_MODE_EXPERIMENT_PRERENDER_GROUP ||
       GetMode() == PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP;
 }
 
 // static
 bool PrerenderManager::IsControlGroup() {
   return GetMode() == PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP;
 }
 
 // static
-bool PrerenderManager::MaybeGetQueryStringBasedAliasURL(
-    const GURL& url, GURL* alias_url) {
-  DCHECK(alias_url);
-  url_parse::Parsed parsed;
-  url_parse::ParseStandardURL(url.spec().c_str(), url.spec().length(),
-                              &parsed);
-  url_parse::Component query = parsed.query;
-  url_parse::Component key, value;
-  while (url_parse::ExtractQueryKeyValue(url.spec().c_str(), &query, &key,
-                                         &value)) {
-    if (key.len != 3 || strncmp(url.spec().c_str() + key.begin, "url", key.len))
-      continue;
-    // We found a url= query string component.
-    if (value.len < 1)
-      continue;
-    url_canon::RawCanonOutputW<1024> decoded_url;
-    url_util::DecodeURLEscapeSequences(url.spec().c_str() + value.begin,
-                                       value.len, &decoded_url);
-    GURL new_url(string16(decoded_url.data(), decoded_url.length()));
-    if (!new_url.is_empty() && new_url.is_valid()) {
-      *alias_url = new_url;
-      return true;
-    }
-    return false;
-  }
-  return false;
-}
-
-// static
 bool PrerenderManager::IsValidHttpMethod(const std::string& method) {
   // method has been canonicalized to upper case at this point so we can just
   // compare them.
   DCHECK_EQ(method, StringToUpperASCII(method));
   for (size_t i = 0; i < arraysize(kValidHttpMethods); ++i) {
     if (method.compare(kValidHttpMethods[i]) == 0)
       return true;
   }
 
   return false;
@@ skipping 27 matching lines @@
   GURL referrer_;
   Origin origin_;
 };
 
 PrerenderManager::PrerenderManager(Profile* profile,
                                    PrerenderTracker* prerender_tracker)
     : enabled_(true),
       profile_(profile),
       prerender_tracker_(prerender_tracker),
       prerender_contents_factory_(PrerenderContents::CreateFactory()),
+      last_experiment_id_(kNoExperiment),
+      last_origin_(ORIGIN_LINK_REL_PRERENDER),
+      origin_experiment_wash_(false),
       last_prerender_start_time_(GetCurrentTimeTicks() -
           base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs)),
       runnable_method_factory_(this),
       prerender_history_(new PrerenderHistory(kHistoryLength)) {
   // There are some assumptions that the PrerenderManager is on the UI thread.
   // Any other checks simply make sure that the PrerenderManager is accessed on
   // the same thread that it was created on.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
@@ skipping 26 matching lines @@
   return AddPrerender(ORIGIN_OMNIBOX, std::make_pair(-1, -1), url, GURL());
 }
 
 bool PrerenderManager::AddPrerender(
     Origin origin,
     const std::pair<int, int>& child_route_id_pair,
     const GURL& url_arg,
     const GURL& referrer) {
   DCHECK(CalledOnValidThread());
 
+  // Check if we are doing an experiment.
+  uint8 experiment = GetQueryStringBasedExperiment(url_arg);
+
+  // We need to update last_experiment_id_, last_origin_, and
+  // origin_experiment_wash_.
+  if (!WithinWindow()) {
+    // If we are outside a window, this is a fresh start and we are fine,
+    // and there is no mix.
+    origin_experiment_wash_ = false;
+  } else {
+    // If we are inside the last window, there is a mish mash of origins
+    // and experiments if either there was a mish mash before, or the current
+    // experiment/origin does not match the previous one.
+    if (experiment != last_experiment_id_ || origin != last_origin_)
+      origin_experiment_wash_ = true;
+  }
+
+  last_origin_ = origin;
+  last_experiment_id_ = experiment;
+
   // 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_prerender_seen_time_ = GetCurrentTimeTicks();
 
   // If the referring page is prerendering, defer the prerender.
   if (FindPrerenderContentsForChildRouteIdPair(child_route_id_pair) !=
           prerender_list_.end()) {
     AddPendingPrerender(origin, child_route_id_pair, url_arg, referrer);
     return true;
   }
 
   DeleteOldEntries();
   DeletePendingDeleteEntries();
 
   GURL url = url_arg;
   GURL alias_url;
-  if (IsControlGroup() &&
-      PrerenderManager::MaybeGetQueryStringBasedAliasURL(
-          url, &alias_url)) {
+  if (IsControlGroup() && MaybeGetQueryStringBasedAliasURL(url, &alias_url)) {
     url = alias_url;
   }
 
   if (FindEntry(url))
     return false;
 
   // Do not prerender if there are too many render processes, and we would
   // have to use an existing one.  We do not want prerendering to happen in
   // a shared process, so that we can always reliably lower the CPU
   // priority for prerendering.
   // In single-process mode, ShouldTryToUseExistingProcessHost() always returns
   // true, so that case needs to be explicitly checked for.
   // TODO(tburkard): Figure out how to cancel prerendering in the opposite
   // case, when a new tab is added to a process used for prerendering.
   if (RenderProcessHost::ShouldTryToUseExistingProcessHost() &&
       !RenderProcessHost::run_renderer_in_process()) {
-    RecordFinalStatus(origin, FINAL_STATUS_TOO_MANY_PROCESSES);
+    RecordFinalStatus(origin, experiment, FINAL_STATUS_TOO_MANY_PROCESSES);
     return false;
   }
 
   // Check if enough time has passed since the last prerender.
   if (!DoesRateLimitAllowPrerender()) {
     // Cancel the prerender. We could add it to the pending prerender list but
     // this doesn't make sense as the next prerender request will be triggered
     // by a navigation and is unlikely to be the same site.
-    RecordFinalStatus(origin, FINAL_STATUS_RATE_LIMIT_EXCEEDED);
+    RecordFinalStatus(origin, experiment, FINAL_STATUS_RATE_LIMIT_EXCEEDED);
     return false;
   }
 
   RenderViewHost* source_render_view_host = NULL;
   // This test should fail only during unit tests.
   if (child_route_id_pair.first != -1) {
     source_render_view_host =
         RenderViewHost::FromID(child_route_id_pair.first,
                                child_route_id_pair.second);
     // Don't prerender page if parent RenderViewHost no longer exists, or it has
     // no view.  The latter should only happen when the RenderView has closed.
     if (!source_render_view_host || !source_render_view_host->view()) {
-      RecordFinalStatus(origin, FINAL_STATUS_SOURCE_RENDER_VIEW_CLOSED);
+      RecordFinalStatus(origin, experiment,
+                        FINAL_STATUS_SOURCE_RENDER_VIEW_CLOSED);
       return false;
     }
   }
 
   PrerenderContents* prerender_contents =
-      CreatePrerenderContents(url, referrer, origin);
+      CreatePrerenderContents(url, referrer, origin, experiment);
   if (!prerender_contents || !prerender_contents->Init())
     return false;
 
   // TODO(cbentzel): Move invalid checks here instead of PrerenderContents?
   PrerenderContentsData data(prerender_contents, GetCurrentTime());
 
   prerender_list_.push_back(data);
 
   if (IsControlGroup()) {
     data.contents_->set_final_status(FINAL_STATUS_CONTROL_GROUP);
@@ skipping 149 matching lines @@
   // Try to set the prerendered page as used, so any subsequent attempts to
   // cancel on other threads will fail.  If this fails because the prerender
   // was already cancelled, possibly on another thread, fail.
   if (!prerender_tracker_->TryUse(child_id, route_id))
     return false;
 
   if (!prerender_contents->load_start_time().is_null())
     RecordTimeUntilUsed(GetCurrentTimeTicks() -
                         prerender_contents->load_start_time());
 
-  UMA_HISTOGRAM_COUNTS("Prerender.PrerendersPerSessionCount",
-                       ++prerenders_per_session_count_);
+  PREFIXED_HISTOGRAM(UMA_HISTOGRAM_COUNTS(
+      GetDefaultHistogramName("PrerendersPerSessionCount"),
+      ++prerenders_per_session_count_));
   prerender_contents->set_final_status(FINAL_STATUS_USED);
 
   RenderViewHost* render_view_host =
       prerender_contents->prerender_contents()->render_view_host();
   DCHECK(render_view_host);
   render_view_host->Send(
       new ViewMsg_SetIsPrerendering(render_view_host->routing_id(), false));
 
   TabContentsWrapper* new_tab_contents =
       prerender_contents->ReleasePrerenderContents();
@@ skipping 89 matching lines @@
 
 bool PrerenderManager::IsPrerenderElementFresh(const base::Time start) const {
   DCHECK(CalledOnValidThread());
   base::Time now = GetCurrentTime();
   return (now - start < config_.max_age);
 }
 
 PrerenderContents* PrerenderManager::CreatePrerenderContents(
     const GURL& url,
     const GURL& referrer,
-    Origin origin) {
+    Origin origin,
+    uint8 experiment_id) {
   DCHECK(CalledOnValidThread());
   return prerender_contents_factory_->CreatePrerenderContents(
-      this, prerender_tracker_, profile_, url, referrer, origin);
+      this, prerender_tracker_, profile_, url, referrer, origin, experiment_id);
 }
 
 bool PrerenderManager::IsPendingDelete(PrerenderContents* entry) const {
   DCHECK(CalledOnValidThread());
   for (std::list<PrerenderContents*>::const_iterator it =
           pending_delete_list_.begin();
        it != pending_delete_list_.end();
        ++it) {
     if (*it == entry)
       return true;
   }
 
   return false;
 }
 
 void PrerenderManager::DeletePendingDeleteEntries() {
   while (!pending_delete_list_.empty()) {
     PrerenderContents* contents = pending_delete_list_.front();
     pending_delete_list_.pop_front();
     AddToHistory(contents);
     delete contents;
   }
 }
 
 // Helper macro for histograms.
 #define RECORD_PLT(tag, perceived_page_load_time) { \
+  PREFIXED_HISTOGRAM_PRERENDER_MANAGER(prerender_manager, \
     UMA_HISTOGRAM_CUSTOM_TIMES( \
-        base::FieldTrial::MakeName(std::string("Prerender.") + tag, \
-                                   "Prefetch"), \
+        base::FieldTrial::MakeName( \
+            prerender_manager->GetDefaultHistogramName(tag), "Prefetch"), \
         perceived_page_load_time, \
         base::TimeDelta::FromMilliseconds(10), \
         base::TimeDelta::FromSeconds(60), \
-        100); \
-  }
+        100)); \
+}
 
 // static
 void PrerenderManager::RecordPerceivedPageLoadTime(
     base::TimeDelta perceived_page_load_time,
     TabContents* tab_contents) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PrerenderManager* prerender_manager =
       tab_contents->profile()->GetPrerenderManager();
   if (!prerender_manager)
     return;
@@ skipping 77 matching lines @@
     return false;
   base::TimeDelta elapsed_time =
       base::TimeTicks::Now() - last_prerender_seen_time_;
   return elapsed_time <= base::TimeDelta::FromSeconds(kWindowDurationSeconds);
 }
 
 bool PrerenderManager::DoesRateLimitAllowPrerender() const {
   DCHECK(CalledOnValidThread());
   base::TimeDelta elapsed_time =
       GetCurrentTimeTicks() - last_prerender_start_time_;
-  UMA_HISTOGRAM_TIMES("Prerender.TimeBetweenPrerenderRequests",
-                      elapsed_time);
+  PREFIXED_HISTOGRAM(
+      UMA_HISTOGRAM_TIMES(
+          GetDefaultHistogramName("TimeBetweenPrerenderRequests"),
+          elapsed_time));
   if (!config_.rate_limit_enabled)
     return true;
   return elapsed_time >
       base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs);
 }
 
 void PrerenderManager::StartSchedulingPeriodicCleanups() {
   DCHECK(CalledOnValidThread());
   if (repeating_timer_.IsRunning())
     return;
@@ skipping 219 matching lines @@
   while (!prerender_list_.empty()) {
     PrerenderContentsData data = prerender_list_.front();
     prerender_list_.pop_front();
     data.contents_->Destroy(final_status);
   }
   DeletePendingDeleteEntries();
 }
 
 void PrerenderManager::RecordTimeUntilUsed(base::TimeDelta time_until_used) {
   DCHECK(CalledOnValidThread());
-  UMA_HISTOGRAM_CUSTOM_TIMES(
-      "Prerender.TimeUntilUsed",
+  PREFIXED_HISTOGRAM(UMA_HISTOGRAM_CUSTOM_TIMES(
+      GetDefaultHistogramName("TimeUntilUsed"),
       time_until_used,
       base::TimeDelta::FromMilliseconds(10),
       config_.max_age,
-      50);
+      50));
+}
+
+void PrerenderManager::RecordFinalStatus(Origin origin,
+                                         uint8 experiment_id,
+                                         FinalStatus final_status) const {
+  DCHECK(final_status != FINAL_STATUS_MAX);
+  // FINAL_STATUS_CONTROL_GROUP indicates that the PrerenderContents
+  // was created only to measure "would-have-been-prerendered" for
+  // control group measurements. Don't pollute data with it.
+  if (PrerenderManager::IsControlGroup() ||
+      final_status == FINAL_STATUS_CONTROL_GROUP)
+    return;
+  PREFIXED_HISTOGRAM_ORIGIN_EXPERIMENT(origin, experiment_id,
+                     UMA_HISTOGRAM_ENUMERATION(
+                         GetHistogramName(origin, experiment_id, "FinalStatus"),
+                         final_status,
+                         FINAL_STATUS_MAX));
+}
+
+std::string PrerenderManager::ComposeHistogramName(
+    const std::string& prefix_type,
+    const std::string& name) const {
+  if (prefix_type.empty())
+    return std::string("Prerender.") + name;
+  return std::string("Prerender.") + prefix_type + std::string("_") + name;
+}
+
+std::string PrerenderManager::GetHistogramName(Origin origin,
+                                               uint8 experiment_id,
+                                               const std::string& name) const {
+  switch (origin) {
+    case ORIGIN_OMNIBOX:
+      if (experiment_id != kNoExperiment)
+        return ComposeHistogramName("wash", name);
+      return ComposeHistogramName("omnibox", name);
+    case ORIGIN_LINK_REL_PRERENDER:
+      if (experiment_id == kNoExperiment)
+        return ComposeHistogramName("", name);
+      return ComposeHistogramName("exp" + std::string(1, experiment_id + '0'),
+                                  name);
+    default:
+      NOTREACHED();
+      break;
+  };
+
+  // Dummy return value to make the compiler happy.
+  NOTREACHED();
+  return ComposeHistogramName("wash", name);
+}
+
+std::string PrerenderManager::GetDefaultHistogramName(
+    const std::string& name) const {
+  if (!WithinWindow())
+    return ComposeHistogramName("", name);
+  if (origin_experiment_wash_)
+    return ComposeHistogramName("wash", name);
+  return GetHistogramName(last_origin_, last_experiment_id_, name);
+}
+
+uint8 PrerenderManager::GetCurrentExperimentId() const {
+  if (!WithinWindow())
+    return kNoExperiment;
+  return last_experiment_id_;
+}
+
+Origin PrerenderManager::GetCurrentOrigin() const {
+  if (!WithinWindow())
+    return ORIGIN_LINK_REL_PRERENDER;
+  return last_origin_;
+}
+
+bool PrerenderManager::IsOriginExperimentWash() const {
+  if (!WithinWindow())
+    return false;
+  return origin_experiment_wash_;
 }
 
 }  // namespace prerender