Create prerender event histograms by origin & experiment.

chrome/browser/prerender/prerender_manager.cc

 // 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.
 
 #include "chrome/browser/prerender/prerender_manager.h"
 
 #include <algorithm>
 #include <functional>
 #include <string>
 #include <vector>
@@ skipping 425 matching lines @@
 
 void PrerenderManager::ProcessMergeResult(
     PrerenderData* prerender_data,
     bool timed_out,
     content::SessionStorageNamespace::MergeResult result) {
   PendingSwap* pending_swap = prerender_data->pending_swap();
   DCHECK(pending_swap);
   // No pending_swap should never happen. If it does anyways (in a retail
   // build), log this and bail.
   if (!pending_swap) {
-    RecordEvent(PRERENDER_EVENT_MERGE_RESULT_NO_PENDING_SWAPIN);
+    RecordEvent(prerender_data->contents(),
+                PRERENDER_EVENT_MERGE_RESULT_NO_PENDING_SWAPIN);
     return;
   }
   if (timed_out) {
-    RecordEvent(PRERENDER_EVENT_MERGE_RESULT_TIMEOUT_CB);
+    RecordEvent(prerender_data->contents(),
+                PRERENDER_EVENT_MERGE_RESULT_TIMEOUT_CB);
   } else {
-    RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_CB);
+    RecordEvent(prerender_data->contents(),
+                PRERENDER_EVENT_MERGE_RESULT_RESULT_CB);
     UMA_HISTOGRAM_TIMES("Prerender.SessionStorageNamespaceMergeTime",
                         pending_swap->GetElapsedTime());
   }
 
   // Any return here must call ClearPendingSwap on |prerender_data| before
   // returning, with one exception: when the prerender was ultimately swapped
   // in. In that case, SwapInternal will take care of deleting
   // |prerender_data| and sending the appropriate notifications to the tracker.
   if (timed_out) {
-    RecordEvent(PRERENDER_EVENT_MERGE_RESULT_TIMED_OUT);
+    RecordEvent(prerender_data->contents(),
+                PRERENDER_EVENT_MERGE_RESULT_TIMED_OUT);
     prerender_data->ClearPendingSwap();
     return;
   }
 
-  RecordEvent(PRERENDER_EVENT_MERGE_RESULT_MERGE_DONE);
+  RecordEvent(prerender_data->contents(),
+              PRERENDER_EVENT_MERGE_RESULT_MERGE_DONE);
 
   // Log the exact merge result in a histogram.
   switch (result) {
     case content::SessionStorageNamespace::MERGE_RESULT_NAMESPACE_NOT_FOUND:
-      RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_NAMESPACE_NOT_FOUND);
+      RecordEvent(prerender_data->contents(),
+                  PRERENDER_EVENT_MERGE_RESULT_RESULT_NAMESPACE_NOT_FOUND);
       break;
     case content::SessionStorageNamespace::MERGE_RESULT_NAMESPACE_NOT_ALIAS:
-      RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_NAMESPACE_NOT_ALIAS);
+      RecordEvent(prerender_data->contents(),
+                  PRERENDER_EVENT_MERGE_RESULT_RESULT_NAMESPACE_NOT_ALIAS);
       break;
     case content::SessionStorageNamespace::MERGE_RESULT_NOT_LOGGING:
-      RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_NOT_LOGGING);
+      RecordEvent(prerender_data->contents(),
+                  PRERENDER_EVENT_MERGE_RESULT_RESULT_NOT_LOGGING);
       break;
     case content::SessionStorageNamespace::MERGE_RESULT_NO_TRANSACTIONS:
-      RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_NO_TRANSACTIONS);
+      RecordEvent(prerender_data->contents(),
+                  PRERENDER_EVENT_MERGE_RESULT_RESULT_NO_TRANSACTIONS);
       break;
     case content::SessionStorageNamespace::MERGE_RESULT_TOO_MANY_TRANSACTIONS:
-      RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_TOO_MANY_TRANSACTIONS);
+      RecordEvent(prerender_data->contents(),
+                  PRERENDER_EVENT_MERGE_RESULT_RESULT_TOO_MANY_TRANSACTIONS);
       break;
     case content::SessionStorageNamespace::MERGE_RESULT_NOT_MERGEABLE:
-      RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_NOT_MERGEABLE);
+      RecordEvent(prerender_data->contents(),
+                  PRERENDER_EVENT_MERGE_RESULT_RESULT_NOT_MERGEABLE);
       break;
     case content::SessionStorageNamespace::MERGE_RESULT_MERGEABLE:
-      RecordEvent(PRERENDER_EVENT_MERGE_RESULT_RESULT_MERGEABLE);
+      RecordEvent(prerender_data->contents(),
+                  PRERENDER_EVENT_MERGE_RESULT_RESULT_MERGEABLE);
       break;
     default:
       NOTREACHED();
   }
 
   if (result != content::SessionStorageNamespace::MERGE_RESULT_MERGEABLE &&
       result !=
       content::SessionStorageNamespace::MERGE_RESULT_NO_TRANSACTIONS) {
-    RecordEvent(PRERENDER_EVENT_MERGE_RESULT_MERGE_FAILED);
+    RecordEvent(prerender_data->contents(),
+                PRERENDER_EVENT_MERGE_RESULT_MERGE_FAILED);
     prerender_data->ClearPendingSwap();
     return;
   }
 
-  RecordEvent(PRERENDER_EVENT_MERGE_RESULT_SWAPPING_IN);
+  RecordEvent(prerender_data->contents(),
+              PRERENDER_EVENT_MERGE_RESULT_SWAPPING_IN);
   // Notice that SwapInInternal, on success, will delete |prerender_data|
   // and |pending_swap|. Therefore, we have to pass a new GURL object rather
   // than a reference to the one in |pending_swap|.
   content::WebContents* new_web_contents =
       SwapInternal(GURL(pending_swap->url()),
                    pending_swap->target_contents(),
                    prerender_data);
-  if (new_web_contents) {
-    RecordEvent(PRERENDER_EVENT_MERGE_RESULT_SWAPIN_SUCCESSFUL);
-  } else {
-    RecordEvent(PRERENDER_EVENT_MERGE_RESULT_SWAPIN_FAILED);
+  if (!new_web_contents) {
+    RecordEvent(prerender_data->contents(),
+                PRERENDER_EVENT_MERGE_RESULT_SWAPIN_FAILED);
     prerender_data->ClearPendingSwap();
   }
 }
 
 bool PrerenderManager::MaybeUsePrerenderedPage(const GURL& url,
                                                chrome::NavigateParams* params) {
   DCHECK(CalledOnValidThread());
 
   content::WebContents* web_contents = params->target_contents;
   DCHECK(!IsWebContentsPrerendering(web_contents, NULL));
@@ skipping 20 matching lines @@
   DCHECK(!IsWebContentsPrerendering(web_contents, NULL));
 
   DeleteOldEntries();
   to_delete_prerenders_.clear();
   // TODO(ajwong): This doesn't handle isolated apps correctly.
 
   // Only if this WebContents is used in a tabstrip may be swap.
   // We check this by examining whether its CoreTabHelper has a delegate.
   CoreTabHelper* core_tab_helper = CoreTabHelper::FromWebContents(web_contents);
   if (!core_tab_helper || !core_tab_helper->delegate()) {
-    RecordEvent(PRERENDER_EVENT_SWAPIN_NO_DELEGATE);
+    RecordEvent(NULL, PRERENDER_EVENT_SWAPIN_NO_DELEGATE);
     return NULL;
   }
 
   // First, try to find prerender data with the correct session storage
   // namespace.
   PrerenderData* prerender_data = FindPrerenderData(
       url,
       web_contents->GetController().GetDefaultSessionStorageNamespace());
 
   // If this failed, we may still find a prerender for the same URL, but a
   // different session storage namespace. If we do, we might have to perform
   // a merge.
   if (!prerender_data) {
     prerender_data = FindPrerenderData(url, NULL);
   } else {
-    RecordEvent(PRERENDER_EVENT_SWAPIN_CANDIDATE_NAMESPACE_MATCHES);
+    RecordEvent(prerender_data->contents(),
+                PRERENDER_EVENT_SWAPIN_CANDIDATE_NAMESPACE_MATCHES);
   }
 
   if (!prerender_data)
     return NULL;
-  RecordEvent(PRERENDER_EVENT_SWAPIN_CANDIDATE);
+  RecordEvent(prerender_data->contents(), PRERENDER_EVENT_SWAPIN_CANDIDATE);
   DCHECK(prerender_data->contents());
 
   // If there is currently a merge pending for this prerender data,
   // or this webcontents, do not swap in, but give the merge a chance to
   // finish and swap into the intended target webcontents.
   if (prerender_data != swap_candidate && prerender_data->pending_swap()) {
     return NULL;
   }
 
-  RecordEvent(PRERENDER_EVENT_SWAPIN_NO_MERGE_PENDING);
+  RecordEvent(prerender_data->contents(),
+              PRERENDER_EVENT_SWAPIN_NO_MERGE_PENDING);
   SessionStorageNamespace* target_namespace =
       web_contents->GetController().GetDefaultSessionStorageNamespace();
   SessionStorageNamespace* prerender_namespace =
       prerender_data->contents()->GetSessionStorageNamespace();
   // Only when actually prerendering is session storage namespace merging an
   // issue. For the control group, it will be assumed that the merge succeeded.
   if (prerender_namespace && prerender_namespace != target_namespace &&
       !prerender_namespace->IsAliasOf(target_namespace)) {
     if (!ShouldMergeSessionStorageNamespaces()) {
-      RecordEvent(PRERENDER_EVENT_SWAPIN_MERGING_DISABLED);
+      RecordEvent(prerender_data->contents(),
+                  PRERENDER_EVENT_SWAPIN_MERGING_DISABLED);
       return NULL;
     }
-    RecordEvent(PRERENDER_EVENT_SWAPIN_ISSUING_MERGE);
+    RecordEvent(prerender_data->contents(),
+                PRERENDER_EVENT_SWAPIN_ISSUING_MERGE);
     // There should never be a |pending_swap| if we get to here:
     // Per check above, |pending_swap| may only be != NULL when
     // processing a successful merge, as indicated by |swap_candidate|
     // != NULL. But in that case, there should be no need for yet another merge.
     DCHECK(!prerender_data->pending_swap());
     if (prerender_data->pending_swap()) {
       // In retail builds, log this error and bail.
-      RecordEvent(PRERENDER_EVENT_MERGE_FOR_SWAPIN_CANDIDATE);
+      RecordEvent(prerender_data->contents(),
+                  PRERENDER_EVENT_MERGE_FOR_SWAPIN_CANDIDATE);
       return NULL;
     }
     PendingSwap* pending_swap = new PendingSwap(
         prerender_tracker_,
         web_contents,
         prerender_data,
         url,
         base::Bind(&PrerenderManager::ProcessMergeResult,
                    AsWeakPtr(),
                    prerender_data,
@@ skipping 1297 matching lines @@
   if (logged_in_state_.get())
     logged_in_state_->erase(domain_key);
 }
 
 void PrerenderManager::LoggedInPredictorDataReceived(
     scoped_ptr<LoggedInStateMap> new_map) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   logged_in_state_.swap(new_map);
 }
 
-void PrerenderManager::RecordEvent(PrerenderEvent event) const {
-  histograms_->RecordEvent(event);
+void PrerenderManager::RecordEvent(PrerenderContents* contents,
+                                   PrerenderEvent event) const {
+  if (!contents)
+    histograms_->RecordEvent(ORIGIN_NONE, kNoExperiment, event);
+  else
+    histograms_->RecordEvent(contents->origin(), contents->experiment_id(),
+                             event);
 }
 
 }  // namespace prerender