1// Copyright 2013 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#ifndef CONTENT_RENDERER_INPUT_INPUT_EVENT_FILTER_H_ 6#define CONTENT_RENDERER_INPUT_INPUT_EVENT_FILTER_H_ 7 8#include <queue> 9#include <set> 10 11#include "base/callback_forward.h" 12#include "base/synchronization/lock.h" 13#include "content/common/content_export.h" 14#include "content/common/input/input_event_ack_state.h" 15#include "content/renderer/input/input_handler_manager_client.h" 16#include "ipc/message_filter.h" 17#include "third_party/WebKit/public/web/WebInputEvent.h" 18 19namespace base { 20class MessageLoopProxy; 21} 22 23namespace IPC { 24class Listener; 25class Sender; 26} 27 28// This class can be used to intercept InputMsg_HandleInputEvent messages 29// and have them be delivered to a target thread. Input events are filtered 30// based on routing_id (see AddRoute and RemoveRoute). 31// 32// The user of this class provides an instance of InputEventFilter::Handler, 33// which will be passed WebInputEvents on the target thread. 34// 35 36namespace content { 37 38class CONTENT_EXPORT InputEventFilter : public InputHandlerManagerClient, 39 public IPC::MessageFilter { 40 public: 41 InputEventFilter(IPC::Listener* main_listener, 42 const scoped_refptr<base::MessageLoopProxy>& target_loop); 43 44 // The |handler| is invoked on the thread associated with |target_loop| to 45 // handle input events matching the filtered routes. 46 // 47 // If INPUT_EVENT_ACK_STATE_NOT_CONSUMED is returned by the handler, 48 // the original InputMsg_HandleInputEvent message will be delivered to 49 // |main_listener| on the main thread. (The "main thread" in this context is 50 // the thread where the InputEventFilter was constructed.) The responsibility 51 // is left to the eventual handler to deliver the corresponding 52 // InputHostMsg_HandleInputEvent_ACK. 53 // 54 virtual void SetBoundHandler(const Handler& handler) OVERRIDE; 55 virtual void DidAddInputHandler(int routing_id, 56 cc::InputHandler* input_handler) OVERRIDE; 57 virtual void DidRemoveInputHandler(int routing_id) OVERRIDE; 58 virtual void DidOverscroll(int routing_id, 59 const DidOverscrollParams& params) OVERRIDE; 60 virtual void DidStopFlinging(int routing_id) OVERRIDE; 61 62 // IPC::MessageFilter methods: 63 virtual void OnFilterAdded(IPC::Sender* sender) OVERRIDE; 64 virtual void OnFilterRemoved() OVERRIDE; 65 virtual void OnChannelClosing() OVERRIDE; 66 virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE; 67 68 private: 69 virtual ~InputEventFilter(); 70 71 void ForwardToMainListener(const IPC::Message& message); 72 void ForwardToHandler(const IPC::Message& message); 73 void SendMessage(scoped_ptr<IPC::Message> message); 74 void SendMessageOnIOThread(scoped_ptr<IPC::Message> message); 75 76 scoped_refptr<base::MessageLoopProxy> main_loop_; 77 IPC::Listener* main_listener_; 78 79 // The sender_ only gets invoked on the thread corresponding to io_loop_. 80 scoped_refptr<base::MessageLoopProxy> io_loop_; 81 IPC::Sender* sender_; 82 83 // The handler_ only gets Run on the thread corresponding to target_loop_. 84 scoped_refptr<base::MessageLoopProxy> target_loop_; 85 Handler handler_; 86 87 // Protects access to routes_. 88 base::Lock routes_lock_; 89 90 // Indicates the routing_ids for which input events should be filtered. 91 std::set<int> routes_; 92 93 // Specifies whether overscroll notifications are forwarded to the host. 94 bool overscroll_notifications_enabled_; 95 96 // Used to intercept overscroll notifications while an event is being 97 // dispatched. If the event causes overscroll, the overscroll metadata can be 98 // bundled in the event ack, saving an IPC. Note that we must continue 99 // supporting overscroll IPC notifications due to fling animation updates. 100 scoped_ptr<DidOverscrollParams>* current_overscroll_params_; 101}; 102 103} // namespace content 104 105#endif // CONTENT_RENDERER_INPUT_INPUT_EVENT_FILTER_H_ 106