blimp: Use remote client LayerTreeHost in the BlimpCompositor.

blimp/client/feature/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_
 
 #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/feature/compositor/blimp_input_manager.h"
 #include "blimp/client/feature/render_widget_feature.h"
 #include "cc/layers/layer_settings.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 cc {
+namespace proto {
+class InitializeImpl;
+}
 class LayerTreeHost;
 }
 
 namespace blimp {
 
 class BlimpMessage;
 
 namespace client {
 
 // 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.
+// the LayerTreeHost.
 class BLIMP_CLIENT_EXPORT BlimpCompositor
     : public cc::LayerTreeHostClient,
       public cc::RemoteProtoChannel,
       public RenderWidgetFeature::RenderWidgetFeatureDelegate,
       public BlimpInputManagerClient {
  public:
   // |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.
   BlimpCompositor(float dp_to_px, RenderWidgetFeature* render_widget_feature);
 
   ~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:
   // Populates the cc::LayerTreeSettings used by the cc::LayerTreeHost.  Can be
   // overridden to provide custom settings parameters.
   virtual void GenerateLayerTreeSettings(cc::LayerTreeSettings* settings);
 
  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,
@@ skipping 16 matching lines @@
   void SendCompositorProto(const cc::proto::CompositorMessage& proto) override;
 
   // RenderWidgetFeatureDelegate implementation.
   void OnRenderWidgetInitialized() override;
   void OnCompositorMessageReceived(
       scoped_ptr<cc::proto::CompositorMessage> message) override;
 
   // BlimpInputManagerClient implementation.
   void SendWebInputEvent(const blink::WebInputEvent& input_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(scoped_ptr<cc::proto::CompositorMessage> message);
+  void CreateLayerTreeHost(
+      const cc::proto::InitializeImpl& initialize_message);
+
+  // 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();
   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_;
@@ skipping 27 matching lines @@
   // widget.
   scoped_ptr<BlimpInputManager> input_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(BlimpCompositor);
 };
 
 }  // namespace client
 }  // namespace blimp
 
 #endif  // BLIMP_CLIENT_FEATURE_COMPOSITOR_BLIMP_COMPOSITOR_H_