Fix the SSL interstitial UMA stats

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_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_preferences_util.h"
 #include "chrome/browser/ssl/ssl_error_info.h"
@@ skipping 27 matching lines @@
 using content::InterstitialPage;
 using content::NavigationController;
 using content::NavigationEntry;
 
 namespace {
 
 // These represent the commands sent by ssl_roadblock.html.
 enum SSLBlockingPageCommands {
   CMD_DONT_PROCEED,
   CMD_PROCEED,
-  CMD_FOCUS,
   CMD_MORE,
   CMD_RELOAD,
 };
 
 // Events for UMA.
 enum SSLBlockingPageEvent {
   SHOW_ALL,
   SHOW_OVERRIDABLE,
   PROCEED_OVERRIDABLE,
   PROCEED_NAME,
@@ skipping 16 matching lines @@
   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,
     int num_visits) {
   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.
+  if (!overridable) {
     // 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.
+    // back. If that's the case, don't record some of the metrics.
     return;
   }
   if (num_visits == 0)
     RecordSSLBlockingPageEventStats(SHOW_NEW_SITE);
   if (proceed) {
     RecordSSLBlockingPageEventStats(PROCEED_OVERRIDABLE);
     if (internal)
       RecordSSLBlockingPageEventStats(PROCEED_INTERNAL_HOSTNAME);
     if (num_visits == 0)
       RecordSSLBlockingPageEventStats(PROCEED_NEW_SITE);
@@ skipping 65 matching lines @@
       history_service->GetVisibleVisitCountToHost(
           request_url_,
           &request_consumer_,
           base::Bind(&SSLBlockingPage::OnGotHistoryCount,
                     base::Unretained(this)));
     }
   }
 
   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_,
                                        internal_,
-                                       display_start_time_,
                                        num_visits_);
     // The page is closed without the user having chosen what to do, default to
     // deny.
     NotifyDenyCertificate();
   }
 }
 
 std::string SSLBlockingPage::GetHTMLContents() {
   DictionaryValue strings;
   int resource_id;
@@ skipping 151 matching lines @@
 #endif  // !defined(OS_ANDROID)
 }
 
 // Matches events defined in ssl_error.html and ssl_roadblock.html.
 void SSLBlockingPage::CommandReceived(const std::string& command) {
   int cmd = atoi(command.c_str());
   if (cmd == CMD_DONT_PROCEED) {
     interstitial_page_->DontProceed();
   } else if (cmd == CMD_PROCEED) {
     interstitial_page_->Proceed();
-  } else if (cmd == CMD_FOCUS) {
-    // Start recording the time when the page is first in focus
-    display_start_time_ = base::TimeTicks::Now();
   } else if (cmd == CMD_MORE) {
     RecordSSLBlockingPageEventStats(MORE);
   } else if (cmd == CMD_RELOAD) {
     // The interstitial can't refresh itself.
     content::NavigationController* controller = &web_contents_->GetController();
     controller->Reload(true);
   }
 }
 
 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_,
                                      internal_,
-                                     display_start_time_,
                                      num_visits_);
   // Accepting the certificate resumes the loading of the page.
   NotifyAllowCertificate();
 }
 
 void SSLBlockingPage::OnDontProceed() {
   RecordSSLBlockingPageDetailedStats(false,
                                      cert_error_,
                                      overridable_ && !strict_enforcement_,
                                      internal_,
-                                     display_start_time_,
                                      num_visits_);
   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 25 matching lines @@
     strings->SetString(keys[i], std::string());
   }
 }
 
 void SSLBlockingPage::OnGotHistoryCount(HistoryService::Handle handle,
                                         bool success,
                                         int num_visits,
                                         base::Time first_visit) {
   num_visits_ = num_visits;
 }