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

chrome/browser/engagement/site_engagement_helper.cc

Index: chrome/browser/engagement/site_engagement_helper.cc
diff --git a/chrome/browser/engagement/site_engagement_helper.cc b/chrome/browser/engagement/site_engagement_helper.cc
index b107edf030c458bb1d9803395d91ab0dbc7652c6..9f78d8d2a0b0ea43c84168e66ca34da56c97d157 100644
--- a/chrome/browser/engagement/site_engagement_helper.cc
+++ b/chrome/browser/engagement/site_engagement_helper.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/engagement/site_engagement_helper.h"
 
+#include "base/time/time.h"
+#include "base/trace_event/trace_event.h"
 #include "chrome/browser/engagement/site_engagement_service.h"
 #include "chrome/browser/engagement/site_engagement_service_factory.h"
 #include "chrome/browser/prerender/prerender_contents.h"
@@ -11,36 +13,179 @@
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/web_contents.h"
 
+namespace {
+
+double g_seconds_between_user_input_check = 10;
+
+}  // anonymous namespace
+
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(SiteEngagementHelper);
 
+SiteEngagementHelper::InputTracker::InputTracker(SiteEngagementHelper* helper)
+    : helper_(helper),
+      pause_timer_(new base::Timer(true, false)),
+      callbacks_added_(false) {
+  key_press_event_callback_ =
+      base::Bind(&SiteEngagementHelper::InputTracker::HandleKeyPressEvent,
+                 base::Unretained(this));
+  mouse_event_callback_ =
+      base::Bind(&SiteEngagementHelper::InputTracker::HandleMouseEvent,
+                 base::Unretained(this));
+}
+
+SiteEngagementHelper::InputTracker::~InputTracker() { }
+
+// Record that there was some user input, and defer handling of the input event.
+// web_contents() will return nullptr if the observed contents have been
+// deleted; if the contents exist, record engagement for the site. Once the
+// timer finishes running, the callbacks detecting user input will be registered
+// again.
+bool SiteEngagementHelper::InputTracker::HandleKeyPressEvent(
+    const content::NativeWebKeyboardEvent& event) {
+  // Only respond to raw key down to avoid multiple triggering on a single input
+  // (e.g. keypress is a key down then key up).
+  if (event.type == blink::WebInputEvent::RawKeyDown) {
+    PauseTracking(helper_->web_contents()->GetRenderViewHost());
+    helper_->RecordUserInput();
+  }
+  return false;
+}
+
+bool SiteEngagementHelper::InputTracker::HandleMouseEvent(
+    const blink::WebMouseEvent& event) {

[jdduke (slow), 2015/09/29 15:20:36]

So, WebMouseEvents won't actually include wheel events. Only WebMouseWheelEvents
will have type "WebInputEvent::MouseWheel".

One thought here would be to hook into the more generic "OnUserGesture" signal,
which is fired from RenderWidgetHostImpl::FilterInputEvent. Then you need only
add a WebContentsObserver and listen to DidGetUserGesture.

That should get you both mouse click and gesture hooks, what do you think?

[dominickn, 2015/09/30 00:22:52]

I had a look at DidGetUserGesture as the first thing for this CL, but the
comments for the method in web_contents_observer.h and render_widget_host_impl.h
are very misleading (one claims that it is fired when the next navigation is
triggered by a user gesture, and the other claims it fires for mouse clicks and
enter/space keys). That's why I didn't even try and use it. Perhaps those
comments should be tidied up.

On testing, DidGetUserGesture() fires when you start scrolling on Android, but
it doesn't trigger again until you take your finger off the touch screen and tap
again elsewhere. However, I think it's much noisier than we want:
DidGetUserGesture() is called on every single click or tap. With our current
design, we deregister the listening callbacks for a set period once we have
handled an event, so there is zero overhead most of the time. If we override
DidGetUserGesture(), that's no longer an option, and we'll need to manually
ignore excess clicks and taps, incurring more overhead. I think having the
ability to register and deregister callbacks is a better design.

+  // Only respond to mouse down with a button or mouse move events (e.g. a click
+  // is a mouse down and mouse up) to avoid cases where multiple events come in
+  // before we can pause tracking.
+  if ((event.button != blink::WebMouseEvent::ButtonNone &&
+       event.type == blink::WebInputEvent::MouseDown) ||
+      event.type == blink::WebInputEvent::MouseWheel) {
+    PauseTracking(helper_->web_contents()->GetRenderViewHost());
+    helper_->RecordUserInput();
+  }
+  return false;
+}
+
+void SiteEngagementHelper::InputTracker::StartTracking(
+    content::RenderViewHost* host) {
+  if (!callbacks_added_) {
+    host->AddKeyPressEventCallback(key_press_event_callback_);
+    host->AddMouseEventCallback(mouse_event_callback_);
+    callbacks_added_ = true;
+  }
+}
+
+void SiteEngagementHelper::InputTracker::PauseTracking(
+    content::RenderViewHost* host) {
+  StopTracking(host);
+  pause_timer_->Start(
+      FROM_HERE,
+      base::TimeDelta::FromSeconds(g_seconds_between_user_input_check),
+      base::Bind(&SiteEngagementHelper::InputTracker::ResumeTracking,
+                 base::Unretained(this)));
+}
+
+void SiteEngagementHelper::InputTracker::ResumeTracking() {
+  content::WebContents* contents = helper_->web_contents();
+  if (contents)
+    StartTracking(contents->GetRenderViewHost());
+}
+
+void SiteEngagementHelper::InputTracker::StopTracking(
+    content::RenderViewHost* host) {
+  pause_timer_->Stop();
+  if (callbacks_added_) {
+    host->RemoveKeyPressEventCallback(key_press_event_callback_);
+    host->RemoveMouseEventCallback(mouse_event_callback_);
+    callbacks_added_ = false;
+  }
+}
+
+void SiteEngagementHelper::InputTracker::SetTimerForTesting(
+    scoped_ptr<base::Timer> timer) {
+  pause_timer_ = timer.Pass();
+}
+
 SiteEngagementHelper::~SiteEngagementHelper() {
+  content::WebContents* contents = web_contents();
+  if (contents)
+    input_tracker_.StopTracking(contents->GetRenderViewHost());
 }
 
-SiteEngagementHelper::SiteEngagementHelper(content::WebContents* web_contents)
-    : content::WebContentsObserver(web_contents) {
+SiteEngagementHelper::SiteEngagementHelper(content::WebContents* contents)
+    : content::WebContentsObserver(contents),
+      input_tracker_(this),
+      record_engagement_(false) { }
+
+void SiteEngagementHelper::RecordUserInput() {
+  TRACE_EVENT0("SiteEngagement", "RecordUserInput");
+  content::WebContents* contents = web_contents();
+  if (contents) {
+    Profile* profile =
+        Profile::FromBrowserContext(contents->GetBrowserContext());
+    SiteEngagementService* service =
+        SiteEngagementServiceFactory::GetForProfile(profile);
+
+    // Service is null in incognito.
+    if (service)
+      service->HandleUserInput(contents->GetVisibleURL());
+  }
 }
 
-void SiteEngagementHelper::DidStartNavigationToPendingEntry(
-    const GURL& url,
-    content::NavigationController::ReloadType reload_type) {
-  prerender::PrerenderContents* prerender_contents =
-      prerender::PrerenderContents::FromWebContents(web_contents());
+bool SiteEngagementHelper::ShouldRecordEngagement() {
+  return record_engagement_;
+}
 
-  // Ignore pre-render loads.
-  if (prerender_contents != NULL)
-    return;
+void SiteEngagementHelper::DidNavigateMainFrame(
+    const content::LoadCommittedDetails& details,
+    const content::FrameNavigateParams& params) {
+  content::WebContents* contents = web_contents();
+  input_tracker_.StopTracking(contents->GetRenderViewHost());
 
   // Ignore all schemes except HTTP and HTTPS.
-  if (!url.SchemeIsHTTPOrHTTPS())
+  record_engagement_ = params.url.SchemeIsHTTPOrHTTPS();
+
+  if (!ShouldRecordEngagement())
     return;
 
   Profile* profile =
-      Profile::FromBrowserContext(web_contents()->GetBrowserContext());
+      Profile::FromBrowserContext(contents->GetBrowserContext());
   SiteEngagementService* service =
       SiteEngagementServiceFactory::GetForProfile(profile);
-  // Service is null in incognito.
-  if (!service)
-    return;
 
-  service->HandleNavigation(url);
+  if (service)
+    service->HandleNavigation(params.url, params.transition);
+
+  input_tracker_.StartTracking(contents->GetRenderViewHost());
+}
+
+void SiteEngagementHelper::RenderViewHostChanged(
+    content::RenderViewHost* old_host,
+    content::RenderViewHost* new_host) {
+  // On changing the render view host, we need to re-register the callbacks
+  // listening for user input.
+  if (ShouldRecordEngagement()) {
+    if (old_host)
+      input_tracker_.StopTracking(old_host);
+    input_tracker_.StartTracking(new_host);
+  }
+}
+
+void SiteEngagementHelper::WasShown() {
+  // Ensure that the input callbacks are registered when we come into view.
+  if (ShouldRecordEngagement())
+    input_tracker_.StartTracking(web_contents()->GetRenderViewHost());
+}
+
+void SiteEngagementHelper::WasHidden() {
+  // Ensure that the input callbacks are not registered when hidden.
+  if (ShouldRecordEngagement()) {
+    content::WebContents* contents = web_contents();
+    if (contents)
+      input_tracker_.StopTracking(contents->GetRenderViewHost());
+  }
+}
+
+// static
+void SiteEngagementHelper::SetSecondsBetweenUserInputCheck(double seconds) {
+  g_seconds_between_user_input_check = seconds;
 }