Add glue between the client and engine for Blimp

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/render_widget_message_processor.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 cc {
 class LayerTreeHost;
 }
 
 namespace blimp {
 
+class BlimpMessage;
+
 // BlimpCompositor provides the basic framework and setup to host a
 // LayerTreeHost (compositor).  The rendering surface this compositor draws to
-// is defined by the gfx::AcceleratedWidget returned by
-// BlimpCompositor::GetWindow().
-class BlimpCompositor : public cc::LayerTreeHostClient {
+// is defined by the gfx::AcceleratedWidget set by SetAcceleratedWidget().
+class BLIMP_CLIENT_EXPORT BlimpCompositor
+    : public cc::LayerTreeHostClient,
+      public cc::RemoteProtoChannel,
+      public RenderWidgetMessageProcessor::RenderWidgetMessageDelegate {
+
  public:
   ~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 it's 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);

[Khushal, 2015/11/19 19:28:24]

We would want to inform the engine of the visibility changes too.

Though I don't think we need to have the visibility status part of the
compositor protocol. The status will change on the client and any message we get
from the engine would probably be stale anyway.

[David Trainor- moved to gerrit, 2015/11/20 17:58:53]

Yeah we'll inform the engine via another route.  I'd almost rather let the
engine inform the local compositor via the compositor protocol.  I'll leave this
until we integrate the actual remote channel as right now this is a LTH.

[Khushal, 2015/11/23 17:40:11]

Right now the LTH expects you to make it invisible before you ask it to release
the output surface. If we also want to do too that then we'll have to inform the
impl side locally about the visibility change. We could try dropping that
condition for us and just ask it to release the surface.

We can decide on this.

+
+  // Sets the size of the viewport on the compositor.
+  // TODO(dtrainor): Should this be pulled 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.

[Khushal, 2015/11/19 19:28:24]

Is this for when we have multiple tabs?

I think when we design for multiple tabs, we will avoid this situation when we
move this to a higher layer. The blimp_view from which we get the input events
and the widget will be shared across tabs. So we could move the widget to this
layer that the view talks to and have the compositor get the output surface from
this layer. The layer would ensure that only the active compositor has the
output surface. It will ensure that it asks the active compositor to release the
surface before giving it to another compositor.

[David Trainor- moved to gerrit, 2015/11/20 17:58:53]

Yeah that's what we talked about, but since there's no higher level object built
in to manage tabs yet, that logic should go here (not in BlimpView).  When we
spin up the Linux client I don't want to duplicate any actual logic in
platform-specific code.

When we split out that higher level class we'll move that code from here to
there (as opposed to from BlimpView to there).  Since that class doesn't exist
yet it should just live in here.

ie:

Now:
BlimpView (Android) -> BlimpCompositor
SomeView  (Linux)   -> BlimpCompositor

Future:
- Keep BlimpView/SomeView the same (platform abstractions can be thin).
- Split BlimpCompositor instead.

BlimpView -> BlimpTabManager -> BlimpCompositor
SomeView  -> BlimpTabManager -> BlimpCompositor

[Khushal, 2015/11/23 17:40:11]

Makes sense.

+  void SetAcceleratedWidget(gfx::AcceleratedWidget widget);
+
+  // Releases the internally stored gfx::AcceleratedWidget and the associated
+  // output surface.  This should be called before calling
+  // SetAcceleratedWidget() with the same gfx::AcceleratedWidget on another
+  // compositor.
+  void ReleaseAcceleratedWidget();
+
+ protected:
+  // |dp_to_px| is the scale factor required to move from dp (device pixels) to
+  // px.
+  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);
+
+ private:
   // 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;
   void RecordFrameTimingEvents(
       scoped_ptr<cc::FrameTimingTracker::CompositeTimingSet> composite_events,
       scoped_ptr<cc::FrameTimingTracker::MainFrameTimingSet> main_frame_events)
       override;
 
- protected:
-  // |dp_to_px| is the scale factor required to move from dp (device pixels) to
-  // px.
-  explicit BlimpCompositor(float dp_to_px);
+  // RemoteProtoChannel implementation.
+  void SetProtoReceiver(ProtoReceiver* receiver) override;
+  void SendCompositorProto(const cc::proto::CompositorMessage& proto) override;
 
-  // Returns a widget for use in constructing this compositor's OutputSurface.
-  // Will only ever be called while this compositor is visible.
-  virtual gfx::AcceleratedWidget GetWindow() = 0;
+  // RenderWidgetMessageDelegate implementation.
+  void OnRenderWidgetInitialized() override;
+  void OnCompositorMessageReceived(
+      scoped_ptr<cc::proto::CompositorMessage> message) override;
 
-  // Populates the cc::LayerTreeSettings used by the cc::LayerTreeHost.  Can be
-  // overridden to provide custom settings parameters.
-  virtual void GenerateLayerTreeSettings(cc::LayerTreeSettings* settings);
+  // Helper method to build the internal CC compositor instance from |message|.
+  void CreateLayerTreeHost(scoped_ptr<cc::proto::CompositorMessage> message);
 
- private:
   // Creates (if necessary) and returns a TaskRunner for a thread meant to run
   // compositor rendering.
   scoped_refptr<base::SingleThreadTaskRunner> GetCompositorTaskRunner();
 
   gfx::Size viewport_size_;
 
   // The scale factor used to convert dp units (device independent pixels) to
   // pixels.
   float device_scale_factor_;
   scoped_ptr<cc::LayerTreeHost> host_;
   scoped_ptr<cc::LayerTreeSettings> settings_;
 
   // Lazily created thread that will run the compositor rendering tasks.
   scoped_ptr<base::Thread> compositor_thread_;
 
+  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_;
+
+  // 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_;
+
   DISALLOW_COPY_AND_ASSIGN(BlimpCompositor);
 };
 
 }  // namespace blimp
 
 #endif  // BLIMP_CLIENT_COMPOSITOR_BLIMP_COMPOSITOR_H_