Introduce the ChromeControllerClient class

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 15 matching lines @@
 #include "chrome/browser/renderer_preferences_util.h"
 #include "chrome/browser/safe_browsing/threat_details.h"
 #include "chrome/browser/safe_browsing/ui_manager.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/grit/locale_settings.h"
 #include "components/google/core/browser/google_util.h"
+#include "components/security_interstitials/core/controller_client.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 "content/public/common/renderer_preferences.h"
 #include "grit/browser_resources.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using base::UserMetricsAction;
 using content::BrowserThread;
 using content::InterstitialPage;
 using content::OpenURLParams;
 using content::Referrer;
 using content::WebContents;
+using security_interstitials::ControllerClient;
 
 namespace safe_browsing {
 
 namespace {
 
 // For malware interstitial pages, we link the problematic URL to Google's
 // diagnostic page.
 #if defined(GOOGLE_CHROME_BUILD)
 const char kSbDiagnosticUrl[] =
     "https://www.google.com/safebrowsing/diagnostic?site=%s&client=googlechrome";
@@ skipping 169 matching lines @@
     // content::WaitForRenderFrameReady sends this message when the page
     // load completes. Ignore it.
     return;
   }
 
   int command = 0;
   bool retval = base::StringToInt(page_cmd, &command);
   DCHECK(retval) << page_cmd;
 
   switch (command) {
-    case CMD_DO_REPORT: {
+    case ControllerClient::CMD_DO_REPORT: {
       // User enabled SB Extended Reporting via the checkbox.
       SetReportingPreference(true);
       break;
     }
-    case CMD_DONT_REPORT: {
+    case ControllerClient::CMD_DONT_REPORT: {
       // User disabled SB Extended Reporting via the checkbox.
       SetReportingPreference(false);
       break;
     }
-    case CMD_OPEN_HELP_CENTER: {
+    case ControllerClient::CMD_OPEN_HELP_CENTER: {
       // User pressed "Learn more".
       metrics_helper()->RecordUserInteraction(
           security_interstitials::MetricsHelper::SHOW_LEARN_MORE);
       GURL learn_more_url(
           interstitial_reason_ == SB_REASON_PHISHING ?
           kLearnMorePhishingUrlV2 : kLearnMoreMalwareUrlV2);
       learn_more_url = google_util::AppendGoogleLocaleParam(
           learn_more_url, g_browser_process->GetApplicationLocale());
       OpenURLParams params(learn_more_url,
                            Referrer(),
                            CURRENT_TAB,
                            ui::PAGE_TRANSITION_LINK,
                            false);
       web_contents()->OpenURL(params);
       break;
     }
-    case CMD_OPEN_REPORTING_PRIVACY: {
+    case ControllerClient::CMD_OPEN_REPORTING_PRIVACY: {
       // User pressed on the SB Extended Reporting "privacy policy" link.
       OpenExtendedReportingPrivacyPolicy();
       break;
     }
-    case CMD_PROCEED: {
+    case ControllerClient::CMD_PROCEED: {
       // User pressed on the button to proceed.
       if (!IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled)) {
         metrics_helper()->RecordUserDecision(
             security_interstitials::MetricsHelper::PROCEED);
         interstitial_page()->Proceed();
         // |this| has been deleted after Proceed() returns.
         break;
       }
       // If the user can't proceed, fall through to CMD_DONT_PROCEED.
     }
-    case CMD_DONT_PROCEED: {
+    case ControllerClient::CMD_DONT_PROCEED: {
       // User pressed on the button to return to safety.
       // Don't record the user action here because there are other ways of
       // triggering DontProceed, like clicking the back button.
       if (is_main_frame_load_blocked_) {
         // If the load is blocked, we want to close the interstitial and discard
         // the pending entry.
         interstitial_page()->DontProceed();
         // |this| has been deleted after DontProceed() returns.
         break;
       }
 
       // Otherwise the offending entry has committed, and we need to go back or
       // to a safe page.  We will close the interstitial when that page commits.
       if (web_contents()->GetController().CanGoBack()) {
         web_contents()->GetController().GoBack();
       } else {
         web_contents()->GetController().LoadURL(
             GURL(chrome::kChromeUINewTabURL),
             content::Referrer(),
             ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
             std::string());
       }
       break;
     }
-    case CMD_OPEN_DIAGNOSTIC: {
+    case ControllerClient::CMD_OPEN_DIAGNOSTIC: {
       // User wants to see why this page is blocked.
       const UnsafeResource& unsafe_resource = unsafe_resources_[0];
       std::string bad_url_spec = unsafe_resource.url.spec();
       metrics_helper()->RecordUserInteraction(
           security_interstitials::MetricsHelper::SHOW_DIAGNOSTIC);
       std::string diagnostic =
           base::StringPrintf(kSbDiagnosticUrl,
               net::EscapeQueryParamValue(bad_url_spec, true).c_str());
       GURL diagnostic_url(diagnostic);
       diagnostic_url = google_util::AppendGoogleLocaleParam(
           diagnostic_url, g_browser_process->GetApplicationLocale());
       DCHECK(unsafe_resource.threat_type == SB_THREAT_TYPE_URL_MALWARE ||
              unsafe_resource.threat_type ==
                  SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL ||
              unsafe_resource.threat_type == SB_THREAT_TYPE_URL_UNWANTED);
       OpenURLParams params(
           diagnostic_url, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_LINK,
           false);
       web_contents()->OpenURL(params);
       break;
     }
-    case CMD_SHOW_MORE_SECTION: {
+    case ControllerClient::CMD_SHOW_MORE_SECTION: {
       // User has opened up the hidden text.
       metrics_helper()->RecordUserInteraction(
           security_interstitials::MetricsHelper::SHOW_ADVANCED);
       break;
     }
-    case CMD_REPORT_PHISHING_ERROR: {
+    case ControllerClient::CMD_REPORT_PHISHING_ERROR: {
       // User wants to report a phishing error.
       metrics_helper()->RecordUserInteraction(
           security_interstitials::MetricsHelper::REPORT_PHISHING_ERROR);
       GURL phishing_error_url(kReportPhishingErrorUrl);
       phishing_error_url = google_util::AppendGoogleLocaleParam(
           phishing_error_url, g_browser_process->GetApplicationLocale());
       OpenURLParams params(phishing_error_url, Referrer(), CURRENT_TAB,
                            ui::PAGE_TRANSITION_LINK, false);
       web_contents()->OpenURL(params);
       break;
@@ skipping 277 matching lines @@
     case SB_REASON_PHISHING:
       PopulatePhishingLoadTimeData(load_time_data);
       break;
   }
 }
 
 void SafeBrowsingBlockingPage::PopulateExtendedReportingOption(
     base::DictionaryValue* load_time_data) {
   // Only show checkbox if !(HTTPS || incognito-mode).
   const bool show = CanShowThreatDetailsOption();
-  load_time_data->SetBoolean(interstitials::kDisplayCheckBox, show);
+  load_time_data->SetBoolean(security_interstitials::kDisplayCheckBox, show);
   if (!show)
     return;
 
   const std::string privacy_link = base::StringPrintf(
-      interstitials::kPrivacyLinkHtml, CMD_OPEN_REPORTING_PRIVACY,
+      security_interstitials::kPrivacyLinkHtml,
+      ControllerClient::CMD_OPEN_REPORTING_PRIVACY,
       l10n_util::GetStringUTF8(IDS_SAFE_BROWSING_PRIVACY_POLICY_PAGE).c_str());
   load_time_data->SetString(
-      interstitials::kOptInLink,
+      security_interstitials::kOptInLink,
       l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_MALWARE_REPORTING_AGREE,
                                  base::UTF8ToUTF16(privacy_link)));
   load_time_data->SetBoolean(
-      interstitials::kBoxChecked,
+      security_interstitials::kBoxChecked,
       IsPrefEnabled(prefs::kSafeBrowsingExtendedReportingEnabled));
 }
 
 void SafeBrowsingBlockingPage::PopulateMalwareLoadTimeData(
     base::DictionaryValue* load_time_data) {
   load_time_data->SetBoolean("phishing", false);
   load_time_data->SetString(
       "heading", l10n_util::GetStringUTF16(IDS_MALWARE_V3_HEADING));
   load_time_data->SetString(
       "primaryParagraph",
@@ skipping 68 matching lines @@
   } else {
     load_time_data->SetString(
         "finalParagraph",
         l10n_util::GetStringUTF16(IDS_PHISHING_V3_PROCEED_PARAGRAPH));
   }
 
   PopulateExtendedReportingOption(load_time_data);
 }
 
 }  // namespace safe_browsing