Create a browser feature extractor that runs after the renderer has

chrome/browser/safe_browsing/client_side_detection_host.cc

 // Copyright (c) 2011 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"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/task.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/safe_browsing/browser_feature_extractor.h"
 #include "chrome/browser/safe_browsing/client_side_detection_service.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
 #include "chrome/common/safe_browsing/safebrowsing_messages.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/tab_contents/navigation_details.h"
@@ skipping 231 matching lines @@
 
 // static
 ClientSideDetectionHost* ClientSideDetectionHost::Create(
     TabContents* tab) {
   return new ClientSideDetectionHost(tab);
 }
 
 ClientSideDetectionHost::ClientSideDetectionHost(TabContents* tab)
     : TabContentsObserver(tab),
       csd_service_(g_browser_process->safe_browsing_detection_service()),
+      feature_extractor_(new BrowserFeatureExtractor(tab)),
       cb_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(tab);
   // Note: csd_service_ and sb_service_ might be NULL.
   sb_service_ = g_browser_process->safe_browsing_service();
 }
 
-ClientSideDetectionHost::~ClientSideDetectionHost() {
-  // Tell any pending classification request that it is being canceled.
-  if (classification_request_.get()) {
-    classification_request_->Cancel();
-  }
-}
+ClientSideDetectionHost::~ClientSideDetectionHost() {}
 
 bool ClientSideDetectionHost::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ClientSideDetectionHost, message)
     IPC_MESSAGE_HANDLER(SafeBrowsingHostMsg_DetectedPhishingSite,
                         OnDetectedPhishingSite)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
@@ skipping 28 matching lines @@
     // Notify the renderer if it should classify this URL.
     classification_request_ = new ShouldClassifyUrlRequest(params,
                                                            tab_contents(),
                                                            csd_service_,
                                                            sb_service_,
                                                            this);
     classification_request_->Start();
   }
 }
 
+void ClientSideDetectionHost::TabContentsDestroyed(TabContents* 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();
+}
+
 void ClientSideDetectionHost::OnDetectedPhishingSite(
     const std::string& verdict_str) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // There is something seriously wrong if there is no service class but
   // this method is called.  The renderer should not start phishing detection
   // if there isn't any service class in the browser.
   DCHECK(csd_service_);
   // We parse the protocol buffer here.  If we're unable to parse it we won't
   // send the verdict further.
   scoped_ptr<ClientPhishingRequest> verdict(new ClientPhishingRequest);
   if (csd_service_ &&
       verdict->ParseFromString(verdict_str) &&
       verdict->IsInitialized()) {
     // There shouldn't be any pending requests because we revoke them everytime
     // we navigate away.
     DCHECK(!cb_factory_.HasPendingCallbacks());
-    VLOG(2) << "Start sending client phishing request for URL: "
-            << verdict->url();
-    csd_service_->SendClientReportPhishingRequest(
-        verdict.release(),  // The service takes ownership of the verdict.
-        cb_factory_.NewCallback(
-            &ClientSideDetectionHost::MaybeShowPhishingWarning));
+
+    // Start browser-side feature extraction.  Once we're done it will send
+    // the client verdict request.
+    feature_extractor_->ExtractFeatures(
+        verdict.release(),
+        NewCallback(this, &ClientSideDetectionHost::FeatureExtractionDone));
   }
 }
 
 void ClientSideDetectionHost::MaybeShowPhishingWarning(GURL phishing_url,
                                                        bool is_phishing) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(2) << "Received server phishing verdict for URL:" << phishing_url
           << " is_phishing:" << is_phishing;
   if (is_phishing) {
     DCHECK(tab_contents());
@@ skipping 11 matching lines @@
         // We need to stop any pending navigations, otherwise the interstital
         // might not get created properly.
         tab_contents()->controller().DiscardNonCommittedEntries();
         resource.client = new CsdClient();  // Will delete itself
         sb_service_->DoDisplayBlockingPage(resource);
       }
     }
   }
 }
 
+void ClientSideDetectionHost::FeatureExtractionDone(
+    bool success,
+    ClientPhishingRequest* request) {
+  if (!request) {
+    DLOG(FATAL) << "Invalid request object in FeatureExtractionDone";
+    return;
+  }
+  VLOG(2) << "Feature extraction done (success:" << success << ") for URL: "
+          << request->url() << ". Start sending client phishing request.";
+  // Send ping no matter what - even if the browser feature extraction failed.
+  csd_service_->SendClientReportPhishingRequest(
+      request,  // The service takes ownership of the request object.
+      cb_factory_.NewCallback(
+          &ClientSideDetectionHost::MaybeShowPhishingWarning));
+}
+
 void ClientSideDetectionHost::set_client_side_detection_service(
     ClientSideDetectionService* service) {
   csd_service_ = service;
 }
 
 void ClientSideDetectionHost::set_safe_browsing_service(
     SafeBrowsingService* service) {
   sb_service_ = service;
 }
 
 }  // namespace safe_browsing