blimp: Move compositing, input and render widget feature to client/core.

blimp/client/core/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_FEATURE_COMPOSITOR_BLIMP_COMPOSITOR_H_
-#define BLIMP_CLIENT_FEATURE_COMPOSITOR_BLIMP_COMPOSITOR_H_
+#ifndef BLIMP_CLIENT_CORE_COMPOSITOR_BLIMP_COMPOSITOR_H_
+#define BLIMP_CLIENT_CORE_COMPOSITOR_BLIMP_COMPOSITOR_H_
 
 #include <memory>
 #include <vector>
 
+#include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "blimp/client/feature/compositor/blimp_input_manager.h"
+#include "blimp/client/core/compositor/blob_image_serialization_processor.h"
+#include "blimp/client/core/input/blimp_input_manager.h"
 #include "cc/trees/layer_tree_host.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;
-}
+}  // namespace base
 
 namespace cc {
 namespace proto {
 class CompositorMessage;
 class InitializeImpl;
-}
+}  // namespace proto
+
+class ImageSerializationProcessor;
 class LayerTreeHost;
-}
+class LayerTreeSettings;
+class TaskGraphRunner;
+}  // namespace cc
+
+namespace gpu {
+class GpuMemoryBufferManager;
+}  // namespace gpu
 
 namespace blimp {
 
 class BlimpMessage;
 
 namespace client {
+class BlimpInputManager;
 
 // The BlimpCompositorClient provides the BlimpCompositor with the necessary
-// dependencies for cc::LayerTreeHost owned by this compositor and for
-// communicating the compositor and input messages to the corresponding
-// render widget of this compositor on the engine.
+// dependencies for communicating the compositor and input messages to the
+// corresponding render widget of this compositor on the engine.
 class BlimpCompositorClient {
  public:
-  // These methods should provide the dependencies for cc::LayerTreeHost for
-  // this compositor.
-  virtual cc::LayerTreeSettings* GetLayerTreeSettings() = 0;
-  virtual scoped_refptr<base::SingleThreadTaskRunner>
-  GetCompositorTaskRunner() = 0;
-  virtual cc::TaskGraphRunner* GetTaskGraphRunner() = 0;
-  virtual gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() = 0;
-  virtual cc::ImageSerializationProcessor* GetImageSerializationProcessor() = 0;
+  virtual ~BlimpCompositorClient() {}
+
   virtual void DidCompleteSwapBuffers() = 0;
+
+  // Called when a compositor frame update from the engine is committed.
+  // TODO(khushalsagar): Don't listen to commits directly once a remote
+  // compositor is used. This method is used for tracking the number of frame
+  // updates from the engine, don't want to mix that with local commits.
   virtual void DidCommitAndDrawFrame() = 0;
 
   // Should send web gesture events which could not be handled locally by the
   // compositor to the engine.
   virtual void SendWebGestureEvent(
-      int render_widget_id,
       const blink::WebGestureEvent& gesture_event) = 0;
 
   // Should send the compositor messages from the remote client LayerTreeHost of
   // this compositor to the corresponding remote server LayerTreeHost.
   virtual void SendCompositorMessage(
-      int render_widget_id,
       const cc::proto::CompositorMessage& message) = 0;
 
- protected:
-  virtual ~BlimpCompositorClient() {}
+  virtual void RequestOutputSurface() = 0;
 };
 
 // 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.
 //
 // The Blimp compositor owns the remote client cc::LayerTreeHost, which performs
 // the compositing work for the remote server LayerTreeHost. The server
 // LayerTreeHost for a BlimpCompositor is owned by the
 // content::RenderWidgetCompositor. Thus, each BlimpCompositor is tied to a
 // RenderWidget, identified by a custom |render_widget_id| generated on the
 // engine. The lifetime of this compositor is controlled by its corresponding
 // RenderWidget.
-class BlimpCompositor
-    : public cc::LayerTreeHostClient,
-      public cc::RemoteProtoChannel,
-      public BlimpInputManagerClient {
+class BlimpCompositor : public cc::LayerTreeHostClient,
+                        public cc::RemoteProtoChannel,
+                        public BlimpInputManagerClient {
  public:
-  BlimpCompositor(const int render_widget_id, BlimpCompositorClient* client);
+  BlimpCompositor(
+      cc::TaskGraphRunner* task_graph_runner,
+      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+      cc::ImageSerializationProcessor* image_serialization_processor,
+      cc::LayerTreeSettings* settings,
+      scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
+      BlimpCompositorClient* client);
 
   ~BlimpCompositor() override;
 
-  // 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).
-  // virtual for testing.
-  virtual void SetVisible(bool visible);
+  void SetVisible(bool visible);
+  bool IsVisible() const;
 
-  // 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.
-  // virtual for testing.
-  virtual void SetAcceleratedWidget(gfx::AcceleratedWidget widget);
+  void SetOutputSurface(std::unique_ptr<cc::OutputSurface> output_surface);
+  void ReleaseOutputSurface();
 
-  // 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.
-  // virtual for testing.
-  virtual void ReleaseAcceleratedWidget();
-
-  // Forwards the touch event to the |input_manager_|.
-  // virtual for testing.
-  virtual bool OnTouchEvent(const ui::MotionEvent& motion_event);
+  BlimpInputManager* input_manager() const { return input_manager_.get(); }
 
   // Called to forward the compositor message from the remote server
   // LayerTreeHost of the render widget for this compositor.
   // virtual for testing.
   virtual void OnCompositorMessageReceived(
       std::unique_ptr<cc::proto::CompositorMessage> message);
 
-  int render_widget_id() const { return render_widget_id_; }
+  cc::LayerTreeHost* GetHostForTesting() const { return host_.get(); }
 
  private:
-  friend class BlimpCompositorForTesting;
-
   // LayerTreeHostClient implementation.
   void WillBeginMainFrame() override;
   void DidBeginMainFrame() override;
   void BeginMainFrame(const cc::BeginFrameArgs& args) override;
   void BeginMainFrameNotExpectedSoon() override;
   void UpdateLayerTreeHost() override;
   void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
                            const gfx::Vector2dF& outer_delta,
                            const gfx::Vector2dF& elastic_overscroll_delta,
                            float page_scale,
                            float top_controls_delta) override;
   void RequestNewOutputSurface() override;
   void DidInitializeOutputSurface() override;
   void DidFailToInitializeOutputSurface() override;
   void WillCommit() override;
   void DidCommit() override;
   void DidCommitAndDrawFrame() override;
   void DidCompleteSwapBuffers() override;
   void DidCompletePageScaleAnimation() override;
 
   // RemoteProtoChannel implementation.
   void SetProtoReceiver(ProtoReceiver* receiver) override;
   void SendCompositorProto(const cc::proto::CompositorMessage& proto) override;
 
   // BlimpInputManagerClient implementation.
   void SendWebGestureEvent(
       const blink::WebGestureEvent& gesture_event) override;
 
-  // Internal method to correctly set the visibility on the |host_|. It will
-  // make the |host_| visible if |visible| is true and we have a valid |window_|
-  // If |visible_| is false, the host will also release its output surface.
-  void SetVisibleInternal(bool visible);
-
-  // Helper method to build the internal CC compositor instance from |message|.
-  void CreateLayerTreeHost(
-      const cc::proto::InitializeImpl& initialize_message);
+  // Helper method to build the internal CC compositor .
+  void CreateLayerTreeHost();
 
   // Helper method to destroy the internal CC compositor instance and all its
   // associated state.
   void DestroyLayerTreeHost();
 
-  // Creates (if necessary) and returns a TaskRunner for a thread meant to run
-  // compositor rendering.
-  void HandlePendingOutputSurfaceRequest();
-
-  // The unique identifier for the render widget for this compositor.
-  const int render_widget_id_;
-
+  cc::TaskGraphRunner* task_graph_runner_;

[nyquist, 2016/08/12 07:34:28]

It is possible to add comments for these for laymen like me? I think it'd be
helpful once they're first there.

[Khushal, 2016/08/13 00:03:22]

Good idea. Done.

+  gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
+  cc::ImageSerializationProcessor* image_serialization_processor_;
+  cc::LayerTreeSettings* settings_;
+  scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
   BlimpCompositorClient* client_;
 
   std::unique_ptr<cc::LayerTreeHost> host_;
-
-  gfx::AcceleratedWidget window_;
-
-  // Whether or not |host_| should be visible.  This is stored in case |host_|
-  // is null when SetVisible() is called or if we don't have a
-  // gfx::AcceleratedWidget to build an output surface from.
   bool host_should_be_visible_;
 
-  // Whether there is an OutputSurface request pending from the current
-  // |host_|. Becomes |true| if RequestNewOutputSurface is called, and |false|
-  // if |host_| is deleted or we succeed in creating *and* initializing an
-  // OutputSurface (which is essentially the contract with cc).
-  bool output_surface_request_pending_;
-
   // To be notified of any incoming compositor protos that are specifically sent
   // to |render_widget_id_|.
   cc::RemoteProtoChannel::ProtoReceiver* remote_proto_channel_receiver_;
 
   // 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.
+  // TODO(khushalsagar): Move this out to the render widget once the cc/blimp
+  // refactor work is done.
   std::unique_ptr<BlimpInputManager> input_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(BlimpCompositor);
 };
 
 }  // namespace client
 }  // namespace blimp
 
-#endif  // BLIMP_CLIENT_FEATURE_COMPOSITOR_BLIMP_COMPOSITOR_H_
+#endif  // BLIMP_CLIENT_CORE_COMPOSITOR_BLIMP_COMPOSITOR_H_