Add UMA to count the number of Google CAPTCHA pages shown and solved by users.

components/page_load_metrics/browser/metrics_web_contents_observer.cc

 // Copyright 2015 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 "components/page_load_metrics/browser/metrics_web_contents_observer.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "base/metrics/user_metrics.h"
 #include "components/page_load_metrics/browser/page_load_metrics_macros.h"
 #include "components/page_load_metrics/common/page_load_metrics_messages.h"
 #include "components/page_load_metrics/common/page_load_timing.h"
 #include "components/rappor/rappor_service.h"
 #include "components/rappor/rappor_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(
     page_load_metrics::MetricsWebContentsObserver);
 
 namespace page_load_metrics {
 
+const char kUMAGoogleCaptchaHistogram[] =
+  "GoogleCaptcha.Event";
+
 namespace {
 
 // The url we see from the renderer side is not always the same as what
 // we see from the browser side (e.g. chrome://newtab). We want to be
 // sure here that we aren't logging UMA for internal pages.
 bool IsRelevantNavigation(
     content::NavigationHandle* navigation_handle,
     const GURL& browser_url,
     const std::string& mime_type) {
   DCHECK(navigation_handle->HasCommitted());
@@ skipping 72 matching lines @@
     return 2;
   if (seconds < 16)
     return 3;
   if (seconds < 32)
     return 4;
   return 5;
 }
 
 }  // namespace
 
+bool IsGoogleCaptcha(const GURL& url) {
+  return (base::StartsWith(url.host(), "ipv4.google.",
+                           base::CompareCase::SENSITIVE)
+          || base::StartsWith(url.host(), "ipv6.google.",
+                              base::CompareCase::SENSITIVE))
+      && base::StartsWith(url.path(), "/sorry", base::CompareCase::SENSITIVE);
+}
+
 PageLoadTracker::PageLoadTracker(
     bool in_foreground,
     rappor::RapporService* const rappor_service,
     base::ObserverList<PageLoadMetricsObserver, true>* observers)
     : has_commit_(false),
       started_in_foreground_(in_foreground),
       rappor_service_(rappor_service),
       observers_(observers) {}
 
 PageLoadTracker::~PageLoadTracker() {
@@ skipping 300 matching lines @@
   // Passing a raw pointer to observers_ is safe because the
   // MetricsWebContentsObserver owns the PageLoadMetricsObserver list and is
   // torn down after the PageLoadTracker.
   provisional_loads_.insert(navigation_handle,
                             make_scoped_ptr(new PageLoadTracker(
                                 in_foreground_, rappor_service_, &observers_)));
 }
 
 void MetricsWebContentsObserver::DidFinishNavigation(
     content::NavigationHandle* navigation_handle) {
+  if (IsGoogleCaptcha(navigation_handle->GetURL())) {
+    UMA_HISTOGRAM_ENUMERATION(kUMAGoogleCaptchaHistogram, GOOGLE_CAPTCHA_SHOWN,

[Alexei Svitkine (slow), 2015/11/13 19:41:57]

Nit: Can you make a helper function to log this histogram? Each macro expands to
quite a bit of code, so having a helper function avoids some bloat. Then, you
can just inline the histogram name in the macro instead of a separate constant.

[Matt Welsh, 2015/11/13 20:15:19]

Done.

+                              GOOGLE_CAPTCHA_EVENT_BOUNDARY);
+  }
+
   if (!navigation_handle->IsInMainFrame())
     return;
 
   scoped_ptr<PageLoadTracker> finished_nav(
       provisional_loads_.take_and_erase(navigation_handle));
   // There's a chance a navigation could have started before we were added to a
   // tab. Bail out early if this is the case.
   if (!finished_nav)
     return;
 
@@ skipping 22 matching lines @@
   const std::string& mime_type = web_contents()->GetContentsMimeType();
   DCHECK(!browser_url.is_empty());
   DCHECK(!mime_type.empty());
   if (!IsRelevantNavigation(navigation_handle, browser_url, mime_type))
     return;
 
   committed_load_ = finished_nav.Pass();
   committed_load_->Commit(navigation_handle);
 }
 
+void MetricsWebContentsObserver::DidRedirectNavigation(
+    content::NavigationHandle* navigation_handle) {
+  if (IsGoogleCaptcha(navigation_handle->GetReferrer().url)) {
+    UMA_HISTOGRAM_ENUMERATION(kUMAGoogleCaptchaHistogram, GOOGLE_CAPTCHA_SOLVED,
+                              GOOGLE_CAPTCHA_EVENT_BOUNDARY);
+  }
+}
+
 void MetricsWebContentsObserver::WasShown() {
   in_foreground_ = true;
   if (committed_load_)
     committed_load_->WebContentsShown();
   for (const auto& kv : provisional_loads_) {
     kv.second->WebContentsShown();
   }
 }
 
 void MetricsWebContentsObserver::WasHidden() {
@@ skipping 42 matching lines @@
 
   if (!committed_load_->UpdateTiming(timing)) {
     // If the page load tracker cannot update its timing, something is wrong
     // with the IPC (it's from another load, or it's invalid in some other way).
     // We expect this to be a rare occurrence.
     RecordInternalError(ERR_BAD_TIMING_IPC);
   }
 }
 
 }  // namespace page_load_metrics