Add metrics for tracking UX impact of non-static CLD data providers

chrome/renderer/translate/translate_helper.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/renderer/translate/translate_helper.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
+#include "base/metrics/user_metrics_action.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/renderer/isolated_world_ids.h"
 #include "components/translate/content/common/translate_messages.h"
 #include "components/translate/core/common/translate_constants.h"
 #include "components/translate/core/common/translate_metrics.h"
 #include "components/translate/core/common/translate_util.h"
 #include "components/translate/core/language_detection/language_detection_util.h"
+#include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/constants.h"
 #include "extensions/renderer/extension_groups.h"
 #include "ipc/ipc_platform_file.h"
 #include "content/public/common/url_constants.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebNodeList.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/WebKit/public/web/WebWidget.h"
 #include "url/gurl.h"
 #include "v8/include/v8.h"
 
 using base::ASCIIToUTF16;
 using blink::WebDocument;
 using blink::WebElement;
 using blink::WebFrame;
 using blink::WebNode;
 using blink::WebNodeList;
 using blink::WebScriptSource;
 using blink::WebSecurityOrigin;
 using blink::WebString;
 using blink::WebVector;
 using blink::WebView;
 
+// Note on metrics:
+//
+// This class provides metrics that allow tracking the user experience impact
+// of non-static CldDataProvider implementations. For background on the data
+// providers, please refer to the following documentation:
+// http://www.chromium.org/developers/how-tos/compact-language-detector-cld-data-source-configuration
+//
+// Available metrics:
+// 1. Translate.LanguageDetectionOnTime
+//      Recorded if PageCaptured(...) is invoked after CLD is available.
+//      This is the ideal case, indicating that CLD is available before it is
+//      needed.
+// 2. Translate.LanguageDetectionDeferred
+//      Recorded if PageCaptured(...) is invoked before CLD is available.
+//      Sub-optimal case indicating that CLD wasn't available when it was
+//      needed, so the request for detection has been deferred until CLD is
+//      available or until the user navigates to a different page.
+// 3. Translate.LanguageDetectionLate
+//      Recorded if CLD becomes available after a language detection request
+//      was deferred as above in (2), but before the user navigated to a
+//      different page. Language detection is ultimately completed, it just
+//      didn't happen on time.
+//
+// Note that there is NOT a metric that records the number of times that
+// language detection had to be aborted because CLD never became available in
+// time. This is because there is no reasonable way to cover all the cases
+// under which this could occur, particularly the destruction of the renderer
+// for which this object was created. However, this value can be synthetically
+// derived, using the logic below.
+//
+// Every page load that triggers language detection will result in the
+// recording of exactly one of the first two metrics in the list above:
+// Translate.LanguageDetectionOnTime or Translate.LanguageDetectionDeferred.
+// If CLD is available in time to satisfy the request, the third metric
+// (Translate.LanguageDetectionLate) will be recorded; thus, the number of
+// times when language detection ultimately fails because CLD isn't ever
+// available is implied as the number of times that detection is deferred minus
+// the number of times that language detection is late. Note that this, too,
+// is not necessarily 100% relevant: some renderer process are so short-lived
+// that language detection wouldn't have been relevant anywaysm and so a failure

[Andrew Hayden (chromium.org), 2014/07/14 14:24:13]

"anywaysm" -> "anyways,"

[simonb1, 2014/07/14 16:23:48]

"anyways" -> "anyway" :-)
http://www.dailywritingtips.com/anyway-any-way-or-anyways/

+// to detect the language in a timely manner might be completely innocuous.
+
 namespace {
 
 // The delay in milliseconds that we'll wait before checking to see if the
 // translate library injected in the page is ready.
 const int kTranslateInitCheckDelayMs = 150;
 
 // The maximum number of times we'll check to see if the translate library
 // injected in the page is ready.
 const int kMaxTranslateInitCheckAttempts = 5;
 
@@ skipping 23 matching lines @@
       weak_method_factory_(this),
       cld_data_provider_(translate::CreateRendererCldDataProviderFor(this)),
       cld_data_polling_started_(false),
       cld_data_polling_canceled_(false),
       deferred_page_capture_(false),
       deferred_page_seq_no_(-1) {
 }
 
 TranslateHelper::~TranslateHelper() {
   CancelPendingTranslation();
-  CancelCldDataPolling();
 }
 
 void TranslateHelper::PrepareForUrl(const GURL& url) {
   ++page_seq_no_;
   Send(new ChromeViewHostMsg_TranslateAssignedSequenceNumber(
       routing_id(), page_seq_no_));
   deferred_page_capture_ = false;
   deferred_page_seq_no_ = -1;
   deferred_contents_.clear();
   if (cld_data_polling_started_)
@@ skipping 31 matching lines @@
   // header.  The two actually have different meanings (despite the
   // original intent of http-equiv to be an equivalent) with the former
   // being the language of the document and the latter being the
   // language of the intended audience (a distinction really only
   // relevant for things like langauge textbooks).  This distinction
   // shouldn't affect translation.
   WebFrame* main_frame = GetMainFrame();
   if (!main_frame || page_seq_no_ != page_seq_no)
     return;
 
-  // TODO(andrewhayden): UMA insertion point here: Track if data is available.
-  // TODO(andrewhayden): Retry insertion point here, retry till data available.
   if (!cld_data_provider_->IsCldDataAvailable()) {
     // We're in dynamic mode and CLD data isn't loaded. Retry when CLD data
     // is loaded, if ever.
     deferred_page_capture_ = true;
     deferred_page_seq_no_ = page_seq_no;
     deferred_contents_ = contents;
+    content::RenderThread::Get()->RecordAction(
+        base::UserMetricsAction("Translate.LanguageDetectionDeferred"));
     return;
   }
 
+  if (deferred_page_seq_no_ == -1) {
+    // CLD data was available before language detection was requested.
+    content::RenderThread::Get()->RecordAction(
+        base::UserMetricsAction("Translate.LanguageDetectionOnTime"));
+  } else {
+    // This is a request that was triggered because CLD data is now available
+    // and was previously deferred.
+    content::RenderThread::Get()->RecordAction(
+        base::UserMetricsAction("Translate.LanguageDetectionLate"));
+  }
+
   WebDocument document = main_frame->document();
   std::string content_language = document.contentLanguage().utf8();
   WebElement html_element = document.documentElement();
   std::string html_lang;
   // |html_element| can be null element, e.g. in
   // BrowserTest.WindowOpenClose.
   if (!html_element.isNull())
     html_lang = html_element.getAttribute("lang").utf8();
   std::string cld_language;
   bool is_cld_reliable;
@@ skipping 437 matching lines @@
 }
 
 void TranslateHelper::OnCldDataAvailable() {
   if (deferred_page_capture_) {
     deferred_page_capture_ = false; // Don't do this a second time.
     PageCapturedImpl(deferred_page_seq_no_, deferred_contents_);
     deferred_page_seq_no_ = -1; // Clean up for sanity
     deferred_contents_.clear(); // Clean up for sanity
   }
 }