Create a browser feature extractor that runs after the renderer has

chrome/browser/safe_browsing/client_side_detection_host_unittest.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 "base/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/task.h"
+#include "chrome/browser/safe_browsing/browser_feature_extractor.h"
 #include "chrome/browser/safe_browsing/client_side_detection_host.h"
 #include "chrome/browser/safe_browsing/client_side_detection_service.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/tab_contents/test_tab_contents_wrapper.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
 #include "chrome/common/safe_browsing/safebrowsing_messages.h"
 #include "chrome/test/testing_profile.h"
 #include "chrome/test/ui_test_utils.h"
@@ skipping 22 matching lines @@
 const bool kFalse = false;
 const bool kTrue = true;
 }
 
 namespace safe_browsing {
 namespace {
 MATCHER_P(EqualsProto, other, "") {
   return other.SerializeAsString() == arg.SerializeAsString();
 }
 
+ACTION(QuitUIMessageLoop) {
+  EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  MessageLoopForUI::current()->Quit();
+}
+
 class MockClientSideDetectionService : public ClientSideDetectionService {
  public:
   MockClientSideDetectionService() : ClientSideDetectionService(NULL) {}
   virtual ~MockClientSideDetectionService() {};
 
   MOCK_METHOD2(SendClientReportPhishingRequest,
                void(ClientPhishingRequest*,
                     ClientReportPhishingRequestCallback*));
   MOCK_CONST_METHOD1(IsPrivateIPAddress, bool(const std::string&));
   MOCK_METHOD2(GetValidCachedResult, bool(const GURL&, bool*));
@@ skipping 27 matching lines @@
 };
 
 class MockTestingProfile : public TestingProfile {
  public:
   MockTestingProfile() {}
   virtual ~MockTestingProfile() {}
 
   MOCK_METHOD0(IsOffTheRecord, bool());
 };
 
+class MockBrowserFeatureExtractor : public BrowserFeatureExtractor {
+ public:
+  explicit MockBrowserFeatureExtractor(TabContents* tab)
+      : BrowserFeatureExtractor(tab) {}
+  virtual ~MockBrowserFeatureExtractor() {}
+
+  MOCK_METHOD2(ExtractFeatures, void(ClientPhishingRequest*,
+                                     BrowserFeatureExtractor::DoneCallback*));
+};
+
 // Helper function which quits the UI message loop from the IO message loop.
-void QuitUIMessageLoop() {
+void QuitUIMessageLoopFromIO() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           new MessageLoop::QuitTask());
 }
 }  // namespace
 
 class ClientSideDetectionHostTest : public TabContentsWrapperTestHarness {
  public:
   virtual void SetUp() {
@@ skipping 27 matching lines @@
   void OnDetectedPhishingSite(const std::string& verdict_str) {
     csd_host_->OnDetectedPhishingSite(verdict_str);
   }
 
   void FlushIOMessageLoop() {
     // If there was a message posted on the IO thread to display the
     // interstitial page we know that it would have been posted before
     // we put the quit message there.
     BrowserThread::PostTask(BrowserThread::IO,
                             FROM_HERE,
-                            NewRunnableFunction(&QuitUIMessageLoop));
+                            NewRunnableFunction(&QuitUIMessageLoopFromIO));
     MessageLoop::current()->Run();
   }
 
   void ExpectPreClassificationChecks(const GURL& url,
                                      const bool* is_private,
                                      const bool* is_incognito,
                                      const bool* match_csd_whitelist,
                                      const bool* get_valid_cached_result,
                                      const bool* is_in_cache,
                                      const bool* over_report_limit) {
@@ skipping 26 matching lines @@
   void WaitAndCheckPreClassificationChecks() {
     // Wait for CheckCsdWhitelist to be called if at all.
     FlushIOMessageLoop();
     // Checks for CheckCache() to be called if at all.
     MessageLoop::current()->RunAllPending();
     EXPECT_TRUE(Mock::VerifyAndClear(csd_service_.get()));
     EXPECT_TRUE(Mock::VerifyAndClear(sb_service_.get()));
     EXPECT_TRUE(Mock::VerifyAndClear(mock_profile_));
   }
 
+  void SetFeatureExtractor(BrowserFeatureExtractor* extractor) {
+    csd_host_->feature_extractor_.reset(extractor);
+  }
+
  protected:
   ClientSideDetectionHost* csd_host_;
   scoped_ptr<StrictMock<MockClientSideDetectionService> > csd_service_;
   scoped_refptr<StrictMock<MockSafeBrowsingService> > sb_service_;
   MockTestingProfile* mock_profile_;  // We don't own this object
 
  private:
   scoped_ptr<BrowserThread> ui_thread_;
   scoped_ptr<BrowserThread> io_thread_;
 };
 
 TEST_F(ClientSideDetectionHostTest, OnDetectedPhishingSiteInvalidVerdict) {
   // Case 0: renderer sends an invalid verdict string that we're unable to
   // parse.
-  EXPECT_CALL(*csd_service_, SendClientReportPhishingRequest(_, _)).Times(0);
+  MockBrowserFeatureExtractor* mock_extractor = new MockBrowserFeatureExtractor(
+      contents());
+  SetFeatureExtractor(mock_extractor);  // The host class takes ownership.
+  EXPECT_CALL(*mock_extractor, ExtractFeatures(_, _)).Times(0);
   OnDetectedPhishingSite("Invalid Protocol Buffer");
-  EXPECT_TRUE(Mock::VerifyAndClear(csd_service_.get()));
+  EXPECT_TRUE(Mock::VerifyAndClear(mock_extractor));
 }
 
 TEST_F(ClientSideDetectionHostTest, OnDetectedPhishingSiteNotPhishing) {
   // Case 1: client thinks the page is phishing.  The server does not agree.
   // No interstitial is shown.
   ClientSideDetectionService::ClientReportPhishingRequestCallback* cb;
   ClientPhishingRequest verdict;
   verdict.set_url("http://phishingurl.com/");
   verdict.set_client_score(1.0f);
   verdict.set_is_phishing(true);
 
   EXPECT_CALL(*csd_service_,
               SendClientReportPhishingRequest(Pointee(EqualsProto(verdict)), _))
-      .WillOnce(DoAll(DeleteArg<0>(), SaveArg<1>(&cb)));
+      .WillOnce(DoAll(DeleteArg<0>(), SaveArg<1>(&cb), QuitUIMessageLoop()));
   OnDetectedPhishingSite(verdict.SerializeAsString());
+  MessageLoop::current()->Run();
   EXPECT_TRUE(Mock::VerifyAndClear(csd_service_.get()));
   ASSERT_TRUE(cb);
 
   // Make sure DoDisplayBlockingPage is not going to be called.
   EXPECT_CALL(*sb_service_, DoDisplayBlockingPage(_)).Times(0);
   cb->Run(GURL(verdict.url()), false);
   delete cb;
   MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(Mock::VerifyAndClear(sb_service_.get()));
 }
 
 TEST_F(ClientSideDetectionHostTest, OnDetectedPhishingSiteDisabled) {
   // Case 2: client thinks the page is phishing and so does the server but
   // showing the interstitial is disabled => no interstitial is shown.
   ClientSideDetectionService::ClientReportPhishingRequestCallback* cb;
   ClientPhishingRequest verdict;
   verdict.set_url("http://phishingurl.com/");
   verdict.set_client_score(1.0f);
   verdict.set_is_phishing(true);
 
   EXPECT_CALL(*csd_service_,
               SendClientReportPhishingRequest(Pointee(EqualsProto(verdict)), _))
-      .WillOnce(DoAll(DeleteArg<0>(), SaveArg<1>(&cb)));
+      .WillOnce(DoAll(DeleteArg<0>(), SaveArg<1>(&cb), QuitUIMessageLoop()));
   OnDetectedPhishingSite(verdict.SerializeAsString());
+  MessageLoop::current()->Run();
   EXPECT_TRUE(Mock::VerifyAndClear(csd_service_.get()));
   ASSERT_TRUE(cb);
 
   // Make sure DoDisplayBlockingPage is not going to be called.
   EXPECT_CALL(*sb_service_, DoDisplayBlockingPage(_)).Times(0);
   cb->Run(GURL(verdict.url()), false);
   delete cb;
   MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(Mock::VerifyAndClear(sb_service_.get()));
 }
 
 TEST_F(ClientSideDetectionHostTest, OnDetectedPhishingSiteShowInterstitial) {
   // Case 3: client thinks the page is phishing and so does the server.
   // We show an interstitial.
   ClientSideDetectionService::ClientReportPhishingRequestCallback* cb;
   GURL phishing_url("http://phishingurl.com/");
   ClientPhishingRequest verdict;
   verdict.set_url(phishing_url.spec());
   verdict.set_client_score(1.0f);
   verdict.set_is_phishing(true);
 
   EXPECT_CALL(*csd_service_,
               SendClientReportPhishingRequest(Pointee(EqualsProto(verdict)), _))
-      .WillOnce(DoAll(DeleteArg<0>(), SaveArg<1>(&cb)));
+      .WillOnce(DoAll(DeleteArg<0>(), SaveArg<1>(&cb), QuitUIMessageLoop()));
   OnDetectedPhishingSite(verdict.SerializeAsString());
+  MessageLoop::current()->Run();
   EXPECT_TRUE(Mock::VerifyAndClear(csd_service_.get()));
   ASSERT_TRUE(cb);
 
   SafeBrowsingService::UnsafeResource resource;
   EXPECT_CALL(*sb_service_, DoDisplayBlockingPage(_))
       .WillOnce(SaveArg<0>(&resource));
   cb->Run(phishing_url, true);
   delete cb;
 
   MessageLoop::current()->RunAllPending();
@@ skipping 30 matching lines @@
   // a single interstitial is shown for the second URL.
   ClientSideDetectionService::ClientReportPhishingRequestCallback* cb;
   GURL phishing_url("http://phishingurl.com/");
   ClientPhishingRequest verdict;
   verdict.set_url(phishing_url.spec());
   verdict.set_client_score(1.0f);
   verdict.set_is_phishing(true);
 
   EXPECT_CALL(*csd_service_,
               SendClientReportPhishingRequest(Pointee(EqualsProto(verdict)), _))
-      .WillOnce(DoAll(DeleteArg<0>(), SaveArg<1>(&cb)));
+      .WillOnce(DoAll(DeleteArg<0>(), SaveArg<1>(&cb), QuitUIMessageLoop()));
   OnDetectedPhishingSite(verdict.SerializeAsString());
+  MessageLoop::current()->Run();
   EXPECT_TRUE(Mock::VerifyAndClear(csd_service_.get()));
   ASSERT_TRUE(cb);
   GURL other_phishing_url("http://other_phishing_url.com/bla");
   ExpectPreClassificationChecks(other_phishing_url, &kFalse, &kFalse, &kFalse,
                                 &kFalse, &kFalse, &kFalse);
   // We navigate away.  The callback cb should be revoked.
   NavigateAndCommit(other_phishing_url);
   // Wait for the pre-classification checks to finish for other_phishing_url.
   WaitAndCheckPreClassificationChecks();
 
   ClientSideDetectionService::ClientReportPhishingRequestCallback* cb_other;
   verdict.set_url(other_phishing_url.spec());
   verdict.set_client_score(0.8f);
   EXPECT_CALL(*csd_service_,
               SendClientReportPhishingRequest(Pointee(EqualsProto(verdict)), _))
-      .WillOnce(DoAll(DeleteArg<0>(), SaveArg<1>(&cb_other)));
+      .WillOnce(DoAll(DeleteArg<0>(),
+                      SaveArg<1>(&cb_other),
+                      QuitUIMessageLoop()));
   OnDetectedPhishingSite(verdict.SerializeAsString());
+  MessageLoop::current()->Run();
   EXPECT_TRUE(Mock::VerifyAndClear(csd_service_.get()));
   ASSERT_TRUE(cb_other);
 
   // We expect that the interstitial is shown for the second phishing URL and
   // not for the first phishing URL.
   SafeBrowsingService::UnsafeResource resource;
   EXPECT_CALL(*sb_service_, DoDisplayBlockingPage(_))
       .WillOnce(SaveArg<0>(&resource));
 
   cb->Run(phishing_url, true);  // Should have no effect.
@@ skipping 208 matching lines @@
   EXPECT_TRUE(Mock::VerifyAndClear(sb_service_.get()));
   EXPECT_EQ(url, resource.url);
   EXPECT_EQ(url, resource.original_url);
   delete resource.client;
   msg = process()->sink().GetFirstMessageMatching(
       SafeBrowsingMsg_StartPhishingDetection::ID);
   ASSERT_FALSE(msg);
 }
 
 }  // namespace safe_browsing