Allow MainThreadEventQueue to call the RenderWidget directly.

content/renderer/input/input_event_filter.h

 // 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.
 
 #ifndef CONTENT_RENDERER_INPUT_INPUT_EVENT_FILTER_H_
 #define CONTENT_RENDERER_INPUT_INPUT_EVENT_FILTER_H_
 
 #include <queue>
 #include <set>
 #include <unordered_map>
@@ skipping 24 matching lines @@
 // based on routing_id (see AddRoute and RemoveRoute).
 //
 // The user of this class provides an instance of InputHandlerManager via
 // |SetInputHandlerManager|. The InputHandlerManager's |HandleInputEvent|
 // will be called on the target thread to process the WebInputEvents.
 //
 
 namespace content {
 
 class CONTENT_EXPORT InputEventFilter : public InputHandlerManagerClient,
-                                        public IPC::MessageFilter,
-                                        public MainThreadEventQueueClient {
+                                        public IPC::MessageFilter {
  public:
   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);
 
   // The |handler| is invoked on the thread associated with |target_loop| to
   // handle input events matching the filtered routes.
   //
   // If INPUT_EVENT_ACK_STATE_NOT_CONSUMED is returned by the handler,
   // the original InputMsg_HandleInputEvent message will be delivered to
   // |main_listener| on the main thread.  (The "main thread" in this context is
   // the thread where the InputEventFilter was constructed.)  The responsibility
   // is left to the eventual handler to deliver the corresponding
   // InputHostMsg_HandleInputEvent_ACK.
   //
   void SetInputHandlerManager(InputHandlerManager*) override;
-  void RegisterRoutingID(int routing_id) override;
+  void RegisterRoutingID(
+      int routing_id,
+      const scoped_refptr<MainThreadEventQueue>& input_event_queue) override;
   void UnregisterRoutingID(int routing_id) override;
   void RegisterAssociatedRenderFrameRoutingID(
       int render_frame_routing_id,
       int render_view_routing_id) override;
   void QueueClosureForMainThreadEventQueue(
       int routing_id,
       const base::Closure& closure) override;
   void DidOverscroll(int routing_id,
                      const ui::DidOverscrollParams& params) override;
   void DidStopFlinging(int routing_id) override;
   void DispatchNonBlockingEventToMainThread(
       int routing_id,
       ui::WebScopedInputEvent event,
       const ui::LatencyInfo& latency_info) override;
 
-  void NotifyInputEventHandled(int routing_id,
-                               blink::WebInputEvent::Type type,
-                               blink::WebInputEventResult result,
-                               InputEventAckState ack_result) override;
-  void ProcessRafAlignedInput(int routing_id,
-                              base::TimeTicks frame_time) override;
-
   // IPC::MessageFilter methods:
   void OnFilterAdded(IPC::Channel* channel) override;
   void OnFilterRemoved() override;
   void OnChannelClosing() override;
   bool OnMessageReceived(const IPC::Message& message) override;
 
-  // MainThreadEventQueueClient methods:
-  void HandleEventOnMainThread(int routing_id,
-                               const blink::WebCoalescedInputEvent* event,
-                               const ui::LatencyInfo& latency,
-                               InputEventDispatchType dispatch_type) override;
-  // Send an InputEventAck IPC message. |touch_event_id| represents
-  // the unique event id for the original WebTouchEvent and should
-  // be 0 if otherwise. See WebInputEventTraits::GetUniqueTouchEventId.
-  void SendInputEventAck(int routing_id,
-                         blink::WebInputEvent::Type type,
-                         InputEventAckState ack_result,
-                         uint32_t touch_event_id) override;
-
-  void NeedsMainFrame(int routing_id) override;
-
  private:
   ~InputEventFilter() override;
 
   void ForwardToHandler(int routing_id,
                         const IPC::Message& message,
                         base::TimeTicks received_time);
   void DidForwardToHandlerAndOverscroll(
       int routing_id,
       InputEventDispatchType dispatch_type,
       InputEventAckState ack_state,
@@ skipping 24 matching lines @@
 
   using RouteQueueMap =
       std::unordered_map<int, scoped_refptr<MainThreadEventQueue>>;
   // Maps RenderView routing ids to a MainThreadEventQueue.
   RouteQueueMap route_queues_;
 
   using AssociatedRoutes = std::unordered_map<int, int>;
   // Maps RenderFrame routing ids to RenderView routing ids so that
   // events sent down the two routing pipes can be handled synchronously.
   AssociatedRoutes associated_routes_;
-
-  blink::scheduler::RendererScheduler* renderer_scheduler_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_INPUT_INPUT_EVENT_FILTER_H_