Refactor GL surface format handling

ui/gl/gl_surface.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_GL_GL_SURFACE_H_
 #define UI_GL_GL_SURFACE_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "build/build_config.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/overlay_transform.h"
 #include "ui/gfx/swap_result.h"
 #include "ui/gl/gl_export.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_surface_format.h"
 
 namespace gfx {
 class VSyncProvider;
 }
 
 namespace ui {
 struct CARendererLayerParams;
 }
 
 namespace gl {
 
 class GLContext;
 
 // Encapsulates a surface that can be rendered to with GL, hiding platform
 // specific management.
 class GL_EXPORT GLSurface : public base::RefCounted<GLSurface> {
  public:
   GLSurface();
 
-  // Minimum bit depth of surface.
-  enum Format {
-    SURFACE_ARGB8888,
-    SURFACE_RGB565,
-    SURFACE_OSMESA_BGRA,
-    SURFACE_OSMESA_RGBA,
-    SURFACE_SURFACELESS,
-    SURFACE_DEFAULT = SURFACE_ARGB8888
-  };
+  // Non-virtual initialization, this always calls Initialize with a
+  // default GLSurfaceFormat. Subclasses should override the format-
+  // specific Initialize method below and interpret the default format
+  // as appropriate.
+  bool Initialize();
 
   // (Re)create the surface. TODO(apatrick): This is an ugly hack to allow the
   // EGL surface associated to be recreated without destroying the associated
   // context. The implementation of this function for other GLSurface derived
   // classes is in a pending changelist.
-  virtual bool Initialize();
-  virtual bool Initialize(GLSurface::Format format);
+  virtual bool Initialize(GLSurfaceFormat format);
 
   // Destroys the surface.
   virtual void Destroy() = 0;
 
   virtual bool Resize(const gfx::Size& size,
                       float scale_factor,
                       bool has_alpha);
 
   // Recreate the surface without changing the size.
   virtual bool Recreate();
@@ skipping 89 matching lines @@
   virtual void* GetDisplay();
 
   // Get the platfrom specific configuration for this surface, if available.
   virtual void* GetConfig();
 
   // Get the key corresponding to the set of GLSurfaces that can be made current
   // with this GLSurface.
   virtual unsigned long GetCompatibilityKey();
 
   // Get the GL pixel format of the surface, if available.
-  virtual GLSurface::Format GetFormat();
+  virtual GLSurfaceFormat GetFormat();
 
   // Get access to a helper providing time of recent refresh and period
   // of screen refresh. If unavailable, returns NULL.
   virtual gfx::VSyncProvider* GetVSyncProvider();
 
   // Schedule an overlay plane to be shown at swap time, or on the next
   // CommitOverlayPlanes call.
   // |z_order| specifies the stacking order of the plane relative to the
   // main framebuffer located at index 0. For the case where there is no
   // main framebuffer, overlays may be scheduled at 0, taking its place.
@@ skipping 49 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(GLSurface);
 };
 
 // Implementation of GLSurface that forwards all calls through to another
 // GLSurface.
 class GL_EXPORT GLSurfaceAdapter : public GLSurface {
  public:
   explicit GLSurfaceAdapter(GLSurface* surface);
 
-  bool Initialize(GLSurface::Format format) override;
+  bool Initialize(GLSurfaceFormat format) override;
   void Destroy() override;
   bool Resize(const gfx::Size& size,
               float scale_factor,
               bool has_alpha) override;
   bool Recreate() override;
   bool DeferDraws() override;
   bool IsOffscreen() override;
   gfx::SwapResult SwapBuffers() override;
   void SwapBuffersAsync(const SwapCompletionCallback& callback) override;
   gfx::SwapResult SwapBuffersWithDamage(int x,
@@ skipping 16 matching lines @@
   gfx::Size GetSize() override;
   void* GetHandle() override;
   unsigned int GetBackingFramebufferObject() override;
   bool OnMakeCurrent(GLContext* context) override;
   bool SetBackbufferAllocation(bool allocated) override;
   void SetFrontbufferAllocation(bool allocated) override;
   void* GetShareHandle() override;
   void* GetDisplay() override;
   void* GetConfig() override;
   unsigned long GetCompatibilityKey() override;
-  GLSurface::Format GetFormat() override;
+  GLSurfaceFormat GetFormat() override;
   gfx::VSyncProvider* GetVSyncProvider() override;
   bool ScheduleOverlayPlane(int z_order,
                             gfx::OverlayTransform transform,
                             GLImage* image,
                             const gfx::Rect& bounds_rect,
                             const gfx::RectF& crop_rect) override;
   bool IsSurfaceless() const override;
   bool FlipsVertically() const override;
   bool BuffersFlipped() const override;
 
   GLSurface* surface() const { return surface_.get(); }
 
  protected:
   ~GLSurfaceAdapter() override;
 
  private:
   scoped_refptr<GLSurface> surface_;
 
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceAdapter);
 };
 
 // Wraps GLSurface in scoped_refptr and tries to initializes it. Returns a
 // scoped_refptr containing the initialized GLSurface or nullptr if
 // initialization fails.
 GL_EXPORT scoped_refptr<GLSurface> InitializeGLSurface(
     scoped_refptr<GLSurface> surface);
 
+GL_EXPORT scoped_refptr<GLSurface> InitializeGLSurfaceWithFormat(
+    scoped_refptr<GLSurface> surface, GLSurfaceFormat format);
+
 }  // namespace gl
 
 #endif  // UI_GL_GL_SURFACE_H_