Implementation of device metrics emulation in render view.

content/renderer/gpu/input_handler_manager.h

 // Copyright (c) 2012 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_GPU_INPUT_HANDLER_MANAGER_H_
 #define CONTENT_RENDERER_GPU_INPUT_HANDLER_MANAGER_H_
 
 #include <map>
 
 #include "base/memory/ref_counted.h"
@@ skipping 12 matching lines @@
 
 namespace WebKit {
 class WebInputEvent;
 }
 
 namespace content {
 
 class InputHandlerWrapper;
 class InputHandlerManagerClient;
 
+// InputEventRewriter class allows client to rewrite incoming input events

[aelias_OOO_until_Jul13, 2013/09/13 23:51:44]

I don't see why you need this on the impl-thread side.  CC already should apply
the transform tree to hit test input events.  (You'll probably need something on
the main thread side though.)

If it's to correct some browser-side translate or scale that the renderer CC is
not aware of, then I think the right thing to do would be to transform the event
on the browser side instead of here (or perhaps, move that transformation to be
on the renderer CC root layer as well).

[dgozman, 2013/09/14 07:42:42]

Doesn't main thread get events through regular render widget input event
handler? If so, that's already handled.
There is no browser-side transformation. I was not aware that CC takes root
layer transform into account. This thing is not needed then.

[dgozman, 2013/09/19 10:17:11]

This is removed.

+// before passing them to the handler.
+class InputEventRewriter {
+ public:
+  virtual ~InputEventRewriter() {}
+
+  virtual WebKit::WebInputEvent* RewriteInputEvent(
+      const WebKit::WebInputEvent* event) = 0;
+};
+
 // InputHandlerManager class manages InputHandlerProxy instances for
 // the WebViews in this renderer.
 class InputHandlerManager {
  public:
   // |message_loop_proxy| is the MessageLoopProxy of the compositor thread. Both
   // the underlying MessageLoop and supplied |client| must outlive this object.
   InputHandlerManager(
       const scoped_refptr<base::MessageLoopProxy>& message_loop_proxy,
       InputHandlerManagerClient* client);
   ~InputHandlerManager();
 
   // Callable from the main thread only.
   void AddInputHandler(
       int routing_id,
       const base::WeakPtr<cc::InputHandler>& input_handler,
       const base::WeakPtr<RenderViewImpl>& render_view_impl);
 
+  // Callable from the main thread only. This takes ownership of rewriter and
+  // uses it later on compositor's thread.
+  void SetInputEventRewriter(int routing_id,
+                             scoped_ptr<InputEventRewriter> rewriter);
+
   // Callback only from the compositor's thread.
   void RemoveInputHandler(int routing_id);
 
   // Called from the compositor's thread.
   InputEventAckState HandleInputEvent(int routing_id,
                                       const WebKit::WebInputEvent* input_event,
                                       const ui::LatencyInfo& latency_info);
 
   // Called from the compositor's thread.
   void DidOverscroll(int routing_id, const cc::DidOverscrollParams& params);
 
  private:
   // Called from the compositor's thread.
   void AddInputHandlerOnCompositorThread(
       int routing_id,
       const scoped_refptr<base::MessageLoopProxy>& main_loop,
       const base::WeakPtr<cc::InputHandler>& input_handler,
       const base::WeakPtr<RenderViewImpl>& render_view_impl);
+  void SetInputEventRewriterOnCompositorThread(
+      int routing_id,
+      scoped_ptr<InputEventRewriter> rewriter);
 
   typedef std::map<int,  // routing_id
                    scoped_refptr<InputHandlerWrapper> > InputHandlerMap;
   InputHandlerMap input_handlers_;
 
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
   InputHandlerManagerClient* client_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_GPU_INPUT_HANDLER_MANAGER_H_