Fork cc::OutputSurface into cc::CompositorFrameSink.

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_CORE_COMPOSITOR_BLIMP_COMPOSITOR_H_
 #define BLIMP_CLIENT_CORE_COMPOSITOR_BLIMP_COMPOSITOR_H_
 
 #include <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "blimp/client/core/compositor/blimp_output_surface.h"
+#include "blimp/client/core/compositor/blimp_compositor_frame_sink_proxy.h"
 #include "blimp/client/core/input/blimp_input_manager.h"
 #include "blimp/client/public/compositor/compositor_dependencies.h"
 #include "cc/surfaces/surface_factory_client.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"
 
@@ skipping 51 matching lines @@
 // 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.
 // This class should only be accessed from the main thread.
 class BlimpCompositor : public cc::LayerTreeHostClient,
                         public cc::RemoteProtoChannel,
                         public BlimpInputManagerClient,
-                        public BlimpOutputSurfaceClient,
+                        public BlimpCompositorFrameSinkProxy,
                         public cc::SurfaceFactoryClient {
  public:
   BlimpCompositor(const int render_widget_id,
                   BlimpCompositorDependencies* compositor_dependencies,
                   BlimpCompositorClient* client);
 
   ~BlimpCompositor() override;
 
   virtual void SetVisible(bool visible);
 
@@ skipping 23 matching lines @@
   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 RequestNewCompositorFrameSink() override;
+  void DidInitializeCompositorFrameSink() override;
   // TODO(khushalsagar): Need to handle context initialization failures.
-  void DidFailToInitializeOutputSurface() override {}
+  void DidFailToInitializeCompositorFrameSink() 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;
 
-  // BlimpOutputSurfaceClient implementation.
-  void BindToOutputSurface(
-      base::WeakPtr<BlimpOutputSurface> output_surface) override;
+  // BlimpCompositorFrameSinkProxy implementation.
+  void BindToProxyClient(
+      base::WeakPtr<BlimpCompositorFrameSinkProxyClient> proxy_client) override;
   void SwapCompositorFrame(cc::CompositorFrame frame) override;
-  void UnbindOutputSurface() override;
+  void UnbindProxyClient() override;
 
   // SurfaceFactoryClient implementation.
   void ReturnResources(const cc::ReturnedResourceArray& resources) override;
   void SetBeginFrameSource(cc::BeginFrameSource* begin_frame_source) override {}
 
   // Called when the a ContextProvider has been created by the
-  // CompositorDependencies class.  If |host_| is waiting on an OutputSurface
-  // this will build one for it.
+  // CompositorDependencies class.  If |host_| is waiting on an
+  // CompositorFrameSink this will build one for it.
   void OnContextProvidersCreated(
       const scoped_refptr<cc::ContextProvider>& compositor_context_provider,
       const scoped_refptr<cc::ContextProvider>& worker_context_provider);
 
   // Helper method to get the embedder dependencies.
   CompositorDependencies* GetEmbedderDeps();
 
   // TODO(khushalsagar): Move all of this to the |DocumentView| or another
   // platform specific class. So we use the DelegatedFrameHostAndroid like the
   // RenderWidgetHostViewAndroid.
@@ skipping 14 matching lines @@
 
   // The unique identifier for the render widget for this compositor.
   const int render_widget_id_;
 
   BlimpCompositorClient* client_;
 
   BlimpCompositorDependencies* compositor_dependencies_;
 
   std::unique_ptr<cc::LayerTreeHostInterface> host_;
 
-  // The SurfaceFactory is bound to the lifetime of the BlimpOutputSurface. When
+  // The SurfaceFactory is bound to the lifetime of the |proxy_client_|. When
   // detached, the surface factory will be destroyed.
   std::unique_ptr<cc::SurfaceFactory> surface_factory_;
-  base::WeakPtr<BlimpOutputSurface> output_surface_;
+  base::WeakPtr<BlimpCompositorFrameSinkProxyClient> proxy_client_;
 
-  // Whether or not |host_| has asked for an output surface.
-  bool output_surface_request_pending_;
+  // Whether or not |host_| has asked for a new CompositorFrameSink.
+  bool compositor_frame_sink_request_pending_;
 
   // Data for the current frame.
   cc::SurfaceId surface_id_;
   gfx::Size current_surface_size_;
 
   base::ThreadChecker thread_checker_;
 
   // Surfaces related stuff and layer which holds the delegated content from the
   // compositor.
   std::unique_ptr<cc::SurfaceIdAllocator> surface_id_allocator_;
@@ skipping 23 matching lines @@
 
   base::WeakPtrFactory<BlimpCompositor> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BlimpCompositor);
 };
 
 }  // namespace client
 }  // namespace blimp
 
 #endif  // BLIMP_CLIENT_CORE_COMPOSITOR_BLIMP_COMPOSITOR_H_