Safe Browsing phishing interstitial redesign.

chrome/browser/safe_browsing/safe_browsing_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.
 //
 // Implementation of the SafeBrowsingBlockingPage class.
 
 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
 
 #include <string>
 
@@ skipping 53 matching lines @@
 
 static const char* const kSbReportPhishingErrorUrl =
     "http://www.google.com/safebrowsing/report_error/";
 
 // URL for the "Learn more" link on the multi threat malware blocking page.
 static const char* const kLearnMoreMalwareUrl =
     "https://www.google.com/support/bin/answer.py?answer=45449&topic=360"
     "&sa=X&oi=malwarewarninglink&resnum=1&ct=help";
 static const char* const kLearnMoreMalwareUrlV2 =
     "https://www.google.com/goodtoknow/online-safety/malware/";
+static const char* const kLearnMorePhishingUrlV2 =
+    "https://www.google.com/goodtoknow/online-safety/phishing/";
 
 // URL for the "Learn more" link on the phishing blocking page.
 static const char* const kLearnMorePhishingUrl =
     "https://www.google.com/support/bin/answer.py?answer=106318";
 
 static const char* const kSbDiagnosticHtml =
     "<a href=\"\" onclick=\"sendCommand('showDiagnostic'); return false;\" "
     "onmousedown=\"return false;\">%s</a>";
 
 static const char* const kPLinkHtml =
     "<a href=\"\" onclick=\"sendCommand('proceed'); return false;\" "
     "onmousedown=\"return false;\">%s</a>";
 
 static const char* const kPrivacyLinkHtml =
-    "<a href=\"\" onclick=\"sendCommand('showPrivacy'); return false;\" "
-    "onmousedown=\"return false;\">%s</a>";
+    "<a id=\"privacy-link\" href=\"\" onclick=\"sendCommand('showPrivacy'); "
+    "return false;\" onmousedown=\"return false;\">%s</a>";
 
 // After a malware interstitial where the user opted-in to the report
 // but clicked "proceed anyway", we delay the call to
 // MalwareDetails::FinishCollection() by this much time (in
 // milliseconds).
 static const int64 kMalwareDetailsProceedDelayMilliSeconds = 3000;
 
 // The commands returned by the page when the user performs an action.
 static const char* const kShowDiagnosticCommand = "showDiagnostic";
 static const char* const kReportErrorCommand = "reportError";
@@ skipping 20 matching lines @@
 
 // The default SafeBrowsingBlockingPageFactory.  Global, made a singleton so we
 // don't leak it.
 class SafeBrowsingBlockingPageFactoryImpl
     : public SafeBrowsingBlockingPageFactory {
  public:
   SafeBrowsingBlockingPage* CreateSafeBrowsingPage(
       SafeBrowsingService* service,
       WebContents* web_contents,
       const SafeBrowsingBlockingPage::UnsafeResourceList& unsafe_resources) {
-    // Only do the trial if the interstitial is for a single malware resource,
-    // the other types of interstitials have not been updated to V2 yet.
+    // Only do the trial if the interstitial is for a single malware or
+    // phishing resource, the multi-threat interstitial has not been updated to
+    // V2 yet.
     if (unsafe_resources.size() == 1 &&
-        unsafe_resources[0].threat_type == SafeBrowsingService::URL_MALWARE) {
+        (unsafe_resources[0].threat_type == SafeBrowsingService::URL_MALWARE ||
+         unsafe_resources[0].threat_type ==
+             SafeBrowsingService::URL_PHISHING)) {
       if (base::FieldTrialList::FindFullName("SBInterstitial") == "V2") {
         DVLOG(1) << "In V2 group.";
         return new SafeBrowsingBlockingPageV2(service, web_contents,
                                               unsafe_resources);
       }
       DVLOG(1) << "In V1 group.";
     }
     return new SafeBrowsingBlockingPageV1(service, web_contents,
                                           unsafe_resources);
   }
@@ skipping 115 matching lines @@
     return;
   }
 
   if (command == kLearnMoreCommandV2) {
     // User pressed "Learn more".
     GURL url;
     SafeBrowsingService::UrlCheckResult threat_type =
         unsafe_resources_[0].threat_type;
     if (threat_type == SafeBrowsingService::URL_MALWARE) {
       url = google_util::AppendGoogleLocaleParam(GURL(kLearnMoreMalwareUrlV2));
+    } else if (threat_type == SafeBrowsingService::URL_PHISHING ||
+               threat_type == SafeBrowsingService::CLIENT_SIDE_PHISHING_URL) {
+      url = google_util::AppendGoogleLocaleParam(GURL(kLearnMorePhishingUrlV2));
     } else {
       NOTREACHED();
     }
 
     OpenURLParams params(
         url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_LINK, false);
     web_contents_->OpenURL(params);
     return;
   }
 
@@ skipping 354 matching lines @@
           "SB2.MalwareInterstitialLearnMore", "SBInterstitial"), dt);
     } else if (command == kNavigatedAwayMetaCommand) {
       UMA_HISTOGRAM_MEDIUM_TIMES("SB2.MalwareInterstitialTimeClosed", dt);
       UMA_HISTOGRAM_MEDIUM_TIMES(base::FieldTrial::MakeName(
           "SB2.MalwareInterstitialTimeClosed", "SBInterstitial"), dt);
     } else if (command == kExpandedSeeMore) {
       // Only record the expanded histogram once per display of the
       // interstitial.
       if (has_expanded_see_more_section_)
         return;
+
       UMA_HISTOGRAM_MEDIUM_TIMES("SB2.MalwareInterstitialTimeExpandedSeeMore",
                                  dt);
       has_expanded_see_more_section_ = true;
       // Expanding the "See More" section doesn't finish the interstitial, so
       // don't mark the reaction time as recorded.
       recorded = false;
     } else {
       recorded = false;
     }
   } else {
     // Same as above but for phishing warnings.
     if (command == kProceedCommand) {
       UMA_HISTOGRAM_MEDIUM_TIMES("SB2.PhishingInterstitialTimeProceed", dt);
     } else if (command == kTakeMeBackCommand) {
       UMA_HISTOGRAM_MEDIUM_TIMES("SB2.PhishingInterstitialTimeTakeMeBack", dt);
     } else if (command == kShowDiagnosticCommand) {
       UMA_HISTOGRAM_MEDIUM_TIMES("SB2.PhishingInterstitialTimeReportError", dt);
     } else if (command == kLearnMoreCommand || command == kLearnMoreCommandV2) {
       UMA_HISTOGRAM_MEDIUM_TIMES("SB2.PhishingInterstitialTimeLearnMore", dt);
     } else if (command == kNavigatedAwayMetaCommand) {
       UMA_HISTOGRAM_MEDIUM_TIMES("SB2.PhishingInterstitialTimeClosed", dt);
     } else if (command == kExpandedSeeMore) {
-      // TODO(mattm): Add histogram for this when we implement V2 of the
-      // phishing interstitial.
-      NOTREACHED();
+      // Only record the expanded histogram once per display of the
+      // interstitial.
+      if (has_expanded_see_more_section_)
+        return;
+
+      UMA_HISTOGRAM_MEDIUM_TIMES("SB2.PhishingInterstitialTimeExpandedSeeMore",
+                                 dt);
+      has_expanded_see_more_section_ = true;
+      // Expanding the "See More" section doesn't finish the interstitial, so
+      // don't mark the reaction time as recorded.
       recorded = false;
     } else {
       recorded = false;
     }
   }
   if (recorded)  // Making sure we don't double-count reaction times.
     interstitial_show_time_ = base::TimeTicks();  //  Resets the show time.
 }
 
 void SafeBrowsingBlockingPage::FinishMalwareDetails(int64 delay_ms) {
@@ skipping 342 matching lines @@
     return std::string();
   }
 
   if (unsafe_resources_.size() > 1) {
     NOTREACHED();
   } else {
     SafeBrowsingService::UrlCheckResult threat_type =
         unsafe_resources_[0].threat_type;
     if (threat_type == SafeBrowsingService::URL_MALWARE) {
       PopulateMalwareStringDictionary(&strings);
-      html = rb.GetRawDataResource(
-          IDR_SAFE_BROWSING_MALWARE_BLOCK_V2,
-          ui::SCALE_FACTOR_NONE).as_string();
     } else {  // Phishing.
       DCHECK(threat_type == SafeBrowsingService::URL_PHISHING ||
              threat_type == SafeBrowsingService::CLIENT_SIDE_PHISHING_URL);
-      NOTREACHED();
+      PopulatePhishingStringDictionary(&strings);
     }
+    html = rb.GetRawDataResource(IDR_SAFE_BROWSING_MALWARE_BLOCK_V2,
+                                 ui::SCALE_FACTOR_NONE).as_string();
   }
   interstitial_show_time_ = base::TimeTicks::Now();
   return jstemplate_builder::GetTemplatesHtml(html, &strings, "template-root");
 }
 
 void SafeBrowsingBlockingPageV2::PopulateStringDictionary(
     DictionaryValue* strings,
     const string16& title,
     const string16& headline,
     const string16& description1,
     const string16& description2,
     const string16& description3) {
   strings->SetString("title", title);
   strings->SetString("headLine", headline);
   strings->SetString("description1", description1);
   strings->SetString("description2", description2);
   strings->SetString("description3", description3);
   strings->SetBoolean("proceedDisabled",
                       IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled));
   strings->SetBoolean("isMainFrame", is_main_frame_load_blocked_);
+  strings->SetBoolean("isPhishing", interstitial_type_ == TYPE_PHISHING);
 
   strings->SetString("back_button",
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_BACK_BUTTON));
   strings->SetString("seeMore", l10n_util::GetStringUTF16(
       IDS_SAFE_BROWSING_MALWARE_V2_SEE_MORE));
+  strings->SetString("proceed",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_V2_PROCEED_LINK));
 
   ChromeURLDataManager::DataSource::SetFontAndTextDirection(strings);
 }
 
 void SafeBrowsingBlockingPageV2::PopulateMultipleThreatStringDictionary(
     DictionaryValue* strings) {
   NOTREACHED();
 }
 
 void SafeBrowsingBlockingPageV2::PopulateMalwareStringDictionary(
@@ skipping 58 matching lines @@
     strings->SetString("confirm_text",
                        l10n_util::GetStringFUTF16(
                            IDS_SAFE_BROWSING_MALWARE_V2_REPORTING_AGREE,
                            UTF8ToUTF16(privacy_link)));
     if (IsPrefEnabled(prefs::kSafeBrowsingReportingEnabled))
       strings->SetString(kBoxChecked, "yes");
     else
       strings->SetString(kBoxChecked, "");
   }
 
-  strings->SetString("proceed",
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_V2_PROCEED_LINK));
+  strings->SetString("report_error", string16());
   strings->SetString("learnMore",
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_V2_LEARN_MORE));
 }
 
 void SafeBrowsingBlockingPageV2::PopulatePhishingStringDictionary(
     DictionaryValue* strings) {
-  NOTREACHED();
+  PopulateStringDictionary(
+      strings,
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_V2_TITLE),
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_V2_HEADLINE),
+      l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_PHISHING_V2_DESCRIPTION1,
+                                 l10n_util::GetStringUTF16(IDS_PRODUCT_NAME),
+                                 UTF8ToUTF16(url_.host())),
+      string16(),
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_V2_DESCRIPTION2));
+
+  strings->SetString("details", "");
+  strings->SetString("confirm_text", "");
+  strings->SetString(kBoxChecked, "");
+  strings->SetString("report_error",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_V2_REPORT_ERROR));
+  strings->SetBoolean(kDisplayCheckBox, false);
+  strings->SetString("learnMore",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_V2_LEARN_MORE));
 }