blimp: Add support for input handling

blimp/client/compositor/blimp_compositor.h

 // Copyright 2015 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 BLIMP_CLIENT_COMPOSITOR_BLIMP_COMPOSITOR_H_
 #define BLIMP_CLIENT_COMPOSITOR_BLIMP_COMPOSITOR_H_
 
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "blimp/client/blimp_client_export.h"
 #include "blimp/client/compositor/render_widget_message_processor.h"
+#include "blimp/client/input/blimp_input_manager.h"
 #include "cc/layers/layer_settings.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "cc/trees/remote_proto_channel.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/native_widget_types.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 class Thread;
@@ skipping 10 matching lines @@
 // BlimpCompositor provides the basic framework and setup to host a
 // LayerTreeHost.  The class that owns the LayerTreeHost is usually called the
 // compositor, but the LayerTreeHost does the compositing work.  The rendering
 // surface this compositor draws to is defined by the gfx::AcceleratedWidget set
 // by SetAcceleratedWidget().  This class should only be accessed from the main
 // thread.  Any interaction with the compositing thread should happen through
 // the LayerTreeHost or RemoteChannelImpl.
 class BLIMP_CLIENT_EXPORT BlimpCompositor
     : public cc::LayerTreeHostClient,
       public cc::RemoteProtoChannel,
-      public RenderWidgetMessageProcessor::RenderWidgetMessageDelegate {
-
+      public RenderWidgetMessageProcessor::RenderWidgetMessageDelegate,
+      public BlimpInputManagerClient {
  public:
   ~BlimpCompositor() override;
 
   // Default layer settings for all Blimp layer instances.
   static cc::LayerSettings LayerSettings();
 
   // Sets whether or not this compositor actually draws to the output surface.
   // Setting this to false will make the compositor drop all of its resources
   // and the output surface.  Setting it to true again will rebuild the output
   // surface from the gfx::AcceleratedWidget (see SetAcceleratedWidget).
   void SetVisible(bool visible);
 
   // Sets the size of the viewport on the compositor.
   // TODO(dtrainor): Should this be set from the engine all the time?
   void SetSize(const gfx::Size& size);
 
   // Lets this compositor know that it can draw to |widget|.  This means that,
   // if this compositor is visible, it will build an output surface and GL
   // context around |widget| and will draw to it.  ReleaseAcceleratedWidget()
   // *must* be called before SetAcceleratedWidget() is called with the same
   // gfx::AcceleratedWidget on another compositor.
   void SetAcceleratedWidget(gfx::AcceleratedWidget widget);
 
   // Releases the internally stored gfx::AcceleratedWidget and the associated
   // output surface.  This must be called before calling
   // SetAcceleratedWidget() with the same gfx::AcceleratedWidget on another
   // compositor.
   void ReleaseAcceleratedWidget();
 
+  // Forwards the touch event to the |input_manager_|.
+  bool OnTouchEvent(const ui::MotionEvent& motion_event);
+
  protected:
   // |dp_to_px| is the scale factor required to move from dp (device pixels) to
   // px.  See https://developer.android.com/guide/practices/screens_support.html
   // for more details.
   explicit BlimpCompositor(float dp_to_px);
 
   // Populates the cc::LayerTreeSettings used by the cc::LayerTreeHost.  Can be
   // overridden to provide custom settings parameters.
   virtual void GenerateLayerTreeSettings(cc::LayerTreeSettings* settings);
 
@@ skipping 24 matching lines @@
 
   // RemoteProtoChannel implementation.
   void SetProtoReceiver(ProtoReceiver* receiver) override;
   void SendCompositorProto(const cc::proto::CompositorMessage& proto) override;
 
   // RenderWidgetMessageDelegate implementation.
   void OnRenderWidgetInitialized() override;
   void OnCompositorMessageReceived(
       scoped_ptr<cc::proto::CompositorMessage> message) override;
 
+  // BlimpInputManagerClient implementation.
+  void SendWebInputEvent(const blink::WebInputEvent& input_event) override;
+
   // Helper method to build the internal CC compositor instance from |message|.
   void CreateLayerTreeHost(scoped_ptr<cc::proto::CompositorMessage> message);
 
   // Creates (if necessary) and returns a TaskRunner for a thread meant to run
   // compositor rendering.
   void HandlePendingOutputSurfaceRequest();
   scoped_refptr<base::SingleThreadTaskRunner> GetCompositorTaskRunner();
 
   gfx::Size viewport_size_;
 
@@ skipping 21 matching lines @@
 
   // To be notified of any incoming compositor protos that are specifically sent
   // to |render_widget_id_|.
   cc::RemoteProtoChannel::ProtoReceiver* remote_proto_channel_receiver_;
 
   // The bridge to the network layer that does the proto/RenderWidget id work.
   // TODO(dtrainor): Move this to a higher level once we start dealing with
   // multiple tabs.
   RenderWidgetMessageProcessor render_widget_processor_;
 
+  // Handles input events for the current render widget. The lifetime of the
+  // input manager is tied to the lifetime of the |host_| which owns the
+  // cc::InputHandler. The input events are forwarded to this input handler by
+  // the manager to be handled by the client compositor for the current render
+  // widget.
+  scoped_ptr<BlimpInputManager> input_manager_;
+
   DISALLOW_COPY_AND_ASSIGN(BlimpCompositor);
 };
 
 }  // namespace blimp
 
 #endif  // BLIMP_CLIENT_COMPOSITOR_BLIMP_COMPOSITOR_H_