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";
 
+// Status of the New Tab URL for the default Search provider. NOTE: Used in a
+// UMA histogram so values should only be added at the end and not reordered.
+enum NewTabURLState {
+  // Valid URL that should be used.
+  NEW_TAB_URL_VALID = 0,
+
+  // Corrupt state (e.g. no profile or template url).
+  NEW_TAB_URL_BAD = 1,
+
+  // URL should not be used because in incognito window.
+  NEW_TAB_URL_INCOGNITO = 2,
+
+  // No New Tab URL set for provider.
+  NEW_TAB_URL_NOT_SET = 3,
+
+  // URL is not secure.
+  NEW_TAB_URL_INSECURE = 4,
+
+  // URL should not be used because Suggest is disabled.
+  NEW_TAB_URL_SUGGEST_OFF = 5,
+
+  // URL should not be used because it is blocked for a supervised user.
+  NEW_TAB_URL_BLOCKED = 6,
+
+  NEW_TAB_URL_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);
 }
 
 TemplateURL* GetDefaultSearchProviderTemplateURL(Profile* profile) {
-  TemplateURLService* template_url_service =
-      TemplateURLServiceFactory::GetForProfile(profile);
-  if (template_url_service)
-    return template_url_service->GetDefaultSearchProvider();
+  if (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,
                           bool append_extra_query_params,
                           bool force_instant_results) {
   TemplateURLRef::SearchTermsArgs search_terms_args =
       TemplateURLRef::SearchTermsArgs(base::string16());
   search_terms_args.omnibox_start_margin = start_margin;
@@ skipping 120 matching lines @@
   ManagedModeURLFilter* url_filter =
       managed_user_service->GetURLFilterForUIThread();
   if (url_filter->GetFilteringBehaviorForURL(url) ==
           ManagedModeURLFilter::BLOCK) {
     return false;
   }
 #endif
   return true;
 }
 
+// Returns whether |new_tab_url| can be used as a URL for the New Tab page.
+// NEW_TAB_URL_VALID means a valid URL; other enum values imply an invalid URL.
+NewTabURLState IsValidNewTabURL(Profile* profile, const GURL& new_tab_url) {
+  if (profile->IsOffTheRecord())
+    return NEW_TAB_URL_INCOGNITO;
+  if (!new_tab_url.is_valid())
+    return NEW_TAB_URL_NOT_SET;
+  if (!new_tab_url.SchemeIsSecure())
+    return NEW_TAB_URL_INSECURE;
+  if (!IsSuggestPrefEnabled(profile))
+    return NEW_TAB_URL_SUGGEST_OFF;
+  if (!IsURLAllowedForSupervisedUser(new_tab_url, profile))
+    return NEW_TAB_URL_BLOCKED;
+  return NEW_TAB_URL_VALID;
+}
+
+// Used to look up the URL to use for the New Tab page. Also tracks how we
+// arrived at that URL so it can be logged with UMA.
+struct NewTabURLDetails {
+  NewTabURLDetails(const GURL& url, NewTabURLState state)
+      : url(url), state(state) {}
+
+  static NewTabURLDetails ForProfile(Profile* profile) {
+    const GURL local_url(chrome::kChromeSearchLocalNtpUrl);
+    TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
+    if (!profile || !template_url)
+      return NewTabURLDetails(local_url, NEW_TAB_URL_BAD);
+
+    GURL search_provider_url = TemplateURLRefToGURL(
+        template_url->new_tab_url_ref(), kDisableStartMargin, false, false);
+    NewTabURLState state = IsValidNewTabURL(profile, search_provider_url);
+    switch (state) {
+      case NEW_TAB_URL_VALID:
+        // We can use the search provider's page.
+        return NewTabURLDetails(search_provider_url, state);
+      case NEW_TAB_URL_INCOGNITO:
+        // Incognito has its own New Tab.
+        return NewTabURLDetails(GURL(), state);
+      default:
+        // Use the local New Tab otherwise.
+        return NewTabURLDetails(local_url, state);
+    };
+  }
+
+  GURL url;
+  NewTabURLState state;
+};
+
 }  // namespace
 
 // Negative start-margin values prevent the "es_sm" parameter from being used.
 const int kDisableStartMargin = -1;
 
 bool IsInstantExtendedAPIEnabled() {
 #if defined(OS_IOS) || defined(OS_ANDROID)
   return false;
 #else
   return true;
@@ skipping 172 matching lines @@
     return result;
   for (size_t i = 0; i < template_url->URLCount(); ++i) {
     TemplateURLRef ref(template_url, i);
     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);
-
-  GURL url(TemplateURLRefToGURL(template_url->new_tab_url_ref(),
-                                kDisableStartMargin, false, false));
-  if (!url.is_valid() || !url.SchemeIsSecure())
-    return GURL(chrome::kChromeSearchLocalNtpUrl);
-
-  if (!IsURLAllowedForSupervisedUser(url, profile))
-    return GURL(chrome::kChromeSearchLocalNtpUrl);
-
-  return url;
+  return NewTabURLDetails::ForProfile(profile).url;
 }
 
 GURL GetSearchResultPrefetchBaseURL(Profile* profile) {
   return ShouldPrefetchSearchResults() ?
       GetInstantURL(profile, kDisableStartMargin, true) : GURL();
 }
 
 bool ShouldPrefetchSearchResults() {
   FieldTrialFlags flags;
   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
@@ skipping 104 matching lines @@
 bool HandleNewTabURLRewrite(GURL* url,
                             content::BrowserContext* browser_context) {
   if (!IsInstantExtendedAPIEnabled())
     return false;
 
   if (!url->SchemeIs(chrome::kChromeUIScheme) ||
       url->host() != chrome::kChromeUINewTabHost)
     return false;
 
   Profile* profile = Profile::FromBrowserContext(browser_context);
-  GURL new_tab_url(GetNewTabPageURL(profile));
-  if (!new_tab_url.is_valid())
-    return false;
-
-  *url = new_tab_url;
-  return true;
+  NewTabURLDetails details(NewTabURLDetails::ForProfile(profile));
+  UMA_HISTOGRAM_ENUMERATION("NewTabPage.URLState",
+                            details.state, NEW_TAB_URL_MAX);
+  if (details.url.is_valid()) {
+    *url = details.url;
+    return true;
+  }
+  return false;
 }
 
 bool HandleNewTabURLReverseRewrite(GURL* url,
                                    content::BrowserContext* browser_context) {
   if (!IsInstantExtendedAPIEnabled())
     return false;
 
+  // Do nothing in incognito.
   Profile* profile = Profile::FromBrowserContext(browser_context);
-  GURL new_tab_url(GetNewTabPageURL(profile));
-  if (!new_tab_url.is_valid() ||
-      !search::MatchesOriginAndPath(new_tab_url, *url))
+  if (profile && profile->IsOffTheRecord())
     return false;
 
-  *url = GURL(chrome::kChromeUINewTabURL);
-  return true;
+  if (search::MatchesOriginAndPath(
+      GURL(chrome::kChromeSearchLocalNtpUrl), *url)) {
+    *url = GURL(chrome::kChromeUINewTabURL);
+    return true;
+  }
+
+  GURL new_tab_url(GetNewTabPageURL(profile));
+  if (new_tab_url.is_valid() &&
+      search::MatchesOriginAndPath(new_tab_url, *url)) {
+    *url = GURL(chrome::kChromeUINewTabURL);
+    return true;
+  }
+
+  return false;
 }
 
 void SetInstantSupportStateInNavigationEntry(InstantSupportState state,
                                              content::NavigationEntry* entry) {
   if (!entry)
     return;
 
   entry->SetExtraData(kInstantSupportStateKey,
                       InstantSupportStateToString(state));
 }
@@ skipping 75 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