Implement Main Thread RAF Aligned Input

content/renderer/input/input_event_filter.cc

 // Copyright 2013 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 "content/renderer/input/input_event_filter.h"
 
 #include <tuple>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
+#include "content/public/common/content_features.h"
 #include "content/public/common/content_switches.h"
+#include "content/renderer/input/input_handler_manager.h"
 #include "content/renderer/render_thread_impl.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
 #include "ui/events/blink/did_overscroll_params.h"
 #include "ui/events/blink/web_input_event_traits.h"
 #include "ui/gfx/geometry/vector2d_f.h"
 
 using blink::WebInputEvent;
 using ui::DidOverscrollParams;
 
@@ skipping 16 matching lines @@
 namespace content {
 
 InputEventFilter::InputEventFilter(
     const base::Callback<void(const IPC::Message&)>& main_listener,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& target_task_runner)
     : main_task_runner_(main_task_runner),
       main_listener_(main_listener),
       sender_(NULL),
       target_task_runner_(target_task_runner),
+      input_handler_manager_(NULL),
       current_overscroll_params_(NULL),
       renderer_scheduler_(NULL) {
   DCHECK(target_task_runner_.get());
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
   renderer_scheduler_ =
       render_thread_impl ? render_thread_impl->GetRendererScheduler() : nullptr;
 }
 
-void InputEventFilter::SetBoundHandler(const Handler& handler) {
+void InputEventFilter::SetInputHandlerManager(
+    InputHandlerManager* input_handler_manager) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
-  handler_ = handler;
+  input_handler_manager_ = input_handler_manager;
 }
 
 void InputEventFilter::SetIsFlingingInMainThreadEventQueue(int routing_id,
                                                            bool is_flinging) {
   RouteQueueMap::iterator iter = route_queues_.find(routing_id);
   if (iter == route_queues_.end() || !iter->second)
     return;
 
   iter->second->set_is_flinging(is_flinging);
 }
 
 void InputEventFilter::RegisterRoutingID(int routing_id) {
   base::AutoLock locked(routes_lock_);
   routes_.insert(routing_id);
   route_queues_[routing_id] = new MainThreadEventQueue(

[tdresser, 2016/08/24 13:42:59]

Should we move reading the flag into the MTEQ? It will be reading a few other
flags (fling intervention, unresponsive main thread intervention).

[dtapuska, 2016/08/24 17:10:06]

I guess. I did it this way as it made TEST_P easier. But I do see that others
are adding feature checks inside the class itself.

-      routing_id, this, main_task_runner_, renderer_scheduler_);
+      routing_id, this, main_task_runner_, renderer_scheduler_,
+      base::FeatureList::IsEnabled(features::kRafAlignedInputEvents));
 }
 
 void InputEventFilter::UnregisterRoutingID(int routing_id) {
   base::AutoLock locked(routes_lock_);
   routes_.erase(routing_id);
   route_queues_.erase(routing_id);
 }
 
 void InputEventFilter::DidOverscroll(int routing_id,
                                      const DidOverscrollParams& params) {
@@ skipping 24 matching lines @@
     base::AutoLock locked(routes_lock_);
     RouteQueueMap::iterator iter = route_queues_.find(routing_id);
     if (iter == route_queues_.end() || !iter->second)
       return;
     queue = iter->second;
   }
 
   queue->EventHandled(type, ack_result);
 }
 
+void InputEventFilter::ProcessRafAlignedInput(int routing_id) {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  scoped_refptr<MainThreadEventQueue> queue;
+  {
+    base::AutoLock locked(routes_lock_);
+    RouteQueueMap::iterator iter = route_queues_.find(routing_id);
+    if (iter == route_queues_.end() || !iter->second)
+      return;
+    queue = iter->second;
+  }
+
+  queue->DispatchRafAlignedInput();
+}
+
 void InputEventFilter::OnFilterAdded(IPC::Sender* sender) {
   io_task_runner_ = base::ThreadTaskRunnerHandle::Get();
   sender_ = sender;
 }
 
 void InputEventFilter::OnFilterRemoved() {
   sender_ = NULL;
 }
 
 void InputEventFilter::OnChannelClosing() {
@@ skipping 25 matching lines @@
       FROM_HERE,
       base::Bind(&InputEventFilter::ForwardToHandler, this, message));
   return true;
 }
 
 InputEventFilter::~InputEventFilter() {
   DCHECK(!current_overscroll_params_);
 }
 
 void InputEventFilter::ForwardToHandler(const IPC::Message& message) {
-  DCHECK(!handler_.is_null());
+  DCHECK(input_handler_manager_);
   DCHECK(target_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT1("input", "InputEventFilter::ForwardToHandler",
                "message_type", GetInputMessageTypeName(message));
 
   if (message.type() != InputMsg_HandleInputEvent::ID) {
     TRACE_EVENT_INSTANT0(
         "input",
         "InputEventFilter::ForwardToHandler::ForwardToMainListener",
         TRACE_EVENT_SCOPE_THREAD);
     main_task_runner_->PostTask(FROM_HERE, base::Bind(main_listener_, message));
@@ skipping 14 matching lines @@
 
   bool send_ack = dispatch_type == DISPATCH_TYPE_BLOCKING;
 
   // Intercept |DidOverscroll| notifications, bundling any triggered overscroll
   // response with the input event ack.
   std::unique_ptr<DidOverscrollParams> overscroll_params;
   base::AutoReset<std::unique_ptr<DidOverscrollParams>*>
       auto_reset_current_overscroll_params(
           &current_overscroll_params_, send_ack ? &overscroll_params : NULL);
 
-  InputEventAckState ack_state =
-      handler_.Run(routing_id, event.get(), &latency_info);
+  InputEventAckState ack_state = input_handler_manager_->HandleInputEvent(
+      routing_id, event.get(), &latency_info);
 
   uint32_t unique_touch_event_id =
       ui::WebInputEventTraits::GetUniqueTouchEventId(*event);
   WebInputEvent::Type type = event->type;
 
   if (ack_state == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING ||
       ack_state == INPUT_EVENT_ACK_STATE_NOT_CONSUMED) {
     DCHECK(!overscroll_params);
     RouteQueueMap::iterator iter = route_queues_.find(routing_id);
     if (iter != route_queues_.end()) {
@@ skipping 42 matching lines @@
 
 void InputEventFilter::SendInputEventAck(int routing_id,
                                          blink::WebInputEvent::Type type,
                                          InputEventAckState ack_result,
                                          uint32_t touch_event_id) {
   InputEventAck ack(type, ack_result, touch_event_id);
   SendMessage(std::unique_ptr<IPC::Message>(
       new InputHostMsg_HandleInputEvent_ACK(routing_id, ack)));
 }
 
+void InputEventFilter::NeedsMainFrame(int routing_id) {
+  input_handler_manager_->NeedsMainFrame(routing_id);
+}
+
 }  // namespace content