Fork cc::OutputSurface into cc::CompositorFrameSink.

ui/compositor/compositor.h

 // Copyright (c) 2012 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 UI_COMPOSITOR_COMPOSITOR_H_
 #define UI_COMPOSITOR_COMPOSITOR_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 81 matching lines @@
 
 // This class abstracts the creation of the 3D context for the compositor. It is
 // a global object.
 class COMPOSITOR_EXPORT ContextFactory {
  public:
   virtual ~ContextFactory() {}
 
   // Creates an output surface for the given compositor. The factory may keep
   // per-compositor data (e.g. a shared context), that needs to be cleaned up
   // by calling RemoveCompositor when the compositor gets destroyed.
-  virtual void CreateOutputSurface(base::WeakPtr<Compositor> compositor) = 0;
+  virtual void CreateCompositorFrameSink(
+      base::WeakPtr<Compositor> compositor) = 0;
 
   // Creates a reflector that copies the content of the |mirrored_compositor|
   // onto |mirroring_layer|.
   virtual std::unique_ptr<Reflector> CreateReflector(
       Compositor* mirrored_compositor,
       Layer* mirroring_layer) = 0;
   // Removes the reflector, which stops the mirroring.
   virtual void RemoveReflector(Reflector* reflector) = 0;
 
   // Return a reference to a shared offscreen context provider usable from the
@@ skipping 22 matching lines @@
   virtual cc::TaskGraphRunner* GetTaskGraphRunner() = 0;
 
   // Allocate a new client ID for the display compositor.
   virtual uint32_t AllocateSurfaceClientId() = 0;
 
   // Gets the surface manager.
   virtual cc::SurfaceManager* GetSurfaceManager() = 0;
 
   // Inform the display corresponding to this compositor if it is visible. When
   // false it does not need to produce any frames. Visibility is reset for each
-  // call to CreateOutputSurface.
+  // call to CreateCompositorFrameSink.
   virtual void SetDisplayVisible(ui::Compositor* compositor, bool visible) = 0;
 
   // Resize the display corresponding to this compositor to a particular size.
   virtual void ResizeDisplay(ui::Compositor* compositor,
                              const gfx::Size& size) = 0;
 
   // Set the output color profile into which this compositor should render.
   virtual void SetDisplayColorSpace(ui::Compositor* compositor,
                                     const gfx::ColorSpace& color_space) = 0;
 
   virtual void SetAuthoritativeVSyncInterval(ui::Compositor* compositor,
                                              base::TimeDelta interval) = 0;
   // Mac path for transporting vsync parameters to the display.  Other platforms
-  // update it via the BrowserCompositorOutputSurface directly.
+  // update it via the BrowserCompositorCompositorFrameSink directly.
   virtual void SetDisplayVSyncParameters(ui::Compositor* compositor,
                                          base::TimeTicks timebase,
                                          base::TimeDelta interval) = 0;
 
   virtual void SetOutputIsSecure(Compositor* compositor, bool secure) = 0;
 
   virtual void AddObserver(ContextFactoryObserver* observer) = 0;
 
   virtual void RemoveObserver(ContextFactoryObserver* observer) = 0;
 };
@@ skipping 35 matching lines @@
  public:
   Compositor(ui::ContextFactory* context_factory,
              scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~Compositor() override;
 
   ui::ContextFactory* context_factory() { return context_factory_; }
 
   void AddSurfaceClient(uint32_t client_id);
   void RemoveSurfaceClient(uint32_t client_id);
 
-  void SetOutputSurface(std::unique_ptr<cc::OutputSurface> surface);
+  void SetCompositorFrameSink(std::unique_ptr<cc::CompositorFrameSink> surface);
 
   // Schedules a redraw of the layer tree associated with this compositor.
   void ScheduleDraw();
 
   // Sets the root of the layer tree drawn by this Compositor. The root layer
   // must have no parent. The compositor's root layer is reset if the root layer
   // is destroyed. NULL can be passed to reset the root layer, in which case the
   // compositor will stop drawing anything.
   // The Compositor does not own the root layer.
   const Layer* root_layer() const { return root_layer_; }
@@ skipping 51 matching lines @@
   bool ScrollLayerTo(int layer_id, const gfx::ScrollOffset& offset);
 
   // The "authoritative" vsync interval, if provided, will override interval
   // reported from 3D context. This is typically the value reported by a more
   // reliable source, e.g, the platform display configuration.
   // In the particular case of ChromeOS -- this is the value queried through
   // XRandR, which is more reliable than the value queried through the 3D
   // context.
   void SetAuthoritativeVSyncInterval(const base::TimeDelta& interval);
 
-  // Most platforms set their vsync info via BrowerCompositorOutputSurface's
+  // Most platforms set their vsync info via
+  // BrowerCompositorCompositorFrameSink's
   // OnUpdateVSyncParametersFromGpu, but Mac routes vsync info via the
   // browser compositor instead through this path.
   void SetDisplayVSyncParameters(base::TimeTicks timebase,
                                  base::TimeDelta interval);
 
   // Sets the widget for the compositor to render into.
   void SetAcceleratedWidget(gfx::AcceleratedWidget widget);
   // Releases the widget previously set through SetAcceleratedWidget().
   // After returning it will not be used for rendering anymore.
   // The compositor must be set to invisible when taking away a widget.
@@ skipping 52 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 DidFailToInitializeOutputSurface() override;
+  void RequestNewCompositorFrameSink() override;
+  void DidInitializeCompositorFrameSink() override;
+  void DidFailToInitializeCompositorFrameSink() override;
   void WillCommit() override {}
   void DidCommit() override;
   void DidCommitAndDrawFrame() override;
   void DidCompleteSwapBuffers() override;
   void DidCompletePageScaleAnimation() override {}
 
   // cc::LayerTreeHostSingleThreadClient implementation.
   void DidPostSwapBuffers() override;
   void DidAbortSwapBuffers() override;
 
@@ skipping 33 matching lines @@
   base::ObserverList<CompositorObserver, true> observer_list_;
   base::ObserverList<CompositorAnimationObserver> animation_observer_list_;
 
   gfx::AcceleratedWidget widget_;
 #if defined(USE_AURA)
   ui::Window* window_;
 #endif
   // A map from child id to parent id.
   std::unordered_map<uint32_t, uint32_t> surface_clients_;
   bool widget_valid_;
-  bool output_surface_requested_;
+  bool compositor_frame_sink_requested_;
   std::unique_ptr<cc::SurfaceIdAllocator> surface_id_allocator_;
   scoped_refptr<cc::Layer> root_web_layer_;
   std::unique_ptr<cc::LayerTreeHost> host_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   // The manager of vsync parameters for this compositor.
   scoped_refptr<CompositorVSyncManager> vsync_manager_;
 
   // The device scale factor of the monitor that this compositor is compositing
   // layers on.
   float device_scale_factor_;
 
   bool locks_will_time_out_;
   CompositorLock* compositor_lock_;
 
   LayerAnimatorCollection layer_animator_collection_;
   scoped_refptr<cc::AnimationTimeline> animation_timeline_;
 
   gfx::ColorSpace color_space_;
 
   base::WeakPtrFactory<Compositor> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Compositor);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_COMPOSITOR_H_