Mostly integrate new malware IP blacklist with the csd client. When

chrome/browser/safe_browsing/client_side_detection_host.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.
 
 #include "chrome/browser/safe_browsing/client_side_detection_host.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ skipping 232 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ShouldClassifyUrlRequest);
 };
 
 // static
 ClientSideDetectionHost* ClientSideDetectionHost::Create(
     WebContents* tab) {
   return new ClientSideDetectionHost(tab);
 }
 
+ClientSideDetectionHost::ClientSideDetectionHost(
+    SafeBrowsingDatabaseManager* database_manager)
+    : content::WebContentsObserver(),
+      database_manager_(database_manager),
+      weak_factory_(this) { }

[mattm, 2013/10/29 01:11:47]

It looks like this constructor doesn't initialize all members.

[noé, 2013/10/31 02:41:12]

Done.

+
 ClientSideDetectionHost::ClientSideDetectionHost(WebContents* tab)
     : content::WebContentsObserver(tab),
       csd_service_(NULL),
       weak_factory_(this),
       unsafe_unique_page_id_(-1),
       malware_killswitch_on_(false),
       malware_report_enabled_(false) {
   DCHECK(tab);
   // Note: csd_service_ and sb_service will be NULL here in testing.
   csd_service_ = g_browser_process->safe_browsing_detection_service();
-  feature_extractor_.reset(new BrowserFeatureExtractor(tab, csd_service_));
+  feature_extractor_.reset(new BrowserFeatureExtractor(tab, this));
   registrar_.Add(this, content::NOTIFICATION_RESOURCE_RESPONSE_STARTED,
                  content::Source<WebContents>(tab));
 
   scoped_refptr<SafeBrowsingService> sb_service =
       g_browser_process->safe_browsing_service();
   if (sb_service.get()) {
     ui_manager_ = sb_service->ui_manager();
     database_manager_ = sb_service->database_manager();
     ui_manager_->AddObserver(this);
   }
@@ skipping 80 matching lines @@
       web_contents()->GetController().GetActiveEntry()) {
     unsafe_unique_page_id_ =
         web_contents()->GetController().GetActiveEntry()->GetUniqueID();
     // We also keep the resource around in order to be able to send the
     // malicious URL to the server.
     unsafe_resource_.reset(new SafeBrowsingUIManager::UnsafeResource(resource));
     unsafe_resource_->callback.Reset();  // Don't do anything stupid.
   }
 }
 
+scoped_refptr<SafeBrowsingDatabaseManager>
+ClientSideDetectionHost::database_manager() {
+    return database_manager_;
+}
+
 void ClientSideDetectionHost::WebContentsDestroyed(WebContents* tab) {
   DCHECK(tab);
   // Tell any pending classification request that it is being canceled.
   if (classification_request_.get()) {
     classification_request_->Cancel();
   }
   // Cancel all pending feature extractions.
   feature_extractor_.reset();
 }
 
@@ skipping 18 matching lines @@
       verdict->ParseFromString(verdict_str) &&
       verdict->IsInitialized()) {
     // We do the malware IP matching and request sending if the feature
     // is enabled.
     if (malware_report_enabled_ && !MalwareKillSwitchIsOn()) {
       scoped_ptr<ClientMalwareRequest> malware_verdict(
           new ClientMalwareRequest);
       // Start browser-side malware feature extraction.  Once we're done it will
       // send the malware client verdict request.
       malware_verdict->set_url(verdict->url());
+      // This function doesn't expect browse_info_ to stay around after this
+      // function returns.
       feature_extractor_->ExtractMalwareFeatures(
-          browse_info_.get(), malware_verdict.get());
-      MalwareFeatureExtractionDone(malware_verdict.Pass());
+          browse_info_.get(),
+          malware_verdict.release(),
+          base::Bind(&ClientSideDetectionHost::MalwareFeatureExtractionDone,
+                     weak_factory_.GetWeakPtr()));
     }
 
     // We only send phishing verdict to the server if the verdict is phishing or
     // if a SafeBrowsing interstitial was already shown for this site.  E.g., a
     // malware or phishing interstitial was shown but the user clicked
     // through.
     if (verdict->is_phishing() || DidShowSBInterstitial()) {
       if (DidShowSBInterstitial()) {
         browse_info_->unsafe_resource.reset(unsafe_resource_.release());
       }
@@ skipping 68 matching lines @@
     }
     // If there is true malware verdict, invalidate weakptr so that no longer
     // consider the phishing vedict.
     weak_factory_.InvalidateWeakPtrs();
   }
 }
 
 void ClientSideDetectionHost::FeatureExtractionDone(
     bool success,
     ClientPhishingRequest* request) {
-  if (!request) {
-    DLOG(FATAL) << "Invalid request object in FeatureExtractionDone";
-    return;
-  }
+  DCHECK(request);
   VLOG(2) << "Feature extraction done (success:" << success << ") for URL: "
           << request->url() << ". Start sending client phishing request.";
   ClientSideDetectionService::ClientReportPhishingRequestCallback callback;
   // If the client-side verdict isn't phishing we don't care about the server
   // response because we aren't going to display a warning.
   if (request->is_phishing()) {
     callback = base::Bind(&ClientSideDetectionHost::MaybeShowPhishingWarning,
                           weak_factory_.GetWeakPtr());
   }
   // Send ping even if the browser feature extraction failed.
   csd_service_->SendClientReportPhishingRequest(
       request,  // The service takes ownership of the request object.
       callback);
 }
 
 void ClientSideDetectionHost::MalwareFeatureExtractionDone(
+    bool feature_extraction_success,
     scoped_ptr<ClientMalwareRequest> request) {
-  if (!request) {
-    DLOG(FATAL) << "Invalid request object in MalwareFeatureExtractionDone";
-    return;
-  }
+  DCHECK(request.get());
   VLOG(2) << "Malware Feature extraction done for URL: " << request->url()
           << ", with features count:" << request->feature_map_size();
 
   // Send ping if there is matching features.
-  if (request->feature_map_size() > 0) {
+  if (feature_extraction_success && request->feature_map_size() > 0) {
     VLOG(1) << "Start sending client malware request.";
     ClientSideDetectionService::ClientReportMalwareRequestCallback callback;
     callback = base::Bind(&ClientSideDetectionHost::MaybeShowMalwareWarning,
                           weak_factory_.GetWeakPtr());
-    csd_service_->SendClientReportMalwareRequest(
-        request.release(),  // The service takes ownership of the request object
-        callback);
+    csd_service_->SendClientReportMalwareRequest(request.release(), callback);
   }
 }
 
 void ClientSideDetectionHost::UpdateIPUrlMap(const std::string& ip,
                                              const std::string& url) {
   if (ip.empty() || url.empty())
     return;
 
   IPUrlMap::iterator it = browse_info_->ips.find(ip);
   if (it == browse_info_->ips.end()) {
@@ skipping 55 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return malware_killswitch_on_;
 }
 
 void ClientSideDetectionHost::SetMalwareKillSwitch(bool killswitch_on) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   malware_killswitch_on_ = killswitch_on;
 }
 
 }  // namespace safe_browsing