Add UMA entry for intranet SSL warnings

chrome/browser/ssl/ssl_blocking_page.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/ssl/ssl_blocking_page.h"
 
 #include "base/i18n/rtl.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_piece.h"
@@ skipping 11 matching lines @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/ssl_status.h"
 #include "grit/app_locale_settings.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "net/base/net_errors.h"
+#include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/webui/jstemplate_builder.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 using base::TimeTicks;
 using content::InterstitialPage;
@@ skipping 18 matching lines @@
   PROCEED_OVERRIDABLE,
   PROCEED_NAME,
   PROCEED_DATE,
   PROCEED_AUTHORITY,
   DONT_PROCEED_OVERRIDABLE,
   DONT_PROCEED_NAME,
   DONT_PROCEED_DATE,
   DONT_PROCEED_AUTHORITY,
   MORE,
   SHOW_UNDERSTAND,
+  SHOW_INTERNAL_HOSTNAME,
+  PROCEED_INTERNAL_HOSTNAME,
   UNUSED_BLOCKING_PAGE_EVENT,
 };
 
 void RecordSSLBlockingPageEventStats(SSLBlockingPageEvent event) {
   UMA_HISTOGRAM_ENUMERATION("interstitial.ssl",
                             event,
                             UNUSED_BLOCKING_PAGE_EVENT);
 }
 
 void RecordSSLBlockingPageDetailedStats(
     bool proceed,
     int cert_error,
     bool overridable,
+    bool internal,
     const base::TimeTicks& start_time) {
   UMA_HISTOGRAM_ENUMERATION("interstitial.ssl_error_type",
      SSLErrorInfo::NetErrorToErrorType(cert_error), SSLErrorInfo::END_OF_ENUM);
   if (start_time.is_null() || !overridable) {
     // A null start time will occur if the page never came into focus.
     // Overridable is false if the user didn't have any option except to turn
     // back. In either case, we don't want to record some of our metrics.
     return;
   }
-  if (proceed)
+  if (proceed) {
     RecordSSLBlockingPageEventStats(PROCEED_OVERRIDABLE);
-  else if (!proceed)
+    if (internal)
+      RecordSSLBlockingPageEventStats(PROCEED_INTERNAL_HOSTNAME);
+  } else if (!proceed) {
     RecordSSLBlockingPageEventStats(DONT_PROCEED_OVERRIDABLE);
+  }
   SSLErrorInfo::ErrorType type = SSLErrorInfo::NetErrorToErrorType(cert_error);
   switch (type) {
     case SSLErrorInfo::CERT_COMMON_NAME_INVALID: {
       if (proceed)
         RecordSSLBlockingPageEventStats(PROCEED_NAME);
       else
         RecordSSLBlockingPageEventStats(DONT_PROCEED_NAME);
       break;
     }
     case SSLErrorInfo::CERT_DATE_INVALID: {
@@ skipping 37 matching lines @@
     const GURL& request_url,
     bool overridable,
     bool strict_enforcement,
     const base::Callback<void(bool)>& callback)
     : callback_(callback),
       web_contents_(web_contents),
       cert_error_(cert_error),
       ssl_info_(ssl_info),
       request_url_(request_url),
       overridable_(overridable),
-      strict_enforcement_(strict_enforcement) {
+      strict_enforcement_(strict_enforcement),
+      internal_(false) {
   trialCondition_ = base::FieldTrialList::FindFullName(kStudyName);
 
+  if (net::IsHostnameNonUnique(request_url_.HostNoBrackets()))
+    internal_ = true;
+
   RecordSSLBlockingPageEventStats(SHOW_ALL);
-  if (overridable_ && !strict_enforcement_)
+  if (overridable_ && !strict_enforcement_) {
     RecordSSLBlockingPageEventStats(SHOW_OVERRIDABLE);
+    if (internal_)
+      RecordSSLBlockingPageEventStats(SHOW_INTERNAL_HOSTNAME);
+  }
 
   interstitial_page_ = InterstitialPage::Create(
       web_contents_, true, request_url, this);
   display_start_time_ = TimeTicks();
   interstitial_page_->Show();
 }
 
 SSLBlockingPage::~SSLBlockingPage() {
   if (!callback_.is_null()) {
-    RecordSSLBlockingPageDetailedStats(
-      false, cert_error_,
-      overridable_ && !strict_enforcement_, display_start_time_);
+    RecordSSLBlockingPageDetailedStats(false,
+                                       cert_error_,
+                                       overridable_ && !strict_enforcement_,
+                                       internal_,
+                                       display_start_time_);
     // The page is closed without the user having chosen what to do, default to
     // deny.
     NotifyDenyCertificate();
   }
 }
 
 std::string SSLBlockingPage::GetHTMLContents() {
   // Let's build the html error page.
   DictionaryValue strings;
   SSLErrorInfo error_info =
@@ skipping 102 matching lines @@
 }
 
 void SSLBlockingPage::OverrideRendererPrefs(
       content::RendererPreferences* prefs) {
   Profile* profile = Profile::FromBrowserContext(
       web_contents_->GetBrowserContext());
   renderer_preferences_util::UpdateFromSystemSettings(prefs, profile);
 }
 
 void SSLBlockingPage::OnProceed() {
-  RecordSSLBlockingPageDetailedStats(true, cert_error_,
-      overridable_ && !strict_enforcement_, display_start_time_);
-
+  RecordSSLBlockingPageDetailedStats(true,
+                                     cert_error_,
+                                     overridable_ && !strict_enforcement_,
+                                     internal_,
+                                     display_start_time_);
   // Accepting the certificate resumes the loading of the page.
   NotifyAllowCertificate();
 }
 
 void SSLBlockingPage::OnDontProceed() {
-  RecordSSLBlockingPageDetailedStats(false, cert_error_,
-    overridable_ && !strict_enforcement_, display_start_time_);
-
+  RecordSSLBlockingPageDetailedStats(false,
+                                     cert_error_,
+                                     overridable_ && !strict_enforcement_,
+                                     internal_,
+                                     display_start_time_);
   NotifyDenyCertificate();
 }
 
 void SSLBlockingPage::NotifyDenyCertificate() {
   // It's possible that callback_ may not exist if the user clicks "Proceed"
   // followed by pressing the back button before the interstitial is hidden.
   // In that case the certificate will still be treated as allowed.
   if (callback_.is_null())
     return;
 
@@ skipping 17 matching lines @@
       "moreInfo1", "moreInfo2", "moreInfo3", "moreInfo4", "moreInfo5"
   };
   int i;
   for (i = 0; i < static_cast<int>(extra_info.size()); i++) {
     strings->SetString(keys[i], extra_info[i]);
   }
   for (; i < 5; i++) {
     strings->SetString(keys[i], std::string());
   }
 }