Safe Browsing malware interstitial redesign field trial.

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>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/lazy_instance.h"
+#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_preferences_util.h"
 #include "chrome/browser/safe_browsing/malware_details.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/webui/ntp/new_tab_ui.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/browser_resources.h"
+#include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using content::BrowserThread;
 using content::InterstitialPage;
 using content::OpenURLParams;
@@ skipping 11 matching lines @@
     "http://safebrowsing.clients.google.com/safebrowsing/diagnostic?site=%s&client=chromium";
 #endif
 
 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/";
 
 // 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";
-
-// URL for the "Safe Browsing Privacy Policies" link on the blocking page.
-// Note: this page is not yet localized.
-static const char* const kSbPrivacyPolicyUrl =
-    "http://www.google.com/intl/en_us/privacy/browsing.html";
+static const char* const kLearnMorePhishingUrlV2 =
+    "https://www.google.com/goodtoknow/online-safety/phishing/";

[kewang, 2012/08/21 10:23:05]

when will this be shown?

[mattm, 2012/08/21 18:29:12]

Ah, added that prematurely.  Removed for now.

 
 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>";
 
 // 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";
 static const char* const kLearnMoreCommand = "learnMore";
+static const char* const kLearnMoreCommandV2 = "learnMore2";
 static const char* const kShowPrivacyCommand = "showPrivacy";
 static const char* const kProceedCommand = "proceed";
 static const char* const kTakeMeBackCommand = "takeMeBack";
 static const char* const kDoReportCommand = "doReport";
 static const char* const kDontReportCommand = "dontReport";
 static const char* const kDisplayCheckBox = "displaycheckbox";
+static const char* const kDisplayShowDiagnostic = "displayShowDiagnostic";
 static const char* const kBoxChecked = "boxchecked";
+static const char* const kExpandedSeeMore = "expandedSeeMore";
 // Special command that we use when the user navigated away from the
 // page.  E.g., closed the tab or the window.  This is only used by
 // RecordUserReactionTime.
 static const char* const kNavigatedAwayMetaCommand = "closed";
 
 // static
 SafeBrowsingBlockingPageFactory* SafeBrowsingBlockingPage::factory_ = NULL;
 
 static base::LazyInstance<SafeBrowsingBlockingPage::UnsafeResourceMap>
     g_unsafe_resource_map = LAZY_INSTANCE_INITIALIZER;
 
 // 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) {
-    return new SafeBrowsingBlockingPage(service, web_contents,
-                                        unsafe_resources);
+    // Only do the trial if the interstitial is a malware one, the other types

[kewang, 2012/08/21 10:23:05]

Basically we do this trial if there is only one unsafe resource and it's
malware. If we have multiple malware ones, we still in V1. Maybe can be more
specific in comment here.

[mattm, 2012/08/21 18:29:12]

Done.

+    // have not been updated to V2 yet.
+    if (unsafe_resources.size() == 1 &&
+        unsafe_resources[0].threat_type == SafeBrowsingService::URL_MALWARE) {
+      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);
   }
 
  private:
   friend struct base::DefaultLazyInstanceTraits<
       SafeBrowsingBlockingPageFactoryImpl>;
 
   SafeBrowsingBlockingPageFactoryImpl() { }
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingBlockingPageFactoryImpl);
 };
 
 static base::LazyInstance<SafeBrowsingBlockingPageFactoryImpl>
     g_safe_browsing_blocking_page_factory_impl = LAZY_INSTANCE_INITIALIZER;
 
 SafeBrowsingBlockingPage::SafeBrowsingBlockingPage(
     SafeBrowsingService* sb_service,
     WebContents* web_contents,
     const UnsafeResourceList& unsafe_resources)
     : malware_details_proceed_delay_ms_(
           kMalwareDetailsProceedDelayMilliSeconds),
       sb_service_(sb_service),
       report_loop_(NULL),
       is_main_frame_load_blocked_(IsMainPageLoadBlocked(unsafe_resources)),
       unsafe_resources_(unsafe_resources),
       proceeded_(false),
       web_contents_(web_contents),
-      url_(unsafe_resources[0].url) {
+      url_(unsafe_resources[0].url),
+      has_expanded_see_more_section_(false) {
+  bool malware = false;
+  bool phishing = false;
+  for (UnsafeResourceList::const_iterator iter = unsafe_resources_.begin();
+       iter != unsafe_resources_.end(); ++iter) {
+    const SafeBrowsingService::UnsafeResource& resource = *iter;
+    SafeBrowsingService::UrlCheckResult threat_type = resource.threat_type;
+    if (threat_type == SafeBrowsingService::URL_MALWARE) {
+      malware = true;
+    } else {
+      DCHECK(threat_type == SafeBrowsingService::URL_PHISHING ||
+             threat_type == SafeBrowsingService::CLIENT_SIDE_PHISHING_URL);
+      phishing = true;
+    }
+  }
+  DCHECK(phishing || malware);
+  if (malware && phishing)
+    interstitial_type_ = TYPE_MALWARE_AND_PHISHING;
+  else if (malware)
+    interstitial_type_ = TYPE_MALWARE;
+  else
+    interstitial_type_ = TYPE_PHISHING;
   RecordUserAction(SHOW);
   if (!is_main_frame_load_blocked_) {
     navigation_entry_index_to_remove_ =
         web_contents->GetController().GetLastCommittedEntryIndex();
   } else {
     navigation_entry_index_to_remove_ = -1;
   }
 
   // Start computing malware details. They will be sent only
   // if the user opts-in on the blocking page later.
@@ skipping 13 matching lines @@
 }
 
 bool SafeBrowsingBlockingPage::CanShowMalwareDetailsOption() {
   return (!web_contents_->GetBrowserContext()->IsOffTheRecord() &&
           web_contents_->GetURL().SchemeIs(chrome::kHttpScheme));
 }
 
 SafeBrowsingBlockingPage::~SafeBrowsingBlockingPage() {
 }
 
-std::string SafeBrowsingBlockingPage::GetHTMLContents() {
-  // Load the HTML page and create the template components.
-  DictionaryValue strings;
-  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-  std::string html;
-
-  if (unsafe_resources_.empty()) {
-    NOTREACHED();
-    return std::string();
-  }
-
-  if (unsafe_resources_.size() > 1) {
-    PopulateMultipleThreatStringDictionary(&strings);
-    html = rb.GetRawDataResource(
-        IDR_SAFE_BROWSING_MULTIPLE_THREAT_BLOCK,
-        ui::SCALE_FACTOR_NONE).as_string();
-    is_malware_interstitial_ = true;
-  } 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,
-          ui::SCALE_FACTOR_NONE).as_string();
-      is_malware_interstitial_ = true;
-    } else {  // Phishing.
-      DCHECK(threat_type == SafeBrowsingService::URL_PHISHING ||
-             threat_type == SafeBrowsingService::CLIENT_SIDE_PHISHING_URL);
-      PopulatePhishingStringDictionary(&strings);
-      html = rb.GetRawDataResource(
-          IDR_SAFE_BROWSING_PHISHING_BLOCK,
-          ui::SCALE_FACTOR_NONE).as_string();
-      is_malware_interstitial_ = false;
-    }
-  }
-  interstitial_show_time_ = base::TimeTicks::Now();
-  return jstemplate_builder::GetTemplatesHtml(html, &strings, "template_root");
-}
-
-void SafeBrowsingBlockingPage::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));
-}
-
-void SafeBrowsingBlockingPage::PopulateMultipleThreatStringDictionary(
-    DictionaryValue* strings) {
-  bool malware = false;
-  bool phishing = false;
-
-  string16 malware_label =
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_LABEL);
-  string16 malware_link =
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_DIAGNOSTIC_PAGE);
-  string16 phishing_label =
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_LABEL);
-  string16 phishing_link =
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_REPORT_ERROR);
-
-  ListValue* error_strings = new ListValue;
-  for (UnsafeResourceList::const_iterator iter = unsafe_resources_.begin();
-       iter != unsafe_resources_.end(); ++iter) {
-    const SafeBrowsingService::UnsafeResource& resource = *iter;
-    SafeBrowsingService::UrlCheckResult threat_type = resource.threat_type;
-    DictionaryValue* current_error_strings = new DictionaryValue;
-    if (threat_type == SafeBrowsingService::URL_MALWARE) {
-      malware = true;
-      current_error_strings->SetString("type", "malware");
-      current_error_strings->SetString("typeLabel", malware_label);
-      current_error_strings->SetString("errorLink", malware_link);
-    } else {
-      DCHECK(threat_type == SafeBrowsingService::URL_PHISHING ||
-             threat_type == SafeBrowsingService::CLIENT_SIDE_PHISHING_URL);
-      phishing = true;
-      current_error_strings->SetString("type", "phishing");
-      current_error_strings->SetString("typeLabel", phishing_label);
-      current_error_strings->SetString("errorLink", phishing_link);
-    }
-    current_error_strings->SetString("url", resource.url.spec());
-    error_strings->Append(current_error_strings);
-  }
-  strings->Set("errors", error_strings);
-  DCHECK(phishing || malware);
-
-  if (malware && phishing) {
-    PopulateStringDictionary(
-        strings,
-        // Use the malware headline, it is the scariest one.
-        l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MULTI_THREAT_TITLE),
-        l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_HEADLINE),
-        l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_MULTI_THREAT_DESCRIPTION1,
-                                   UTF8ToUTF16(web_contents_->GetURL().host())),
-        l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MULTI_THREAT_DESCRIPTION2),
-        string16());
-  } else if (malware) {
-    // Just malware.
-    PopulateStringDictionary(
-        strings,
-        l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_TITLE),
-        l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_HEADLINE),
-        l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_MULTI_MALWARE_DESCRIPTION1,
-                                   UTF8ToUTF16(web_contents_->GetURL().host())),
-        l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MULTI_MALWARE_DESCRIPTION2),
-        l10n_util::GetStringUTF16(
-            IDS_SAFE_BROWSING_MULTI_MALWARE_DESCRIPTION3));
-  } else {
-    // Just phishing.
-    PopulateStringDictionary(
-        strings,
-        l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_TITLE),
-        l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_HEADLINE),
-        l10n_util::GetStringFUTF16(
-            IDS_SAFE_BROWSING_MULTI_PHISHING_DESCRIPTION1,
-            UTF8ToUTF16(web_contents_->GetURL().host())),
-        string16(),
-        string16());
-  }
-
-  strings->SetString("confirm_text",
-                     l10n_util::GetStringUTF16(
-                         IDS_SAFE_BROWSING_MULTI_MALWARE_DESCRIPTION_AGREE));
-  strings->SetString("continue_button",
-                     l10n_util::GetStringUTF16(
-                         IDS_SAFE_BROWSING_MULTI_MALWARE_PROCEED_BUTTON));
-  strings->SetString("back_button",
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_BACK_BUTTON));
-  strings->SetString("textdirection", base::i18n::IsRTL() ? "rtl" : "ltr");
-}
-
-void SafeBrowsingBlockingPage::PopulateMalwareStringDictionary(
-    DictionaryValue* strings) {
-  std::string diagnostic_link = base::StringPrintf(kSbDiagnosticHtml,
-      l10n_util::GetStringUTF8(
-        IDS_SAFE_BROWSING_MALWARE_DIAGNOSTIC_PAGE).c_str());
-
-  strings->SetString("badURL", url_.host());
-  // Check to see if we're blocking the main page, or a sub-resource on the
-  // main page.
-  string16 description1, description3, description5;
-  if (is_main_frame_load_blocked_) {
-    description1 = l10n_util::GetStringFUTF16(
-        IDS_SAFE_BROWSING_MALWARE_DESCRIPTION1, UTF8ToUTF16(url_.host()));
-  } else {
-    description1 = l10n_util::GetStringFUTF16(
-        IDS_SAFE_BROWSING_MALWARE_DESCRIPTION4,
-        UTF8ToUTF16(web_contents_->GetURL().host()),
-        UTF8ToUTF16(url_.host()));
-  }
-
-  std::string proceed_link = base::StringPrintf(kPLinkHtml,
-      l10n_util::GetStringUTF8(IDS_SAFE_BROWSING_MALWARE_PROCEED_LINK).c_str());
-  description3 =
-      l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION3,
-                                 UTF8ToUTF16(proceed_link));
-
-  PopulateStringDictionary(
-      strings,
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_TITLE),
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_HEADLINE),
-      description1,
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION2),
-      description3);
-
-  description5 =
-      l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION5,
-                                 UTF8ToUTF16(url_.host()),
-                                 UTF8ToUTF16(url_.host()),
-                                 UTF8ToUTF16(diagnostic_link));
-
-  strings->SetString("description5", description5);
-
-  strings->SetString("back_button",
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_BACK_BUTTON));
-  strings->SetString("proceed_link",
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_PROCEED_LINK));
-  strings->SetString("textdirection", base::i18n::IsRTL() ? "rtl" : "ltr");
-
-  if (!CanShowMalwareDetailsOption()) {
-    strings->SetBoolean(kDisplayCheckBox, false);
-  } else {
-    // Show the checkbox for sending malware details.
-    strings->SetBoolean(kDisplayCheckBox, true);
-
-    std::string privacy_link = base::StringPrintf(
-        kPrivacyLinkHtml,
-        l10n_util::GetStringUTF8(
-            IDS_SAFE_BROWSING_PRIVACY_POLICY_PAGE).c_str());
-
-    strings->SetString("confirm_text",
-                       l10n_util::GetStringFUTF16(
-                           IDS_SAFE_BROWSING_MALWARE_REPORTING_AGREE,
-                           UTF8ToUTF16(privacy_link)));
-    if (IsPrefEnabled(prefs::kSafeBrowsingReportingEnabled))
-      strings->SetString(kBoxChecked, "yes");
-    else
-      strings->SetString(kBoxChecked, "");
-  }
-}
-
-void SafeBrowsingBlockingPage::PopulatePhishingStringDictionary(
-    DictionaryValue* strings) {
-  std::string proceed_link = base::StringPrintf(
-      kPLinkHtml,
-      l10n_util::GetStringUTF8(
-          IDS_SAFE_BROWSING_PHISHING_PROCEED_LINK).c_str());
-  string16 description3 = l10n_util::GetStringFUTF16(
-      IDS_SAFE_BROWSING_PHISHING_DESCRIPTION3,
-      UTF8ToUTF16(proceed_link));
-
-  PopulateStringDictionary(
-      strings,
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_TITLE),
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_HEADLINE),
-      l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_PHISHING_DESCRIPTION1,
-                                 UTF8ToUTF16(url_.host())),
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_DESCRIPTION2),
-      description3);
-
-  strings->SetString("back_button",
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_BACK_BUTTON));
-  strings->SetString("report_error",
-      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_REPORT_ERROR));
-  strings->SetString("textdirection", base::i18n::IsRTL() ? "rtl" : "ltr");
-}
-
 void SafeBrowsingBlockingPage::CommandReceived(const std::string& cmd) {
   std::string command(cmd);  // Make a local copy so we can modify it.
   // The Jasonified response has quotes, remove them.
   if (command.length() > 1 && command[0] == '"') {
     command = command.substr(1, command.length() - 2);
   }
   RecordUserReactionTime(command);
   if (command == kDoReportCommand) {
     SetReportingPreference(true);
     return;
@@ skipping 17 matching lines @@
     } else {
       NOTREACHED();
     }
 
     OpenURLParams params(
         url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_LINK, false);
     web_contents_->OpenURL(params);
     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) {

[kewang, 2012/08/21 10:23:05]

Wil this part ever be reached? I think the v2 only works for malware warning?

[mattm, 2012/08/21 18:29:12]

removed.

+      url = google_util::AppendGoogleLocaleParam(GURL(kLearnMorePhishingUrlV2));
+    } else {
+      NOTREACHED();
+    }
+
+    OpenURLParams params(
+        url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_LINK, false);
+    web_contents_->OpenURL(params);
+    return;
+  }
+
   if (command == kShowPrivacyCommand) {
     // User pressed "Safe Browsing privacy policy".
-    GURL url(kSbPrivacyPolicyUrl);
+    GURL url(l10n_util::GetStringUTF8(IDS_SAFE_BROWSING_PRIVACY_POLICY_URL));
     OpenURLParams params(
         url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_LINK, false);
     web_contents_->OpenURL(params);
     return;
   }
 
   bool proceed_blocked = false;
   if (command == kProceedCommand) {
     if (IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled)) {
       proceed_blocked = true;
@@ skipping 76 matching lines @@
     diagnostic_url = google_util::AppendGoogleLocaleParam(diagnostic_url);
     DCHECK(unsafe_resources_[element_index].threat_type ==
            SafeBrowsingService::URL_MALWARE);
     OpenURLParams params(
         diagnostic_url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_LINK,
         false);
     web_contents_->OpenURL(params);
     return;
   }
 
+  if (command == kExpandedSeeMore) {
+    // User expanded the "see more info" section of the page.  We don't actually
+    // do any action based on this, it's just so that RecordUserReactionTime can
+    // track it.
+    return;
+  }
+
   NOTREACHED() << "Unexpected command: " << command;
 }
 
 void SafeBrowsingBlockingPage::OverrideRendererPrefs(
       content::RendererPreferences* prefs) {
   Profile* profile = Profile::FromBrowserContext(
       web_contents_->GetBrowserContext());
   renderer_preferences_util::UpdateFromSystemSettings(prefs, profile);
  }
 
@@ skipping 64 matching lines @@
   if (navigation_entry_index_to_remove_ != -1 &&
       navigation_entry_index_to_remove_ != last_committed_index &&
       !web_contents_->IsBeingDestroyed()) {
     web_contents_->GetController().RemoveEntryAtIndex(
         navigation_entry_index_to_remove_);
     navigation_entry_index_to_remove_ = -1;
   }
 }
 
 void SafeBrowsingBlockingPage::RecordUserAction(BlockingPageEvent event) {
-  // Determine the interstitial type from the blocked resources.
-  // This is the same logic that is used to actually construct the
-  // page contents; we can look at the title to see which type of
-  // interstitial is being displayed.
-  DictionaryValue strings;
-  PopulateMultipleThreatStringDictionary(&strings);
+  // This enum is used for a histogram.  Don't reorder, delete, or insert
+  // elements.  New elements should be added before MAX_ACTION only.
+  enum {
+    MALWARE_SHOW = 0,
+    MALWARE_DONT_PROCEED,
+    MALWARE_FORCED_DONT_PROCEED,
+    MALWARE_PROCEED,
+    MULTIPLE_SHOW,
+    MULTIPLE_DONT_PROCEED,
+    MULTIPLE_FORCED_DONT_PROCEED,
+    MULTIPLE_PROCEED,
+    PHISHING_SHOW,
+    PHISHING_DONT_PROCEED,
+    PHISHING_FORCED_DONT_PROCEED,
+    PHISHING_PROCEED,
+    MAX_ACTION
+  } histogram_action;
 
-  string16 title;
-  bool success = strings.GetString("title", &title);
-  DCHECK(success);
+  switch (event) {
+    case SHOW:
+      switch (interstitial_type_) {
+        case TYPE_MALWARE_AND_PHISHING:
+          histogram_action = MULTIPLE_SHOW;
+          break;
+        case TYPE_MALWARE:
+          histogram_action = MALWARE_SHOW;
+          break;
+        case TYPE_PHISHING:
+          histogram_action = PHISHING_SHOW;
+          break;
+      }
+      break;
+    case PROCEED:
+      switch (interstitial_type_) {
+        case TYPE_MALWARE_AND_PHISHING:
+          histogram_action = MULTIPLE_PROCEED;
+          break;
+        case TYPE_MALWARE:
+          histogram_action = MALWARE_PROCEED;
+          break;
+        case TYPE_PHISHING:
+          histogram_action = PHISHING_PROCEED;
+          break;
+      }
+      break;
+    case DONT_PROCEED:
+      if (IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled)) {
+        switch (interstitial_type_) {
+          case TYPE_MALWARE_AND_PHISHING:
+            histogram_action = MULTIPLE_FORCED_DONT_PROCEED;
+            break;
+          case TYPE_MALWARE:
+            histogram_action = MALWARE_FORCED_DONT_PROCEED;
+            break;
+          case TYPE_PHISHING:
+            histogram_action = PHISHING_FORCED_DONT_PROCEED;
+            break;
+        }
+      } else {
+        switch (interstitial_type_) {
+          case TYPE_MALWARE_AND_PHISHING:
+            histogram_action = MULTIPLE_DONT_PROCEED;
+            break;
+          case TYPE_MALWARE:
+            histogram_action = MALWARE_DONT_PROCEED;
+            break;
+          case TYPE_PHISHING:
+            histogram_action = PHISHING_DONT_PROCEED;
+            break;
+        }
+      }
+      break;
+    default:
+      NOTREACHED() << "Unexpected event: " << event;
+  }
+  UMA_HISTOGRAM_ENUMERATION("SB2.InterstitialAction", histogram_action,
+                            MAX_ACTION);
+  UMA_HISTOGRAM_ENUMERATION(
+      base::FieldTrial::MakeName("SB2.InterstitialAction", "SBInterstitial"),
+      histogram_action,
+      MAX_ACTION);
 
+  // TODO(mattm): now that we've added the histogram above, should we remove
+  // this old user metric at some future point?
   std::string action = "SBInterstitial";
-  if (title ==
-          l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MULTI_THREAT_TITLE)) {
-    action.append("Multiple");
-  } else if (title ==
-                 l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_TITLE)) {
-    action.append("Malware");
-  } else {
-    DCHECK_EQ(title,
-              l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_TITLE));
-    action.append("Phishing");
+  switch (interstitial_type_) {
+    case TYPE_MALWARE_AND_PHISHING:
+      action.append("Multiple");
+      break;
+    case TYPE_MALWARE:
+      action.append("Malware");
+      break;
+    case TYPE_PHISHING:
+      action.append("Phishing");
+      break;
   }
 
   switch (event) {
     case SHOW:
       action.append("Show");
       break;
     case PROCEED:
       action.append("Proceed");
       break;
     case DONT_PROCEED:
       if (IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled))
         action.append("ForcedDontProceed");
       else
         action.append("DontProceed");
       break;
     default:
       NOTREACHED() << "Unexpected event: " << event;
   }
 
+  std::string field_trial_action;
+  if (base::FieldTrialList::FindFullName("SBInterstitial") == "V2")
+    field_trial_action = action + "_V2";
+  else
+    field_trial_action = action + "_V1";
+
   content::RecordComputedAction(action);
+  content::RecordComputedAction(field_trial_action);
 }
 
 void SafeBrowsingBlockingPage::RecordUserReactionTime(
     const std::string& command) {
   if (interstitial_show_time_.is_null())
     return;  // We already reported the user reaction time.
   base::TimeDelta dt = base::TimeTicks::Now() - interstitial_show_time_;
   DVLOG(1) << "User reaction time for command:" << command
-           << " on is_malware:" << is_malware_interstitial_
+           << " on interstitial_type_:" << interstitial_type_
            << " warning took " << dt.InMilliseconds() << "ms";
   bool recorded = true;
-  if (is_malware_interstitial_) {
+  if (interstitial_type_ == TYPE_MALWARE ||
+      interstitial_type_ == TYPE_MALWARE_AND_PHISHING) {
     // There are six ways in which the malware interstitial can go
     // away.  We handle all of them here but we group two together: closing the
     // tag / browser window and clicking on the back button in the browser (not
     // the big green button) are considered the same action.
     if (command == kProceedCommand) {
       UMA_HISTOGRAM_MEDIUM_TIMES("SB2.MalwareInterstitialTimeProceed", dt);
+      UMA_HISTOGRAM_MEDIUM_TIMES(base::FieldTrial::MakeName(
+          "SB2.MalwareInterstitialTimeProceed", "SBInterstitial"), dt);
     } else if (command == kTakeMeBackCommand) {
       UMA_HISTOGRAM_MEDIUM_TIMES("SB2.MalwareInterstitialTimeTakeMeBack", dt);
+      UMA_HISTOGRAM_MEDIUM_TIMES(base::FieldTrial::MakeName(
+          "SB2.MalwareInterstitialTimeTakeMeBack", "SBInterstitial"), dt);
     } else if (command == kShowDiagnosticCommand) {
       UMA_HISTOGRAM_MEDIUM_TIMES("SB2.MalwareInterstitialTimeDiagnostic", dt);
+      UMA_HISTOGRAM_MEDIUM_TIMES(base::FieldTrial::MakeName(
+          "SB2.MalwareInterstitialTimeDiagnostic", "SBInterstitial"), dt);
     } else if (command == kShowPrivacyCommand) {
       UMA_HISTOGRAM_MEDIUM_TIMES("SB2.MalwareInterstitialTimePrivacyPolicy",
                                  dt);
+      UMA_HISTOGRAM_MEDIUM_TIMES(base::FieldTrial::MakeName(
+          "SB2.MalwareInterstitialTimePrivacyPolicy", "SBInterstitial"), dt);
+    } else if (command == kLearnMoreCommand || command == kLearnMoreCommandV2) {
+      UMA_HISTOGRAM_MEDIUM_TIMES("SB2.MalwareInterstitialLearnMore",
+                                 dt);
+      UMA_HISTOGRAM_MEDIUM_TIMES(base::FieldTrial::MakeName(
+          "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 == kShowPrivacyCommand) {
+    } 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();
+      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) {
   if (malware_details_ == NULL)
@@ skipping 74 matching lines @@
   // Client-side phishing detection interstitials never block the main frame
   // load, since they happen after the page is finished loading.
   if (unsafe_resources[0].threat_type ==
       SafeBrowsingService::CLIENT_SIDE_PHISHING_URL) {
     return false;
   }
 
   // Otherwise, check the threat type.
   return unsafe_resources.size() == 1 && !unsafe_resources[0].is_subresource;
 }
+
+SafeBrowsingBlockingPageV1::SafeBrowsingBlockingPageV1(
+    SafeBrowsingService* sb_service,
+    WebContents* web_contents,
+    const UnsafeResourceList& unsafe_resources)
+  : SafeBrowsingBlockingPage(sb_service, web_contents, unsafe_resources) {
+}
+
+std::string SafeBrowsingBlockingPageV1::GetHTMLContents() {
+  // Load the HTML page and create the template components.
+  DictionaryValue strings;
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+  std::string html;
+
+  if (unsafe_resources_.empty()) {
+    NOTREACHED();
+    return std::string();
+  }
+
+  if (unsafe_resources_.size() > 1) {
+    PopulateMultipleThreatStringDictionary(&strings);
+    html = rb.GetRawDataResource(
+        IDR_SAFE_BROWSING_MULTIPLE_THREAT_BLOCK,
+        ui::SCALE_FACTOR_NONE).as_string();
+  } 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,
+          ui::SCALE_FACTOR_NONE).as_string();
+    } else {  // Phishing.
+      DCHECK(threat_type == SafeBrowsingService::URL_PHISHING ||
+             threat_type == SafeBrowsingService::CLIENT_SIDE_PHISHING_URL);
+      PopulatePhishingStringDictionary(&strings);
+      html = rb.GetRawDataResource(
+          IDR_SAFE_BROWSING_PHISHING_BLOCK,
+          ui::SCALE_FACTOR_NONE).as_string();
+    }
+  }
+  interstitial_show_time_ = base::TimeTicks::Now();
+  return jstemplate_builder::GetTemplatesHtml(html, &strings, "template_root");
+}
+
+void SafeBrowsingBlockingPageV1::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));
+}
+
+void SafeBrowsingBlockingPageV1::PopulateMultipleThreatStringDictionary(
+    DictionaryValue* strings) {
+
+  string16 malware_label =
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_LABEL);
+  string16 malware_link =
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_DIAGNOSTIC_PAGE);
+  string16 phishing_label =
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_LABEL);
+  string16 phishing_link =
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_REPORT_ERROR);
+
+  ListValue* error_strings = new ListValue;
+  for (UnsafeResourceList::const_iterator iter = unsafe_resources_.begin();
+       iter != unsafe_resources_.end(); ++iter) {
+    const SafeBrowsingService::UnsafeResource& resource = *iter;
+    SafeBrowsingService::UrlCheckResult threat_type = resource.threat_type;
+    DictionaryValue* current_error_strings = new DictionaryValue;
+    if (threat_type == SafeBrowsingService::URL_MALWARE) {
+      current_error_strings->SetString("type", "malware");
+      current_error_strings->SetString("typeLabel", malware_label);
+      current_error_strings->SetString("errorLink", malware_link);
+    } else {
+      DCHECK(threat_type == SafeBrowsingService::URL_PHISHING ||
+             threat_type == SafeBrowsingService::CLIENT_SIDE_PHISHING_URL);
+      current_error_strings->SetString("type", "phishing");
+      current_error_strings->SetString("typeLabel", phishing_label);
+      current_error_strings->SetString("errorLink", phishing_link);
+    }
+    current_error_strings->SetString("url", resource.url.spec());
+    error_strings->Append(current_error_strings);
+  }
+  strings->Set("errors", error_strings);
+
+  switch (interstitial_type_) {
+    case TYPE_MALWARE_AND_PHISHING:
+      PopulateStringDictionary(
+          strings,
+          // Use the malware headline, it is the scariest one.
+          l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MULTI_THREAT_TITLE),
+          l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_HEADLINE),
+          l10n_util::GetStringFUTF16(
+              IDS_SAFE_BROWSING_MULTI_THREAT_DESCRIPTION1,
+              UTF8ToUTF16(web_contents_->GetURL().host())),
+          l10n_util::GetStringUTF16(
+              IDS_SAFE_BROWSING_MULTI_THREAT_DESCRIPTION2),
+          string16());
+      break;
+    case TYPE_MALWARE:
+      PopulateStringDictionary(
+          strings,
+          l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_TITLE),
+          l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_HEADLINE),
+          l10n_util::GetStringFUTF16(
+              IDS_SAFE_BROWSING_MULTI_MALWARE_DESCRIPTION1,
+              UTF8ToUTF16(web_contents_->GetURL().host())),
+          l10n_util::GetStringUTF16(
+              IDS_SAFE_BROWSING_MULTI_MALWARE_DESCRIPTION2),
+          l10n_util::GetStringUTF16(
+              IDS_SAFE_BROWSING_MULTI_MALWARE_DESCRIPTION3));
+      break;
+    case TYPE_PHISHING:
+      PopulateStringDictionary(
+          strings,
+          l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_TITLE),
+          l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_HEADLINE),
+          l10n_util::GetStringFUTF16(
+              IDS_SAFE_BROWSING_MULTI_PHISHING_DESCRIPTION1,
+              UTF8ToUTF16(web_contents_->GetURL().host())),
+          string16(),
+          string16());
+      break;
+  }
+
+  strings->SetString("confirm_text",
+                     l10n_util::GetStringUTF16(
+                         IDS_SAFE_BROWSING_MULTI_MALWARE_DESCRIPTION_AGREE));
+  strings->SetString("continue_button",
+                     l10n_util::GetStringUTF16(
+                         IDS_SAFE_BROWSING_MULTI_MALWARE_PROCEED_BUTTON));
+  strings->SetString("back_button",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_BACK_BUTTON));
+  strings->SetString("textdirection", base::i18n::IsRTL() ? "rtl" : "ltr");
+}
+
+void SafeBrowsingBlockingPageV1::PopulateMalwareStringDictionary(
+    DictionaryValue* strings) {
+  std::string diagnostic_link = base::StringPrintf(kSbDiagnosticHtml,
+      l10n_util::GetStringUTF8(
+        IDS_SAFE_BROWSING_MALWARE_DIAGNOSTIC_PAGE).c_str());
+
+  // Check to see if we're blocking the main page, or a sub-resource on the
+  // main page.
+  string16 description1, description3, description5;
+  if (is_main_frame_load_blocked_) {
+    description1 = l10n_util::GetStringFUTF16(
+        IDS_SAFE_BROWSING_MALWARE_DESCRIPTION1, UTF8ToUTF16(url_.host()));
+  } else {
+    description1 = l10n_util::GetStringFUTF16(
+        IDS_SAFE_BROWSING_MALWARE_DESCRIPTION4,
+        UTF8ToUTF16(web_contents_->GetURL().host()),
+        UTF8ToUTF16(url_.host()));
+  }
+
+  std::string proceed_link = base::StringPrintf(kPLinkHtml,
+      l10n_util::GetStringUTF8(IDS_SAFE_BROWSING_MALWARE_PROCEED_LINK).c_str());
+  description3 =
+      l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION3,
+                                 UTF8ToUTF16(proceed_link));
+
+  PopulateStringDictionary(
+      strings,
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_TITLE),
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_HEADLINE),
+      description1,
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION2),
+      description3);
+
+  description5 =
+      l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION5,
+                                 UTF8ToUTF16(url_.host()),
+                                 UTF8ToUTF16(url_.host()),
+                                 UTF8ToUTF16(diagnostic_link));
+
+  strings->SetString("description5", description5);
+
+  strings->SetString("back_button",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_BACK_BUTTON));
+  strings->SetString("proceed_link",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_PROCEED_LINK));
+  strings->SetString("textdirection", base::i18n::IsRTL() ? "rtl" : "ltr");
+
+  if (!CanShowMalwareDetailsOption()) {
+    strings->SetBoolean(kDisplayCheckBox, false);
+  } else {
+    // Show the checkbox for sending malware details.
+    strings->SetBoolean(kDisplayCheckBox, true);
+
+    std::string privacy_link = base::StringPrintf(
+        kPrivacyLinkHtml,
+        l10n_util::GetStringUTF8(
+            IDS_SAFE_BROWSING_PRIVACY_POLICY_PAGE).c_str());
+
+    strings->SetString("confirm_text",
+                       l10n_util::GetStringFUTF16(
+                           IDS_SAFE_BROWSING_MALWARE_REPORTING_AGREE,
+                           UTF8ToUTF16(privacy_link)));
+    if (IsPrefEnabled(prefs::kSafeBrowsingReportingEnabled))
+      strings->SetString(kBoxChecked, "yes");
+    else
+      strings->SetString(kBoxChecked, "");
+  }
+}
+
+void SafeBrowsingBlockingPageV1::PopulatePhishingStringDictionary(
+    DictionaryValue* strings) {
+  std::string proceed_link = base::StringPrintf(
+      kPLinkHtml,
+      l10n_util::GetStringUTF8(
+          IDS_SAFE_BROWSING_PHISHING_PROCEED_LINK).c_str());
+  string16 description3 = l10n_util::GetStringFUTF16(
+      IDS_SAFE_BROWSING_PHISHING_DESCRIPTION3,
+      UTF8ToUTF16(proceed_link));
+
+  PopulateStringDictionary(
+      strings,
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_TITLE),
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_HEADLINE),
+      l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_PHISHING_DESCRIPTION1,
+                                 UTF8ToUTF16(url_.host())),
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_DESCRIPTION2),
+      description3);
+
+  strings->SetString("back_button",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_BACK_BUTTON));
+  strings->SetString("report_error",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_REPORT_ERROR));
+  strings->SetString("textdirection", base::i18n::IsRTL() ? "rtl" : "ltr");
+}
+
+SafeBrowsingBlockingPageV2::SafeBrowsingBlockingPageV2(
+    SafeBrowsingService* sb_service,
+    WebContents* web_contents,
+    const UnsafeResourceList& unsafe_resources)
+  : SafeBrowsingBlockingPage(sb_service, web_contents, unsafe_resources) {
+}
+
+std::string SafeBrowsingBlockingPageV2::GetHTMLContents() {
+  // Load the HTML page and create the template components.
+  DictionaryValue strings;
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+  std::string html;
+
+  if (unsafe_resources_.empty()) {
+    NOTREACHED();
+    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();
+    }
+  }
+  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,
+    const string16& description4) {
+  strings->SetString("title", title);
+  strings->SetString("headLine", headline);
+  strings->SetString("description1", description1);
+  strings->SetString("description2", description2);
+  strings->SetString("description3", description3);
+  strings->SetString("description4", description4);
+  strings->SetBoolean("proceedDisabled",
+                      IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled));
+
+  strings->SetString("textdirection", base::i18n::IsRTL() ? "rtl" : "ltr");
+  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("seeLess", l10n_util::GetStringUTF16(
+      IDS_SAFE_BROWSING_MALWARE_V2_SEE_LESS));
+}
+
+void SafeBrowsingBlockingPageV2::PopulateMultipleThreatStringDictionary(
+    DictionaryValue* strings) {
+  NOTREACHED();
+}
+
+void SafeBrowsingBlockingPageV2::PopulateMalwareStringDictionary(
+    DictionaryValue* strings) {
+  std::string diagnostic_link = base::StringPrintf(kSbDiagnosticHtml,
+      l10n_util::GetStringUTF8(
+        IDS_SAFE_BROWSING_MALWARE_DIAGNOSTIC_PAGE).c_str());
+
+  // Check to see if we're blocking the main page, or a sub-resource on the
+  // main page.
+  string16 headline, description1, description2, description3, description4;
+
+
+  if (is_main_frame_load_blocked_) {
+    headline = l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_V2_HEADLINE);
+    description1 = l10n_util::GetStringFUTF16(
+        IDS_SAFE_BROWSING_MALWARE_V2_DESCRIPTION1,
+        l10n_util::GetStringUTF16(IDS_PRODUCT_NAME),
+        UTF8ToUTF16(url_.host()));
+    description2 = l10n_util::GetStringUTF16(
+        IDS_SAFE_BROWSING_MALWARE_V2_DESCRIPTION2);
+    description3 = l10n_util::GetStringUTF16(
+        IDS_SAFE_BROWSING_MALWARE_V2_DESCRIPTION3);
+    description4 = l10n_util::GetStringUTF16(
+        IDS_SAFE_BROWSING_MALWARE_V2_DESCRIPTION4);
+    strings->SetBoolean(kDisplayShowDiagnostic, true);
+  } else {
+    headline = l10n_util::GetStringUTF16(
+        IDS_SAFE_BROWSING_MALWARE_V2_HEADLINE_SUBRESOURCE);
+    description1 = l10n_util::GetStringFUTF16(
+        IDS_SAFE_BROWSING_MALWARE_V2_DESCRIPTION1_SUBRESOURCE,
+        l10n_util::GetStringUTF16(IDS_PRODUCT_NAME),
+        UTF8ToUTF16(web_contents_->GetURL().host()));
+    description2 = l10n_util::GetStringUTF16(
+        IDS_SAFE_BROWSING_MALWARE_V2_DESCRIPTION2_SUBRESOURCE);
+    description3 = l10n_util::GetStringUTF16(
+        IDS_SAFE_BROWSING_MALWARE_V2_DESCRIPTION3_SUBRESOURCE);
+    description4 = l10n_util::GetStringFUTF16(
+            IDS_SAFE_BROWSING_MALWARE_V2_DESCRIPTION4_SUBRESOURCE,
+            UTF8ToUTF16(url_.host()));
+    strings->SetBoolean(kDisplayShowDiagnostic, false);
+  }
+
+  PopulateStringDictionary(
+      strings,
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_V2_TITLE),
+      headline,
+      description1,
+      description2,
+      description3,
+      description4);
+
+  if (!CanShowMalwareDetailsOption()) {
+    strings->SetBoolean(kDisplayCheckBox, false);
+  } else {
+    // Show the checkbox for sending malware details.
+    strings->SetBoolean(kDisplayCheckBox, true);
+
+    std::string privacy_link = base::StringPrintf(
+        kPrivacyLinkHtml,
+        l10n_util::GetStringUTF8(
+            IDS_SAFE_BROWSING_PRIVACY_POLICY_PAGE_V2).c_str());
+
+    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("learnMore",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_V2_LEARN_MORE));
+  strings->SetString("details",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_V2_DETAILS));
+}
+
+void SafeBrowsingBlockingPageV2::PopulatePhishingStringDictionary(
+    DictionaryValue* strings) {
+  NOTREACHED();
+}