Create a browser feature extractor that runs after the renderer has

chrome/browser/safe_browsing/browser_feature_extractor_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 "chrome/browser/safe_browsing/browser_feature_extractor.h"
+
+#include <map>
+#include <string>
+
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
+#include "base/time.h"
+#include "chrome/common/safe_browsing/csd.pb.h"
+#include "chrome/browser/history/history.h"
+#include "chrome/browser/history/history_backend.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/test/testing_profile.h"
+#include "content/browser/browser_thread.h"
+#include "content/browser/renderer_host/test_render_view_host.h"
+#include "content/browser/tab_contents/tab_contents.h"
+#include "content/browser/tab_contents/test_tab_contents.h"
+#include "googleurl/src/gurl.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace safe_browsing {
+class BrowserFeatureExtractorTest : public RenderViewHostTestHarness {
+ public:
+  BrowserFeatureExtractorTest()
+      : ui_thread_(BrowserThread::UI, &message_loop_) {
+  }
+  virtual void SetUp() {
+    RenderViewHostTestHarness::SetUp();
+    profile_->CreateHistoryService(true /* delete_file */, false /* no_db */);
+    extractor_.reset(new BrowserFeatureExtractor(contents()));
+  }
+
+  virtual void TearDown() {
+    extractor_.reset();
+    profile_->DestroyHistoryService();
+    RenderViewHostTestHarness::TearDown();
+  }
+
+  HistoryService* history_service() {
+    return profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
+  }
+
+  bool ExtractFeatures(ClientPhishingRequest* request) {
+    StartExtractFeatures(request);
+    MessageLoop::current()->Run();
+    EXPECT_EQ(1U, success_.count(request));
+    return success_.count(request) ? success_[request] : false;
+  }
+
+  void StartExtractFeatures(ClientPhishingRequest* request) {
+    success_.erase(request);
+    extractor_->ExtractFeatures(
+        request,
+        NewCallback(this,
+                    &BrowserFeatureExtractorTest::ExtractFeaturesDone));
+  }
+
+ protected:
+  BrowserThread ui_thread_;
+  scoped_ptr<BrowserFeatureExtractor> extractor_;
+  std::map<ClientPhishingRequest*, bool> success_;
+
+ private:
+  void ExtractFeaturesDone(bool success, ClientPhishingRequest* request) {
+    success_[request] = success;
+    MessageLoop::current()->Quit();
+  }
+};
+
+TEST_F(BrowserFeatureExtractorTest, UrlNotInHistory) {
+  ClientPhishingRequest request;
+  request.set_url("http://www.google.com/");
+  request.set_client_score(0.5);
+  EXPECT_FALSE(ExtractFeatures(&request));
+}
+
+TEST_F(BrowserFeatureExtractorTest, RequestNotInitialized) {
+  ClientPhishingRequest request;
+  request.set_url("http://www.google.com/");
+  // Request is missing the score value.
+  EXPECT_FALSE(ExtractFeatures(&request));
+}
+
+TEST_F(BrowserFeatureExtractorTest, UrlInHistory) {
+  history_service()->AddPage(GURL("http://www.foo.com/bar.html"),
+                             history::SOURCE_BROWSED);
+  history_service()->AddPage(GURL("https://www.foo.com/gaa.html"),
+                             history::SOURCE_BROWSED);  // same domain HTTPS.
+  history_service()->AddPage(GURL("http://www.foo.com/gaa.html"),
+                             history::SOURCE_BROWSED);  // same domain HTTP.
+  history_service()->AddPage(GURL("http://bar.foo.com/gaa.html"),
+                             history::SOURCE_BROWSED);  // different domain.
+  history_service()->AddPage(GURL("http://www.foo.com/bar.html?a=b"),
+                             base::Time::Now() - base::TimeDelta::FromHours(23),
+                             NULL, 0, GURL(), PageTransition::LINK,
+                             history::RedirectList(), history::SOURCE_BROWSED,
+                             false);
+  history_service()->AddPage(GURL("http://www.foo.com/bar.html"),
+                             base::Time::Now() - base::TimeDelta::FromHours(25),
+                             NULL, 0, GURL(), PageTransition::TYPED,
+                             history::RedirectList(), history::SOURCE_BROWSED,
+                             false);
+  history_service()->AddPage(GURL("https://www.foo.com/goo.html"),
+                             base::Time::Now() - base::TimeDelta::FromDays(5),
+                             NULL, 0, GURL(), PageTransition::TYPED,
+                             history::RedirectList(), history::SOURCE_BROWSED,
+                             false);
+
+  ClientPhishingRequest request;
+  request.set_url("http://www.foo.com/bar.html");
+  request.set_client_score(0.5);
+  EXPECT_TRUE(ExtractFeatures(&request));
+  std::map<std::string, double> features;
+  for (int i = 0; i < request.feature_map_size(); ++i) {
+    EXPECT_EQ(0U, features.count(request.feature_map(i).name()));
+    features[request.feature_map(i).name()] = request.feature_map(i).value();
+  }
+  EXPECT_EQ(8U, features.size());
+  EXPECT_DOUBLE_EQ(2.0, features[features::kUrlHistoryVisitCount]);
+  EXPECT_DOUBLE_EQ(1.0, features[features::kUrlHistoryVisitCount24hAgo]);
+  EXPECT_DOUBLE_EQ(1.0, features[features::kUrlHistoryTypedCount]);
+  EXPECT_DOUBLE_EQ(1.0, features[features::kUrlHistoryLinkCount]);
+  EXPECT_DOUBLE_EQ(4.0, features[features::kHttpHostVisitCount]);
+  EXPECT_DOUBLE_EQ(2.0, features[features::kHttpsHostVisitCount]);
+  EXPECT_DOUBLE_EQ(1.0, features[features::kFirstHttpHostVisitMoreThan24hAgo]);
+  EXPECT_DOUBLE_EQ(1.0, features[features::kFirstHttpsHostVisitMoreThan24hAgo]);
+}
+
+TEST_F(BrowserFeatureExtractorTest, MultipleRequestsAtOnce) {
+  history_service()->AddPage(GURL("http://www.foo.com/bar.html"),
+                             history::SOURCE_BROWSED);
+  ClientPhishingRequest request;
+  request.set_url("http://www.foo.com/bar.html");
+  request.set_client_score(0.5);
+  StartExtractFeatures(&request);
+
+  ClientPhishingRequest request2;
+  request2.set_url("http://www.foo.com/goo.html");
+  request2.set_client_score(1.0);
+  StartExtractFeatures(&request2);
+
+  // We have to call Run() twice because we expect ExtractFeaturesDone

[Paweł Hajdan Jr., 2011/06/08 08:54:46]

Could you rather count the number of finished requests in ExtractFeaturesDone
and only quit the loop when all of the expected ones have finished?

I think it's generally cleaner than running the loop multiple times.

[noelutz, 2011/06/08 16:39:30]

Done.

+  // to be called twice.
+  MessageLoop::current()->Run();
+  MessageLoop::current()->Run();
+
+  EXPECT_TRUE(success_[&request]);
+  EXPECT_FALSE(success_[&request2]);
+}
+}  // namespace safe_browsing