added clock interstitial to chrome://interstitials

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/build_time.h"
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "base/i18n/time_formatting.h"
@@ skipping 204 matching lines @@
 const void* SSLBlockingPage::kTypeForTesting =
     &SSLBlockingPage::kTypeForTesting;
 
 // Note that we always create a navigation entry with SSL errors.
 // No error happening loading a sub-resource triggers an interstitial so far.
 SSLBlockingPage::SSLBlockingPage(content::WebContents* web_contents,
                                  int cert_error,
                                  const net::SSLInfo& ssl_info,
                                  const GURL& request_url,
                                  int options_mask,
-                                 const base::Callback<void(bool)>& callback)
+                                 const base::Callback<void(bool)>& callback,
+                                 const base::Time& base_time)
     : SecurityInterstitialPage(web_contents, request_url),
       callback_(callback),
       cert_error_(cert_error),
       ssl_info_(ssl_info),
       overridable_(IsOptionsOverridable(options_mask)),
       danger_overridable_(true),
       strict_enforcement_((options_mask & STRICT_ENFORCEMENT) != 0),
       expired_but_previously_allowed_(
-          (options_mask & EXPIRED_BUT_PREVIOUSLY_ALLOWED) != 0) {
-  interstitial_reason_ =
-      IsErrorDueToBadClock(base::Time::NowFromSystemTime(), cert_error_) ?
-      SSL_REASON_BAD_CLOCK : SSL_REASON_SSL;
+          (options_mask & EXPIRED_BUT_PREVIOUSLY_ALLOWED) != 0),
+      time_triggered_(base_time) {

[lgarron, 2015/02/24 02:28:37]

I would make the constructor argument and the instance variable have the same
name (apart from the underscore).

[fahl, 2015/02/24 21:23:23]

Done.

+  interstitial_reason_ = IsErrorDueToBadClock(time_triggered_, cert_error_)
+                             ? SSL_REASON_BAD_CLOCK
+                             : SSL_REASON_SSL;
 
   // We collapse the Rappor metric name to just "ssl" so we don't leak
   // the "overridable" bit.  We skip Rappor altogether for bad clocks.
   // This must be done after calculating |interstitial_reason_| above.
   metrics_helper_.reset(new SecurityInterstitialMetricsHelper(
       web_contents, request_url, GetUmaHistogramPrefix(), kSSLRapporPrefix,
       (interstitial_reason_ == SSL_REASON_BAD_CLOCK
            ? SecurityInterstitialMetricsHelper::SKIP_RAPPOR
            : SecurityInterstitialMetricsHelper::REPORT_RAPPOR),
       GetSamplingEventName()));
 
   metrics_helper_->RecordUserDecision(SecurityInterstitialMetricsHelper::SHOW);
   metrics_helper_->RecordUserInteraction(
       SecurityInterstitialMetricsHelper::TOTAL_VISITS);
 
   ssl_error_classification_.reset(new SSLErrorClassification(
       web_contents,
-      base::Time::NowFromSystemTime(),
+      time_triggered_,
       request_url,
       cert_error_,
       *ssl_info_.cert.get()));
   ssl_error_classification_->RecordUMAStatistics(overridable_);
 
   // Creating an interstitial without showing (e.g. from chrome://interstitials)
   // it leaks memory, so don't create it here.
 }
 
 bool SSLBlockingPage::ShouldCreateNewNavigation() const {
@@ skipping 22 matching lines @@
 }
 
 void SSLBlockingPage::PopulateInterstitialStrings(
     base::DictionaryValue* load_time_data) {
   CHECK(load_time_data);
   base::string16 url(GetFormattedHostName());
   // Shared values for both the overridable and non-overridable versions.
   load_time_data->SetString("type", "SSL");
 
   // Shared UI configuration for all SSL interstitials.
-  base::Time now = base::Time::NowFromSystemTime();
   load_time_data->SetString("errorCode", net::ErrorToString(cert_error_));
   load_time_data->SetString(
       "openDetails",
       l10n_util::GetStringUTF16(IDS_SSL_V2_OPEN_DETAILS_BUTTON));
   load_time_data->SetString(
       "closeDetails",
       l10n_util::GetStringUTF16(IDS_SSL_V2_CLOSE_DETAILS_BUTTON));
 
   // Conditional UI configuration.
   if (interstitial_reason_ == SSL_REASON_BAD_CLOCK) {
     load_time_data->SetBoolean("bad_clock", true);
     load_time_data->SetBoolean("overridable", false);
 
 #if defined(OS_IOS)
     load_time_data->SetBoolean("hide_primary_button", true);
 #else
     load_time_data->SetBoolean("hide_primary_button", false);
 #endif
 
     // We're showing the SSL clock warning to be helpful, but we haven't warned
     // them about the risks. (And there might still be an SSL error after they
     // fix their clock.) Thus, we don't allow the "danger" override in this
     // case.
     danger_overridable_ = false;
 
-    int heading_string = SSLErrorClassification::IsUserClockInTheFuture(now) ?
-                              IDS_SSL_V2_CLOCK_AHEAD_HEADING :
-                              IDS_SSL_V2_CLOCK_BEHIND_HEADING;
+    int heading_string =
+        SSLErrorClassification::IsUserClockInTheFuture(time_triggered_)
+            ? IDS_SSL_V2_CLOCK_AHEAD_HEADING
+            : IDS_SSL_V2_CLOCK_BEHIND_HEADING;
 
     load_time_data->SetString(
         "tabTitle",
         l10n_util::GetStringUTF16(IDS_SSL_V2_CLOCK_TITLE));
     load_time_data->SetString(
         "heading",
         l10n_util::GetStringUTF16(heading_string));
-    load_time_data->SetString("primaryParagraph",
-                              l10n_util::GetStringFUTF16(
-                                  IDS_SSL_V2_CLOCK_PRIMARY_PARAGRAPH ,
-                                  url,
-                                  base::TimeFormatFriendlyDateAndTime(now)));
+    load_time_data->SetString(
+        "primaryParagraph",
+        l10n_util::GetStringFUTF16(
+            IDS_SSL_V2_CLOCK_PRIMARY_PARAGRAPH, url,
+            base::TimeFormatFriendlyDateAndTime(time_triggered_)));
 
     load_time_data->SetString(
         "primaryButtonText",
         l10n_util::GetStringUTF16(IDS_SSL_V2_CLOCK_UPDATE_DATE_AND_TIME));
     load_time_data->SetString(
         "explanationParagraph",
         l10n_util::GetStringUTF16(IDS_SSL_V2_CLOCK_EXPLANATION));
 
     // The interstitial template expects this string, but we're not using it. So
     // we send a blank string for now.
@@ skipping 70 matching lines @@
 
   // Set debugging information at the bottom of the warning.
   load_time_data->SetString(
       "subject", ssl_info_.cert->subject().GetDisplayName());
   load_time_data->SetString(
       "issuer", ssl_info_.cert->issuer().GetDisplayName());
   load_time_data->SetString(
       "expirationDate",
       base::TimeFormatShortDate(ssl_info_.cert->valid_expiry()));
   load_time_data->SetString(
-      "currentDate", base::TimeFormatShortDate(now));
+      "currentDate", base::TimeFormatShortDate(time_triggered_));
   std::vector<std::string> encoded_chain;
-  ssl_info_.cert->GetPEMEncodedChain(&encoded_chain);
-  load_time_data->SetString("pem", JoinString(encoded_chain, std::string()));
+  ssl_info_.cert->GetPEMEncodedChain(
+      &encoded_chain);
+  load_time_data->SetString(
+      "pem", JoinString(encoded_chain, std::string()));
 }
 
 void SSLBlockingPage::OverrideEntry(NavigationEntry* entry) {
   int cert_id = content::CertStore::GetInstance()->StoreCert(
       ssl_info_.cert.get(), web_contents()->GetRenderProcessHost()->GetID());
   DCHECK(cert_id);
 
   entry->GetSSL().security_style =
       content::SECURITY_STYLE_AUTHENTICATION_BROKEN;
   entry->GetSSL().cert_id = cert_id;
@@ skipping 117 matching lines @@
     event_name.append(kEventNotOverridable);
   event_name.append(net::ErrorToString(cert_error_));
   return event_name;
 }
 
 // static
 bool SSLBlockingPage::IsOptionsOverridable(int options_mask) {
   return (options_mask & SSLBlockingPage::OVERRIDABLE) &&
          !(options_mask & SSLBlockingPage::STRICT_ENFORCEMENT);
 }