Implement a site engagement score based on time-on-site.

chrome/browser/engagement/site_engagement_service_browsertest.cc

Index: chrome/browser/engagement/site_engagement_service_browsertest.cc
diff --git a/chrome/browser/engagement/site_engagement_service_browsertest.cc b/chrome/browser/engagement/site_engagement_service_browsertest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..faba78e31a93f78800731e1a2b2516c046b7206f
--- /dev/null
+++ b/chrome/browser/engagement/site_engagement_service_browsertest.cc
@@ -0,0 +1,478 @@
+// Copyright 2015 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/command_line.h"
+#include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
+#include "base/task_runner.h"
+#include "base/test/simple_test_clock.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/timer/mock_timer.h"
+#include "base/values.h"
+#include "chrome/browser/engagement/site_engagement_helper.h"
+#include "chrome/browser/engagement/site_engagement_service.h"
+#include "chrome/browser/engagement/site_engagement_service_factory.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/test/base/browser_with_test_window_test.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "chrome/test/base/ui_test_utils.h"
+#include "content/public/test/browser_test_utils.h"
+#include "content/public/test/test_navigation_observer.h"
+#include "net/test/embedded_test_server/embedded_test_server.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/events/keycodes/keyboard_codes.h"
+
+class TestObserver : public SiteEngagementHelper::Observer {
+ public:
+  TestObserver(SiteEngagementHelper* helper, base::Closure quit_closure)
+      : helper_(helper), quit_closure_(quit_closure) { }
+  ~TestObserver() {
+    helper_->RemoveObserverForTesting(this);
+  }
+
+  void OnInputRecorded(SiteEngagementHelper* helper) override {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, quit_closure_);
+  }
+
+ private:
+  SiteEngagementHelper* helper_;
+  base::Closure quit_closure_;
+};
+
+class SiteEngagementServiceBrowserTest : public InProcessBrowserTest {
+ public:
+  void SetUpOnMainThread() override {
+    ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+    InProcessBrowserTest::SetUpOnMainThread();
+  }
+
+  // Create a SiteEngagementHelper. Called here as friend class methods cannot
+  // be called in tests.
+  SiteEngagementHelper* CreateHelper(content::WebContents* web_contents,

[benwells, 2015/09/29 00:24:12]

Since you create the helper here, can you have a TestSiteEngagementHelper
instead of using a regalar one? That would let you move most of the weird test
only stuff out of the regular SiteEngagementHelper.

[dominickn, 2015/09/29 01:40:37]

Done, though it does make this test pretty ugly.

+                                     bool enable_callbacks) {
+    SiteEngagementHelper::CreateForWebContents(web_contents);
+    SiteEngagementHelper* helper =
+      SiteEngagementHelper::FromWebContents(web_contents);
+    DCHECK(helper);
+
+    // Selectively enable or disable the input listening callbacks to avoid
+    // interference in tests.
+    if (enable_callbacks)
+      SiteEngagementHelper::EnableCallbackRegistrationForTesting();
+    else
+      SiteEngagementHelper::DisableCallbackRegistrationForTesting();
+    return helper;
+  }
+
+  // Simulate a key press event and handle it.
+  void HandleKeyPress(SiteEngagementHelper* helper, ui::KeyboardCode key) {
+    content::NativeWebKeyboardEvent event;
+    event.windowsKeyCode = key;
+    event.type = blink::WebKeyboardEvent::RawKeyDown;
+    helper->input_tracker_->HandleKeyPressEvent(event);
+  }
+
+  // Simulate a mouse event and handle it.
+  void HandleMouseEvent(SiteEngagementHelper* helper,
+                        blink::WebMouseEvent::Button button,
+                        blink::WebInputEvent::Type type) {
+    blink::WebMouseEvent event;
+    event.button = button;
+    event.type = type;
+    helper->input_tracker_->HandleMouseEvent(event);
+  }
+
+  // Set a timer object for test purposes.
+  void SetHelperTimer(SiteEngagementHelper* helper,
+                      scoped_ptr<base::Timer> timer) {
+    helper->input_tracker_->SetTimerForTesting(timer.Pass());
+  }
+
+  bool CallbacksAdded(SiteEngagementHelper* helper) {
+    return helper->input_tracker_->callbacks_added();
+  }
+};
+
+IN_PROC_BROWSER_TEST_F(SiteEngagementServiceBrowserTest,
+                       KeyPressEngagementAccumulation) {
+  GURL url1("https://www.google.com/");
+  GURL url2("http://www.google.com/");
+  content::WebContents* web_contents =
+    browser()->tab_strip_model()->GetActiveWebContents();
+
+  SiteEngagementHelper* helper = CreateHelper(web_contents, false);
+  SiteEngagementService* service =
+    SiteEngagementServiceFactory::GetForProfile(browser()->profile());
+  DCHECK(service);
+
+  // Check that navigation triggers engagement.
+  ui_test_utils::NavigateToURL(browser(), url1);
+  EXPECT_DOUBLE_EQ(0.5, service->GetScore(url1));
+  EXPECT_EQ(0, service->GetScore(url2));
+
+  // Simulate a key press trigger and ensure it is treated correctly.
+  HandleKeyPress(helper, ui::VKEY_DOWN);
+
+  EXPECT_DOUBLE_EQ(0.55, service->GetScore(url1));
+  EXPECT_EQ(0, service->GetScore(url2));
+
+  // Simulate three key presses, and ensure they are treated correctly.
+  HandleKeyPress(helper, ui::VKEY_UP);
+  HandleKeyPress(helper, ui::VKEY_RETURN);
+  HandleKeyPress(helper, ui::VKEY_J);
+
+  EXPECT_DOUBLE_EQ(0.7, service->GetScore(url1));
+  EXPECT_EQ(0, service->GetScore(url2));
+
+  // Simulate key presses for a different link.
+  ui_test_utils::NavigateToURL(browser(), url2);
+
+  EXPECT_DOUBLE_EQ(0.7, service->GetScore(url1));
+  EXPECT_DOUBLE_EQ(0.5, service->GetScore(url2));
+  EXPECT_DOUBLE_EQ(1.2, service->GetTotalEngagementPoints());
+
+  HandleKeyPress(helper, ui::VKEY_K);
+  EXPECT_DOUBLE_EQ(0.7, service->GetScore(url1));
+  EXPECT_DOUBLE_EQ(0.55, service->GetScore(url2));
+  EXPECT_DOUBLE_EQ(1.25, service->GetTotalEngagementPoints());
+}
+
+IN_PROC_BROWSER_TEST_F(SiteEngagementServiceBrowserTest,
+                       MouseEventEngagementAccumulation) {
+  GURL url1("https://www.google.com/");
+  GURL url2("http://www.google.com/");
+  content::WebContents* web_contents =
+    browser()->tab_strip_model()->GetActiveWebContents();
+
+  SiteEngagementHelper* helper = CreateHelper(web_contents, false);
+  SiteEngagementService* service =
+    SiteEngagementServiceFactory::GetForProfile(browser()->profile());
+  DCHECK(service);
+
+  ui_test_utils::NavigateToURL(browser(), url1);
+  EXPECT_DOUBLE_EQ(0.5, service->GetScore(url1));
+  EXPECT_EQ(0, service->GetScore(url2));
+
+  HandleMouseEvent(helper, blink::WebMouseEvent::ButtonLeft,
+                   blink::WebInputEvent::MouseDown);
+
+  EXPECT_DOUBLE_EQ(0.55, service->GetScore(url1));
+  EXPECT_EQ(0, service->GetScore(url2));
+
+  HandleMouseEvent(helper, blink::WebMouseEvent::ButtonRight,
+                   blink::WebInputEvent::MouseWheel);
+  HandleMouseEvent(helper, blink::WebMouseEvent::ButtonMiddle,
+                   blink::WebInputEvent::MouseDown);
+  HandleMouseEvent(helper, blink::WebMouseEvent::ButtonLeft,
+                   blink::WebInputEvent::MouseDown);
+
+  EXPECT_DOUBLE_EQ(0.7, service->GetScore(url1));
+  EXPECT_EQ(0, service->GetScore(url2));
+
+  ui_test_utils::NavigateToURL(browser(), url2);
+
+  EXPECT_DOUBLE_EQ(0.7, service->GetScore(url1));
+  EXPECT_DOUBLE_EQ(0.5, service->GetScore(url2));
+  EXPECT_DOUBLE_EQ(1.2, service->GetTotalEngagementPoints());
+
+  HandleMouseEvent(helper, blink::WebMouseEvent::ButtonLeft,
+                   blink::WebInputEvent::MouseDown);
+  EXPECT_DOUBLE_EQ(0.7, service->GetScore(url1));
+  EXPECT_DOUBLE_EQ(0.55, service->GetScore(url2));
+  EXPECT_DOUBLE_EQ(1.25, service->GetTotalEngagementPoints());
+}
+
+IN_PROC_BROWSER_TEST_F(SiteEngagementServiceBrowserTest,
+                       MixedInputEngagementAccumulation) {
+  GURL url1("https://www.google.com/");
+  GURL url2("http://www.google.com/");
+  content::WebContents* web_contents =
+    browser()->tab_strip_model()->GetActiveWebContents();
+
+  SiteEngagementHelper* helper = CreateHelper(web_contents, false);
+  SiteEngagementService* service =
+    SiteEngagementServiceFactory::GetForProfile(browser()->profile());
+  DCHECK(service);
+
+  ui_test_utils::NavigateToURL(browser(), url1);
+  EXPECT_DOUBLE_EQ(0.5, service->GetScore(url1));
+  EXPECT_EQ(0, service->GetScore(url2));
+
+  HandleKeyPress(helper, ui::VKEY_UP);
+  HandleKeyPress(helper, ui::VKEY_RETURN);
+  HandleKeyPress(helper, ui::VKEY_J);
+
+  HandleMouseEvent(helper, blink::WebMouseEvent::ButtonLeft,
+                   blink::WebInputEvent::MouseDown);
+
+  EXPECT_DOUBLE_EQ(0.7, service->GetScore(url1));
+  EXPECT_EQ(0, service->GetScore(url2));
+
+  HandleMouseEvent(helper, blink::WebMouseEvent::ButtonRight,
+                   blink::WebInputEvent::MouseDown);
+  HandleMouseEvent(helper, blink::WebMouseEvent::ButtonMiddle,
+                   blink::WebInputEvent::MouseDown);
+  HandleMouseEvent(helper, blink::WebMouseEvent::ButtonNone,
+                   blink::WebInputEvent::MouseWheel);
+
+  EXPECT_DOUBLE_EQ(0.85, service->GetScore(url1));
+  EXPECT_EQ(0, service->GetScore(url2));
+
+  ui_test_utils::NavigateToURL(browser(), url2);
+
+  EXPECT_DOUBLE_EQ(0.85, service->GetScore(url1));
+  EXPECT_DOUBLE_EQ(0.5, service->GetScore(url2));
+  EXPECT_DOUBLE_EQ(1.35, service->GetTotalEngagementPoints());
+
+  HandleMouseEvent(helper, blink::WebMouseEvent::ButtonNone,
+                   blink::WebInputEvent::MouseWheel);
+  HandleKeyPress(helper, ui::VKEY_DOWN);
+
+  EXPECT_DOUBLE_EQ(0.85, service->GetScore(url1));
+  EXPECT_DOUBLE_EQ(0.6, service->GetScore(url2));
+  EXPECT_DOUBLE_EQ(1.45, service->GetTotalEngagementPoints());
+}
+
+IN_PROC_BROWSER_TEST_F(SiteEngagementServiceBrowserTest,
+                       CheckTimer) {
+  GURL url1("https://www.google.com/");
+  GURL url2("http://www.google.com/");
+  content::WebContents* web_contents =
+    browser()->tab_strip_model()->GetActiveWebContents();
+
+  scoped_ptr<base::MockTimer> mock_timer(new base::MockTimer(true, false));
+  base::MockTimer* timer = mock_timer.get();
+  SiteEngagementHelper* helper = CreateHelper(web_contents, false);
+  SetHelperTimer(helper, mock_timer.Pass());
+
+  SiteEngagementService* service =
+    SiteEngagementServiceFactory::GetForProfile(browser()->profile());
+  DCHECK(service);
+
+  ui_test_utils::NavigateToURL(browser(), url1);
+  EXPECT_DOUBLE_EQ(0.5, service->GetScore(url1));
+  EXPECT_EQ(0, service->GetScore(url2));
+
+  // Timer should not be running after navigation. It should start after input.
+  EXPECT_FALSE(timer->IsRunning());
+  HandleKeyPress(helper, ui::VKEY_RETURN);
+  EXPECT_TRUE(timer->IsRunning());
+
+  EXPECT_DOUBLE_EQ(0.55, service->GetScore(url1));
+  EXPECT_EQ(0, service->GetScore(url2));
+  timer->Fire();
+
+  EXPECT_FALSE(timer->IsRunning());
+  HandleMouseEvent(helper, blink::WebMouseEvent::ButtonNone,
+                   blink::WebInputEvent::MouseWheel);
+  EXPECT_TRUE(timer->IsRunning());
+
+  EXPECT_DOUBLE_EQ(0.6, service->GetScore(url1));
+  EXPECT_EQ(0, service->GetScore(url2));
+  timer->Fire();
+
+  EXPECT_FALSE(timer->IsRunning());
+  ui_test_utils::NavigateToURL(browser(), url2);
+  EXPECT_FALSE(timer->IsRunning());
+
+  EXPECT_DOUBLE_EQ(0.6, service->GetScore(url1));
+  EXPECT_DOUBLE_EQ(0.5, service->GetScore(url2));
+
+  HandleMouseEvent(helper, blink::WebMouseEvent::ButtonRight,
+                   blink::WebInputEvent::MouseDown);
+  EXPECT_TRUE(timer->IsRunning());
+
+  EXPECT_DOUBLE_EQ(0.6, service->GetScore(url1));
+  EXPECT_DOUBLE_EQ(0.55, service->GetScore(url2));
+  EXPECT_DOUBLE_EQ(1.15, service->GetTotalEngagementPoints());
+}
+
+IN_PROC_BROWSER_TEST_F(SiteEngagementServiceBrowserTest,
+                       SimulateInput) {
+  GURL url1("https://www.google.com/");
+  GURL url2("http://www.google.com/");
+  content::WebContents* web_contents =
+    browser()->tab_strip_model()->GetActiveWebContents();
+
+  scoped_ptr<base::MockTimer> mock_timer(new base::MockTimer(true, false));
+  base::MockTimer* timer = mock_timer.get();
+  SiteEngagementHelper* helper = CreateHelper(web_contents, true);
+  SetHelperTimer(helper, mock_timer.Pass());
+
+  SiteEngagementService* service =
+    SiteEngagementServiceFactory::GetForProfile(browser()->profile());
+  DCHECK(service);
+  EXPECT_FALSE(timer->IsRunning());
+
+  // Navigate and click. Ensure that the timer is running as expected.
+  {
+    base::RunLoop run_loop;
+    TestObserver observer(helper, run_loop.QuitClosure());
+    helper->AddObserverForTesting(&observer);
+
+    ui_test_utils::NavigateToURL(browser(), url1);
+    EXPECT_DOUBLE_EQ(0.5, service->GetScore(url1));
+    EXPECT_EQ(0, service->GetScore(url2));
+    EXPECT_FALSE(timer->IsRunning());
+    EXPECT_TRUE(CallbacksAdded(helper));
+
+    // Click and wait until the observer exits.
+    content::SimulateMouseClick(web_contents, 0,
+                                blink::WebMouseEvent::ButtonLeft);
+    run_loop.Run();
+
+    EXPECT_DOUBLE_EQ(0.55, service->GetScore(url1));
+    EXPECT_EQ(0, service->GetScore(url2));
+    EXPECT_TRUE(timer->IsRunning());
+    EXPECT_FALSE(CallbacksAdded(helper));
+    timer->Fire();
+  }
+
+  // Navigate and click.
+  {
+    base::RunLoop run_loop;
+    TestObserver observer(helper, run_loop.QuitClosure());
+    helper->AddObserverForTesting(&observer);
+
+    EXPECT_FALSE(timer->IsRunning());
+    EXPECT_TRUE(CallbacksAdded(helper));
+    ui_test_utils::NavigateToURL(browser(), url1);
+    EXPECT_DOUBLE_EQ(1.05, service->GetScore(url1));
+    EXPECT_EQ(0, service->GetScore(url2));
+    EXPECT_FALSE(timer->IsRunning());
+    EXPECT_TRUE(CallbacksAdded(helper));
+
+    content::SimulateMouseClick(web_contents, 0,
+                                blink::WebMouseEvent::ButtonLeft);
+    run_loop.Run();
+
+    EXPECT_DOUBLE_EQ(1.1, service->GetScore(url1));
+    EXPECT_EQ(0, service->GetScore(url2));
+    EXPECT_TRUE(timer->IsRunning());
+    EXPECT_FALSE(CallbacksAdded(helper));
+    timer->Fire();
+  }
+
+  // Click only.
+  {
+    base::RunLoop run_loop;
+    TestObserver observer(helper, run_loop.QuitClosure());
+    helper->AddObserverForTesting(&observer);
+
+    EXPECT_FALSE(timer->IsRunning());
+    EXPECT_TRUE(CallbacksAdded(helper));
+    content::SimulateMouseClick(web_contents, 0,
+                                blink::WebMouseEvent::ButtonMiddle);
+    run_loop.Run();
+
+    EXPECT_DOUBLE_EQ(1.15, service->GetScore(url1));
+    EXPECT_EQ(0, service->GetScore(url2));
+    EXPECT_TRUE(timer->IsRunning());
+    EXPECT_FALSE(CallbacksAdded(helper));
+    timer->Fire();
+  }
+
+  // Navigate and click.
+  {
+    base::RunLoop run_loop;
+    TestObserver observer(helper, run_loop.QuitClosure());
+    helper->AddObserverForTesting(&observer);
+
+    EXPECT_FALSE(timer->IsRunning());
+    EXPECT_TRUE(CallbacksAdded(helper));
+    ui_test_utils::NavigateToURL(browser(), url1);
+    EXPECT_DOUBLE_EQ(1.65, service->GetScore(url1));
+    EXPECT_EQ(0, service->GetScore(url2));
+    content::SimulateMouseClick(web_contents, 0,
+                                blink::WebMouseEvent::ButtonRight);
+    run_loop.Run();
+
+    EXPECT_DOUBLE_EQ(1.7, service->GetScore(url1));
+    EXPECT_EQ(0, service->GetScore(url2));
+    EXPECT_TRUE(timer->IsRunning());
+    EXPECT_FALSE(CallbacksAdded(helper));
+
+    // Simulate another event while the timer is running to make sure that this
+    // input is ignored.
+    content::SimulateMouseClick(web_contents, 0,
+                                blink::WebMouseEvent::ButtonLeft);
+
+    EXPECT_DOUBLE_EQ(1.7, service->GetScore(url1));
+    EXPECT_EQ(0, service->GetScore(url2));
+    EXPECT_TRUE(timer->IsRunning());
+    EXPECT_FALSE(CallbacksAdded(helper));
+    timer->Fire();
+  }
+}
+
+IN_PROC_BROWSER_TEST_F(SiteEngagementServiceBrowserTest,
+                       ShowAndHide) {
+  GURL url1("https://www.google.com/");
+  GURL url2("http://www.google.com/");
+  content::WebContents* web_contents =
+    browser()->tab_strip_model()->GetActiveWebContents();
+
+  scoped_ptr<base::MockTimer> mock_timer(new base::MockTimer(true, false));
+  base::MockTimer* timer = mock_timer.get();
+  SiteEngagementHelper* helper = CreateHelper(web_contents, true);
+  SetHelperTimer(helper, mock_timer.Pass());
+
+  SiteEngagementService* service =
+    SiteEngagementServiceFactory::GetForProfile(browser()->profile());
+  DCHECK(service);
+  EXPECT_FALSE(timer->IsRunning());
+
+  // Navigate and hide.
+  {
+    base::RunLoop run_loop;
+    TestObserver observer(helper, run_loop.QuitClosure());
+    helper->AddObserverForTesting(&observer);
+
+    ui_test_utils::NavigateToURL(browser(), url1);
+    EXPECT_TRUE(CallbacksAdded(helper));
+    content::SimulateMouseClick(web_contents, 0,
+                                blink::WebMouseEvent::ButtonRight);
+    run_loop.Run();
+
+    // Timer runs after input is recorded.
+    EXPECT_TRUE(timer->IsRunning());
+    EXPECT_FALSE(CallbacksAdded(helper));
+
+    ui_test_utils::NavigateToURLWithDisposition(
+        browser(), url2, NEW_FOREGROUND_TAB,
+        ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
+
+    // Hiding the original tab should stop the timer.
+    EXPECT_FALSE(timer->IsRunning());
+    EXPECT_FALSE(CallbacksAdded(helper));
+    EXPECT_EQ(2, browser()->tab_strip_model()->count());
+
+    // Timer should still be stopped on re-focus, but the input callbacks
+    // should now be added.
+    browser()->tab_strip_model()->ActivateTabAt(0, true);
+    EXPECT_FALSE(timer->IsRunning());
+    EXPECT_TRUE(CallbacksAdded(helper));
+  }
+
+  // Click. Timer should be started.
+  {
+    base::RunLoop run_loop;
+    TestObserver observer(helper, run_loop.QuitClosure());
+    helper->AddObserverForTesting(&observer);
+
+    content::SimulateMouseClick(web_contents, 0,
+                                blink::WebMouseEvent::ButtonRight);
+    run_loop.Run();
+
+    // Timer runs after input is recorded, and after it fires the callbacks are
+    // added.
+    EXPECT_FALSE(CallbacksAdded(helper));
+    EXPECT_TRUE(timer->IsRunning());
+    timer->Fire();
+    EXPECT_FALSE(timer->IsRunning());
+    EXPECT_TRUE(CallbacksAdded(helper));
+  }
+}