NTP: add histogram to track New Tab page URL status.

chrome/browser/search/search.cc

 // Copyright 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/search/search.h"
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
+#include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/search/instant_service.h"
 #include "chrome/browser/search/instant_service_factory.h"
@@ skipping 60 matching lines @@
 // Dev & Canary, for now the code accepts both names.
 // TODO(dcblack): Remove the InstantExtended name once M31 hits the Beta
 // channel.
 const char kInstantExtendedFieldTrialName[] = "InstantExtended";
 const char kEmbeddedSearchFieldTrialName[] = "EmbeddedSearch";
 
 // If the field trial's group name ends with this string its configuration will
 // be ignored and Instant Extended will not be enabled by default.
 const char kDisablingSuffix[] = "DISABLED";
 
+// Reasons for falling back to the local NTP instead of using a valid search
+// provider's URL. Used in a UMA histogram so values should only be added at the
+// end and not reordered.
+// (Keep in sync with InstantExtended_LocalNTPFallbackReason.)
+enum LocalNTPFallbackReason {
+  LOCAL_NTP_FALLBACK_INSECURE_URL = 1,
+  LOCAL_NTP_FALLBACK_SUGGEST_OFF = 2,
+  LOCAL_NTP_FALLBACK_BLOCKED_URL = 3,
+  LOCAL_NTP_FALLBACK_MAX
+};
+
 // Used to set the Instant support state of the Navigation entry.
 const char kInstantSupportStateKey[] = "instant_support_state";
 
 const char kInstantSupportEnabled[] = "Instant support enabled";
 const char kInstantSupportDisabled[] = "Instant support disabled";
 const char kInstantSupportUnknown[] = "Instant support unknown";
 
 InstantSupportState StringToInstantSupportState(const base::string16& value) {
   if (value == base::ASCIIToUTF16(kInstantSupportEnabled))
     return INSTANT_SUPPORT_YES;
   else if (value == base::ASCIIToUTF16(kInstantSupportDisabled))
     return INSTANT_SUPPORT_NO;
   else
     return INSTANT_SUPPORT_UNKNOWN;
 }
 
 base::string16 InstantSupportStateToString(InstantSupportState state) {
   switch (state) {
     case INSTANT_SUPPORT_NO:
       return base::ASCIIToUTF16(kInstantSupportDisabled);
     case INSTANT_SUPPORT_YES:
       return base::ASCIIToUTF16(kInstantSupportEnabled);
     case INSTANT_SUPPORT_UNKNOWN:
       return base::ASCIIToUTF16(kInstantSupportUnknown);
   }
   return base::ASCIIToUTF16(kInstantSupportUnknown);
 }
 
+void RecordLocalNTPFallbackReason(LocalNTPFallbackReason reason) {
+  UMA_HISTOGRAM_ENUMERATION("InstantExtended.LocalNTPFallbackReason",
+                            reason,
+                            LOCAL_NTP_FALLBACK_MAX);
+}
+
 TemplateURL* GetDefaultSearchProviderTemplateURL(Profile* profile) {
   TemplateURLService* template_url_service =
       TemplateURLServiceFactory::GetForProfile(profile);
   if (template_url_service)
     return template_url_service->GetDefaultSearchProvider();
   return NULL;
 }
 
 GURL TemplateURLRefToGURL(const TemplateURLRef& ref,
                           int start_margin,
@@ skipping 320 matching lines @@
     result.push_back(TemplateURLRefToGURL(ref, kDisableStartMargin, false,
                                           false));
   }
   return result;
 }
 
 GURL GetNewTabPageURL(Profile* profile) {
   if (!profile || profile->IsOffTheRecord())
     return GURL();
 
-  if (!IsSuggestPrefEnabled(profile))
-    return GURL(chrome::kChromeSearchLocalNtpUrl);
-
   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
   if (!template_url)
     return GURL(chrome::kChromeSearchLocalNtpUrl);

[Jered, 2014/01/30 17:13:12]

How about adding another bucket, BAD_URL, to measure these other two cases? I'm
curious how much profile corruption is really a problem.

[samarth, 2014/01/31 16:05:20]

Done.

 
   GURL url(TemplateURLRefToGURL(template_url->new_tab_url_ref(),
                                 kDisableStartMargin, false, false));
-  if (!url.is_valid() || !url.SchemeIsSecure())
+  if (!url.is_valid())
     return GURL(chrome::kChromeSearchLocalNtpUrl);
 
-  if (!IsURLAllowedForSupervisedUser(url, profile))
+  if (!url.SchemeIsSecure()) {

[Jered, 2014/01/30 17:13:12]

If you add a bucket NONE, then we can normalize as a fraction of total calls to
this function, and you can write
LocalNTPFallbackReason fallback = NONE;
if (cond1)
  fallback = R1;
else if (cond2)
  fallback = R2;
...
record(fallback);
if (fallback != NONE)
  return url;
return GURL(localntp);

[samarth, 2014/01/31 16:05:20]

I ended up redoing this code to make it simpler and clearer.  It also changes it
so that we only log when the rewrite is happening and not whenever
GetNewTabPageURL is called.

+    RecordLocalNTPFallbackReason(LOCAL_NTP_FALLBACK_INSECURE_URL);
     return GURL(chrome::kChromeSearchLocalNtpUrl);
+  }
+
+  if (!IsSuggestPrefEnabled(profile)) {
+    RecordLocalNTPFallbackReason(LOCAL_NTP_FALLBACK_SUGGEST_OFF);
+    return GURL(chrome::kChromeSearchLocalNtpUrl);
+  }
+
+  if (!IsURLAllowedForSupervisedUser(url, profile)) {
+    RecordLocalNTPFallbackReason(LOCAL_NTP_FALLBACK_BLOCKED_URL);
+    return GURL(chrome::kChromeSearchLocalNtpUrl);
+  }
 
   return url;
 }
 
 GURL GetSearchResultPrefetchBaseURL(Profile* profile) {
   return ShouldPrefetchSearchResults() ?
       GetInstantURL(profile, kDisableStartMargin, true) : GURL();
 }
 
 bool ShouldPrefetchSearchResults() {
@@ skipping 222 matching lines @@
 
 // Given a FieldTrialFlags object, returns the boolean value of the provided
 // flag.
 bool GetBoolValueForFlagWithDefault(const std::string& flag,
                                     bool default_value,
                                     const FieldTrialFlags& flags) {
   return !!GetUInt64ValueForFlagWithDefault(flag, default_value ? 1 : 0, flags);
 }
 
 }  // namespace chrome