Send malware reports when a user opts-in from the safe browsing interstitial ...

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/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.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/profile.h"
+#include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
+#include "chrome/browser/safe_browsing/malware_report.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/jstemplate_builder.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "net/base/escape.h"
 
 // For malware interstitial pages, we link the problematic URL to Google's
 // diagnostic page.
 #if defined(GOOGLE_CHROME_BUILD)
 static const char* const kSbDiagnosticUrl =
@@ skipping 56 matching lines @@
 
 SafeBrowsingBlockingPage::SafeBrowsingBlockingPage(
     SafeBrowsingService* sb_service,
     TabContents* tab_contents,
     const UnsafeResourceList& unsafe_resources)
     : InterstitialPage(tab_contents,
                        IsMainPage(unsafe_resources),
                        unsafe_resources[0].url),
       sb_service_(sb_service),
       is_main_frame_(IsMainPage(unsafe_resources)),
-      unsafe_resources_(unsafe_resources) {
+      unsafe_resources_(unsafe_resources),
+      malware_report_(NULL) {
   RecordUserAction(SHOW);
   if (!is_main_frame_) {
     navigation_entry_index_to_remove_ =
         tab()->controller().last_committed_entry_index();
   } else {
     navigation_entry_index_to_remove_ = -1;
   }
+
+  // Start computing an advanced malware report. It will be sent only
+  // if the user opts-in on the blocking page later.
+  if (unsafe_resources.size() == 1 &&
+      unsafe_resources[0].threat_type == SafeBrowsingService::URL_MALWARE &&
+      malware_report_ == NULL &&
+      !tab()->profile()->IsOffTheRecord()) {
+    malware_report_ = new SafeBrowsingMalwareReport(tab(), unsafe_resources[0]);
+  }
 }
 
 SafeBrowsingBlockingPage::~SafeBrowsingBlockingPage() {
 }
 
 std::string SafeBrowsingBlockingPage::GetHTMLContents() {
   // Load the HTML page and create the template components.
   DictionaryValue strings;
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   std::string html;
@@ skipping 261 matching lines @@
            SafeBrowsingService::URL_MALWARE);
     tab()->OpenURL(diagnostic_url, GURL(), CURRENT_TAB, PageTransition::LINK);
     return;
   }
 
   NOTREACHED() << "Unexpected command: " << command;
 }
 
 void SafeBrowsingBlockingPage::Proceed() {
   RecordUserAction(PROCEED);
+  FinishMalwareReport();  // Send the malware report, 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());
   SafeBrowsingBlockingPage* blocking_page = NULL;
   if (iter != unsafe_resource_map->end() && !iter->second.empty()) {
     // Build an interstitial for all the unsafe resources notifications.
@@ skipping 17 matching lines @@
   // We could have already called Proceed(), in which case we must not notify
   // the SafeBrowsingService again, as the client has been deleted.
   if (action_taken() == PROCEED_ACTION) {
     // We still want to hide the interstitial page.
     InterstitialPage::DontProceed();
     // We are now deleted.
     return;
   }
 
   RecordUserAction(DONT_PROCEED);
+  FinishMalwareReport();  // Send the malware report, if we opted to.
 
   NotifySafeBrowsingService(sb_service_, unsafe_resources_, false);
 
   // The user does not want to proceed, clear the queued unsafe resources
   // notifications we received while the interstitial was showing.
   UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
   UnsafeResourceMap::iterator iter = unsafe_resource_map->find(tab());
   if (iter != unsafe_resource_map->end() && !iter->second.empty()) {
     NotifySafeBrowsingService(sb_service_, iter->second, false);
     unsafe_resource_map->erase(iter);
@@ skipping 45 matching lines @@
     case DONT_PROCEED:
       action.append("DontProceed");
       break;
     default:
       NOTREACHED() << "Unexpected event: " << event;
   }
 
   UserMetrics::RecordComputedAction(action);
 }
 
+void SafeBrowsingBlockingPage::FinishMalwareReport() {
+  if (malware_report_ == NULL) {
+    // Not all interstitials have reports (eg phishing).
+    return;
+  }
+
+  // Q: Reading from the preference -- should it happen in another thread?

[lzheng, 2010/11/16 00:18:12]

It has to be called on the same thread where pref is created.

[panayiotis, 2010/11/18 22:04:37]

thanks.

+  const PrefService::Preference* pref =
+      tab()->profile()->GetPrefs()->FindPreference(
+          prefs::kSafeBrowsingMalwareReportsEnabled);
+
+  bool value;
+  if (pref && pref->GetValue()->GetAsBoolean(&value) && value) {
+    // Give the report object to the service class, so it can send it.
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        NewRunnableMethod(
+            sb_service_, &SafeBrowsingService::SendMalwareReport,
+            malware_report_));
+  }
+}
+
 // static
 void SafeBrowsingBlockingPage::NotifySafeBrowsingService(
     SafeBrowsingService* sb_service,
     const UnsafeResourceList& unsafe_resources,
     bool proceed) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
           sb_service, &SafeBrowsingService::OnBlockingPageDone,
           unsafe_resources, proceed));
@@ skipping 42 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;
 }