Add instrumentation to see how often a local predictor prerender could be

chrome/browser/prerender/prerender_local_predictor.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_local_predictor.h"
 
 #include <ctype.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 288 matching lines @@
   base::Time actual_start_time;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PrerenderProperties);
 };
 
 PrerenderLocalPredictor::PrerenderLocalPredictor(
     PrerenderManager* prerender_manager)
     : prerender_manager_(prerender_manager),
       is_visit_database_observer_(false),
-      weak_factory_(this) {
+      weak_factory_(this),
+      current_prerender_would_have_matched_(false) {
   RecordEvent(EVENT_CONSTRUCTED);
   if (MessageLoop::current()) {
     timer_.Start(FROM_HERE,
                  base::TimeDelta::FromMilliseconds(kInitDelayMs),
                  this,
                  &PrerenderLocalPredictor::Init);
     RecordEvent(EVENT_INIT_SCHEDULED);
   }
 
   static const size_t kChecksumHashSize = 32;
@@ skipping 155 matching lines @@
   WebContents* source_web_contents = NULL;
 
 #if !defined(OS_ANDROID)
   // We need to figure out what tab launched the prerender. We do this by
   // comparing URLs. This may not always work: the URL may occur in two
   // tabs, and we pick the wrong one, or the tab we should have picked
   // may have navigated elsewhere. Hopefully, this doesn't happen too often,
   // so we ignore these cases for now.
   // TODO(tburkard): Reconsider this, potentially measure it, and fix this
   // in the future.
   for (TabContentsIterator it; !it.done(); it.Next()) {

[Shishir, 2013/05/14 18:19:34]

Since you are adding stats, how about adding a stat here for the number of times
you see multiple possible tabs that a prerender can go into. That way you can
compare to the other stats you added and find other cases the prerender does not
get swapped in.

[tburkard, 2013/05/14 19:28:06]

Done.

     if (it->GetURL() == info->source_url_.url) {
       source_web_contents = *it;
       break;
     }
   }
 #endif
 
   if (!source_web_contents) {
     RecordEvent(EVENT_PRERENDER_URL_LOOKUP_NO_SOURCE_WEBCONTENTS_FOUND);
     return;
@@ skipping 228 matching lines @@
   const GURL& url = info->url;
   double priority = info->priority;
   base::Time current_time = GetCurrentTime();
   RecordEvent(EVENT_ISSUING_PRERENDER);
 
   current_prerender_priority_ = priority;
   scoped_ptr<prerender::PrerenderHandle> old_prerender_handle(
       prerender_handle_.release());
   prerender_handle_.reset(prerender_manager_->AddPrerenderFromLocalPredictor(
       url, session_storage_namespace.get(), *size));
+  current_prerender_would_have_matched_ = false;
   if (old_prerender_handle)
     old_prerender_handle->OnCancel();
 
   RecordEvent(EVENT_ADD_VISIT_PRERENDERING);
   if (current_prerender_.get() && current_prerender_->url_id == url_id) {
     RecordEvent(EVENT_ADD_VISIT_PRERENDERING_EXTENDED);
     if (priority > current_prerender_->priority)
       current_prerender_->priority = priority;
     // If the prerender already existed, we want to extend it.  However,
     // we do not want to set its start_time to the current time to
     // disadvantage PLT computations when the prerender is swapped in.
     // So we set the new start time to current_time - 10s (since the vast
     // majority of PLTs are < 10s), provided that is not before the actual
     // time the prerender was started (so as to not artificially advantage
     // the PLT computation).
     base::Time simulated_new_start_time =
         current_time - base::TimeDelta::FromSeconds(10);
     if (simulated_new_start_time > current_prerender_->start_time)
       current_prerender_->start_time = simulated_new_start_time;
   } else {
     current_prerender_.reset(
         new PrerenderProperties(url_id, url, priority, current_time));
   }
   current_prerender_->actual_start_time = current_time;
 }
 
+void PrerenderLocalPredictor::OnTabHelperURLSeen(
+    const GURL& url, WebContents* web_contents) {
+  RecordEvent(EVENT_TAB_HELPER_URL_SEEN);

[Shishir, 2013/05/14 18:19:34]

This event will have a lot of duplicates since it is called from both
provisional load start and commit. Ideally you would want cleaner stats.

[tburkard, 2013/05/14 19:28:06]

We already have other events for when a DidNavigate happens, so we can compare
against these if we want cleaner stats.

On 2013/05/14 18:19:34, Shishir wrote:

+  if (current_prerender_would_have_matched_ ||
+      !prerender_handle_.get() ||
+      !prerender_handle_->Matches(url, NULL)) {

[Shishir, 2013/05/14 18:19:34]

Can you call this with NULL if the prerender is live? There is a check in
prerender contents that would likely fail.

[tburkard, 2013/05/14 19:28:06]

Done.

+    return;
+  }
+  RecordEvent(EVENT_TAB_HELPER_URL_SEEN_MATCH);
+  if (prerender_handle_->Matches(
+          url,
+          web_contents->GetController().GetDefaultSessionStorageNamespace())) {
+    RecordEvent(EVENT_TAB_HELPER_URL_SEEN_NAMESPACE_MATCH);
+  }
+  current_prerender_would_have_matched_ = true;

[Shishir, 2013/05/14 18:19:34]

Can you add a comment as to the conditions where this can happen. Ideally if the
URL and namespace matches, this would have gotten swapped in.

[tburkard, 2013/05/14 19:28:06]

Done.

+}
+
 }  // namespace prerender