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 146 matching lines @@
   DCHECK_GE(static_cast<int>(info->candidate_urls_.size()), 1);
 
   if (!info->source_url_.url_lookup_success) {
     RecordEvent(EVENT_PRERENDER_URL_LOOKUP_FAILED);
     return;
   }
 
   LogCandidateURLStats(info->candidate_urls_[0].url);
 
   WebContents* source_web_contents = NULL;
+  bool multiple_source_web_contents_candidates = false;
 
 #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()) {
     if (it->GetURL() == info->source_url_.url) {
-      source_web_contents = *it;
-      break;
+      if (!source_web_contents)
+        source_web_contents = *it;
+      else
+        multiple_source_web_contents_candidates = true;
     }
   }
 #endif
 
   if (!source_web_contents) {
     RecordEvent(EVENT_PRERENDER_URL_LOOKUP_NO_SOURCE_WEBCONTENTS_FOUND);
     return;
   }
 
+  if (multiple_source_web_contents_candidates)
+    RecordEvent(EVENT_PRERENDER_URL_LOOKUP_MULTIPLE_SOURCE_WEBCONTENTS_FOUND);
+
+
   scoped_refptr<SessionStorageNamespace> session_storage_namespace =
       source_web_contents->GetController().GetDefaultSessionStorageNamespace();
 
   gfx::Rect container_bounds;
   source_web_contents->GetView()->GetContainerBounds(&container_bounds);
   scoped_ptr<gfx::Size> size(new gfx::Size(container_bounds.size()));
 
   scoped_refptr<LoggedInPredictorTable> logged_in_table =
       prerender_manager_->logged_in_predictor_table();
 
@@ skipping 216 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);
+  if (current_prerender_would_have_matched_ ||
+      !prerender_handle_.get() ||
+      !prerender_handle_->Matches(url, NULL)) {
+    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);
+  }
+  // If the namespace matches and the URL matches, we might be able to swap
+  // in. However, the actual code initating the swapin is in the renderer
+  // and is checking for other criteria (such as POSTs). There may
+  // also be conditions when a swapin should happen but does not. By recording
+  // the two previous events, we can keep an eye on the magnitude of the
+  // discrepancy.
+  current_prerender_would_have_matched_ = true;
+}
+
 }  // namespace prerender