Add a checkbox to the malware interstitial page, for user to opt-in to send m...

chrome/browser/safe_browsing/safe_browsing_blocking_page.cc

 // Copyright (c) 2010 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 "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/i18n/rtl.h"
 #include "base/lazy_instance.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/dom_operation_notification_details.h"
 #include "chrome/browser/dom_ui/new_tab_ui.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/malware_details.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
@@ skipping 37 matching lines @@
 static const char* const kPLinkHtml =
     "<a href=\"\" onclick=\"sendCommand('proceed'); return false;\" "
     "onmousedown=\"return false;\">%s</a>";
 
 // 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 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 kBoxChecked = "boxchecked";
 
 // static
 SafeBrowsingBlockingPageFactory* SafeBrowsingBlockingPage::factory_ = NULL;
 
 static base::LazyInstance<SafeBrowsingBlockingPage::UnsafeResourceMap>
     g_unsafe_resource_map(base::LINKER_INITIALIZED);
 
 // The default SafeBrowsingBlockingPageFactory.  Global, made a singleton so we
 // don't leak it.
 class SafeBrowsingBlockingPageFactoryImpl
@@ skipping 224 matching lines @@
                                  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);
+    return;
+  }
+
+  // show the checkbox about sending malware report
+  strings->SetBoolean(kDisplayCheckBox, true);
+  strings->SetString("confirm_text",
+       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_REPORTING_AGREE));
+
+  const PrefService::Preference* pref =
+      tab()->profile()->GetPrefs()->FindPreference(
+          prefs::kSafeBrowsingReportingEnabled);
+  bool value;
+  if (pref && pref->GetValue()->GetAsBoolean(&value) && value) {
+    strings->SetString(kBoxChecked, "yes");
+  } else {
+    strings->SetString(kBoxChecked, "");
+  }
 }
 
 void SafeBrowsingBlockingPage::PopulatePhishingStringDictionary(
     DictionaryValue* strings) {
   std::string proceed_link = 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));
 
@@ skipping 13 matching lines @@
   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);
   }
 
+  if (command == kDoReportCommand) {
+    SetReportingPreference(true);
+    return;
+  }
+
+  if (command == kDontReportCommand) {
+    SetReportingPreference(false);
+    return;
+  }
+
   if (command == kLearnMoreCommand) {
     // User pressed "Learn more".
     GURL url;
     if (unsafe_resources_[0].threat_type == SafeBrowsingService::URL_MALWARE) {
       url = google_util::AppendGoogleLocaleParam(GURL(kLearnMoreMalwareUrl));
     } else if (unsafe_resources_[0].threat_type ==
                SafeBrowsingService::URL_PHISHING) {
       url = google_util::AppendGoogleLocaleParam(GURL(kLearnMorePhishingUrl));
     } else {
       NOTREACHED();
@@ skipping 55 matching lines @@
     diagnostic_url = google_util::AppendGoogleLocaleParam(diagnostic_url);
     DCHECK(unsafe_resources_[element_index].threat_type ==
            SafeBrowsingService::URL_MALWARE);
     tab()->OpenURL(diagnostic_url, GURL(), CURRENT_TAB, PageTransition::LINK);
     return;
   }
 
   NOTREACHED() << "Unexpected command: " << command;
 }
 
+void SafeBrowsingBlockingPage::SetReportingPreference(bool report) {
+  PrefService* pref = tab()->profile()->GetPrefs();
+  pref->SetBoolean(prefs::kSafeBrowsingReportingEnabled, report);
+}
+
 void SafeBrowsingBlockingPage::Proceed() {
   RecordUserAction(PROCEED);
   FinishMalwareDetails();  // Send the malware details, if we opted to.
 
   NotifySafeBrowsingService(sb_service_, unsafe_resources_, true);
 
   // Check to see if some new notifications of unsafe resources have been
   // received while we were showing the interstitial.
   UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
   UnsafeResourceMap::iterator iter = unsafe_resource_map->find(tab());
@@ skipping 167 matching lines @@
   UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
   (*unsafe_resource_map)[tab_contents].push_back(unsafe_resource);
 }
 
 // static
 bool SafeBrowsingBlockingPage::IsMainPage(
     const UnsafeResourceList& unsafe_resources) {
   return unsafe_resources.size() == 1 &&
          unsafe_resources[0].resource_type == ResourceType::MAIN_FRAME;
 }