ui + mus: Split ContextFactory into ContextFactory(Client) and ContextFactoryPrivate

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 68 matching lines @@
   // Notifies that the ContextProvider returned from
   // ui::ContextFactory::SharedMainThreadContextProvider was lost.  When this
   // is called, the old resources (e.g. shared context, GL helper) still
   // exist, but are about to be destroyed. Getting a reference to those
   // resources from the ContextFactory (e.g. through
   // SharedMainThreadContextProvider()) will return newly recreated, valid
   // resources.
   virtual void OnLostResources() = 0;
 };
 
-// This class abstracts the creation of the 3D context for the compositor. It is
-// a global object.
-class COMPOSITOR_EXPORT ContextFactory {
+// This is privileged interface to the compositor. It is a global object.
+class COMPOSITOR_EXPORT ContextFactoryPrivate {
  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 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
-  // main thread.
-  virtual scoped_refptr<cc::ContextProvider>
-      SharedMainThreadContextProvider() = 0;
-
-  // Destroys per-compositor data.
-  virtual void RemoveCompositor(Compositor* compositor) = 0;
-
-  // When true, the factory uses test contexts that do not do real GL
-  // operations.
-  virtual bool DoesCreateTestContexts() = 0;
-
-  // Returns the OpenGL target to use for image textures.
-  virtual uint32_t GetImageTextureTarget(gfx::BufferFormat format,
-                                         gfx::BufferUsage usage) = 0;
-
-  // Gets the GPU memory buffer manager.
-  virtual gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() = 0;
-
-  // Gets the task graph runner.
-  virtual cc::TaskGraphRunner* GetTaskGraphRunner() = 0;
-
   // Allocate a new client ID for the display compositor.
   virtual cc::FrameSinkId AllocateFrameSinkId() = 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 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 BrowserCompositorCompositorFrameSink directly.
   virtual void SetDisplayVSyncParameters(ui::Compositor* compositor,
                                          base::TimeTicks timebase,
                                          base::TimeDelta interval) = 0;
 
   virtual void SetOutputIsSecure(Compositor* compositor, bool secure) = 0;
+};
+
+// 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 CreateCompositorFrameSink(
+      base::WeakPtr<Compositor> compositor) = 0;
+
+  // Return a reference to a shared offscreen context provider usable from the
+  // main thread.
+  virtual scoped_refptr<cc::ContextProvider>
+  SharedMainThreadContextProvider() = 0;
+
+  // Destroys per-compositor data.
+  virtual void RemoveCompositor(Compositor* compositor) = 0;
+
+  // When true, the factory uses test contexts that do not do real GL
+  // operations.
+  virtual bool DoesCreateTestContexts() = 0;
+
+  // Returns the OpenGL target to use for image textures.
+  virtual uint32_t GetImageTextureTarget(gfx::BufferFormat format,
+                                         gfx::BufferUsage usage) = 0;
+
+  // Gets the GPU memory buffer manager.
+  virtual gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() = 0;
+
+  // Gets the task graph runner.
+  virtual cc::TaskGraphRunner* GetTaskGraphRunner() = 0;
 
   virtual void AddObserver(ContextFactoryObserver* observer) = 0;
 
   virtual void RemoveObserver(ContextFactoryObserver* observer) = 0;
 };
 
 // This class represents a lock on the compositor, that can be used to prevent
 // commits to the compositor tree while we're waiting for an asynchronous
 // event. The typical use case is when waiting for a renderer to produce a frame
 // at the right size. The caller keeps a reference on this object, and drops the
@@ skipping 22 matching lines @@
 // Compositor object to take care of GPU painting.
 // A Browser compositor object is responsible for generating the final
 // displayable form of pixels comprising a single widget's contents. It draws an
 // appropriately transformed texture for each transformed view in the widget's
 // view hierarchy.
 class COMPOSITOR_EXPORT Compositor
     : NON_EXPORTED_BASE(public cc::LayerTreeHostClient),
       NON_EXPORTED_BASE(public cc::LayerTreeHostSingleThreadClient) {
  public:
   Compositor(ui::ContextFactory* context_factory,
+             ui::ContextFactoryPrivate* context_factory_private,
              scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~Compositor() override;
 
   ui::ContextFactory* context_factory() { return context_factory_; }
 
+  ui::ContextFactoryPrivate* context_factory_private() {
+    return context_factory_private_;
+  }
+
   void AddFrameSink(const cc::FrameSinkId& frame_sink_id);
   void RemoveFrameSink(const cc::FrameSinkId& frame_sink_id);
 
   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
@@ skipping 169 matching lines @@
 
   // Called by CompositorLock.
   void UnlockCompositor();
 
   // Called to release any pending CompositorLock
   void CancelCompositorLock();
 
   gfx::Size size_;
 
   ui::ContextFactory* context_factory_;
+  ui::ContextFactoryPrivate* context_factory_private_;
 
   // The root of the Layer tree drawn by this compositor.
   Layer* root_layer_;
 
   base::ObserverList<CompositorObserver, true> observer_list_;
   base::ObserverList<CompositorAnimationObserver> animation_observer_list_;
 
   gfx::AcceleratedWidget widget_;
 #if defined(USE_AURA)
   ui::Window* window_;
@@ skipping 24 matching lines @@
   gfx::ColorSpace color_space_;
 
   base::WeakPtrFactory<Compositor> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Compositor);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_COMPOSITOR_H_