Refactor GL surface format handling

ui/gl/gl_surface.cc

 // 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.
 
 #include "ui/gl/gl_surface.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_local.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gfx/swap_result.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_surface_format.h"
 #include "ui/gl/gl_switches.h"
 
 namespace gl {
 
 namespace {
 base::LazyInstance<base::ThreadLocalPointer<GLSurface> >::Leaky
     current_surface_ = LAZY_INSTANCE_INITIALIZER;
 }  // namespace
 
 GLSurface::GLSurface() {}
 
 bool GLSurface::Initialize() {
-  return Initialize(SURFACE_DEFAULT);
+  return Initialize(GLSurfaceFormat());
 }
 
-bool GLSurface::Initialize(GLSurface::Format format) {
+bool GLSurface::Initialize(GLSurfaceFormat format) {
   return true;
 }
 
 bool GLSurface::Resize(const gfx::Size& size,
                        float scale_factor,
                        bool has_alpha) {
   NOTIMPLEMENTED();
   return false;
 }
 
@@ skipping 82 matching lines @@
 
 void* GLSurface::GetConfig() {
   NOTIMPLEMENTED();
   return NULL;
 }
 
 unsigned long GLSurface::GetCompatibilityKey() {
   return 0;
 }
 
-GLSurface::Format GLSurface::GetFormat() {
+GLSurfaceFormat GLSurface::GetFormat() {
   NOTIMPLEMENTED();
-  return SURFACE_DEFAULT;
+  return GLSurfaceFormat();
 }
 
 gfx::VSyncProvider* GLSurface::GetVSyncProvider() {
   return NULL;
 }
 
 bool GLSurface::ScheduleOverlayPlane(int z_order,
                                      gfx::OverlayTransform transform,
                                      GLImage* image,
                                      const gfx::Rect& bounds_rect,
@@ skipping 48 matching lines @@
   delimited_name += " ";
 
   return extensions.find(delimited_name) != std::string::npos;
 }
 
 void GLSurface::OnSetSwapInterval(int interval) {
 }
 
 GLSurfaceAdapter::GLSurfaceAdapter(GLSurface* surface) : surface_(surface) {}
 
-bool GLSurfaceAdapter::Initialize(GLSurface::Format format) {
+bool GLSurfaceAdapter::Initialize(GLSurfaceFormat format) {
   return surface_->Initialize(format);
 }
 
 void GLSurfaceAdapter::Destroy() {
   surface_->Destroy();
 }
 
 bool GLSurfaceAdapter::Resize(const gfx::Size& size,
                               float scale_factor,
                               bool has_alpha) {
@@ skipping 102 matching lines @@
 }
 
 void* GLSurfaceAdapter::GetConfig() {
   return surface_->GetConfig();
 }
 
 unsigned long GLSurfaceAdapter::GetCompatibilityKey() {
   return surface_->GetCompatibilityKey();
 }
 
-GLSurface::Format GLSurfaceAdapter::GetFormat() {
+GLSurfaceFormat GLSurfaceAdapter::GetFormat() {
   return surface_->GetFormat();
 }
 
 gfx::VSyncProvider* GLSurfaceAdapter::GetVSyncProvider() {
   return surface_->GetVSyncProvider();
 }
 
 bool GLSurfaceAdapter::ScheduleOverlayPlane(int z_order,
                                             gfx::OverlayTransform transform,
                                             GLImage* image,
@@ skipping 10 matching lines @@
 bool GLSurfaceAdapter::FlipsVertically() const {
   return surface_->FlipsVertically();
 }
 
 bool GLSurfaceAdapter::BuffersFlipped() const {
   return surface_->BuffersFlipped();
 }
 
 GLSurfaceAdapter::~GLSurfaceAdapter() {}
 
-scoped_refptr<GLSurface> InitializeGLSurface(scoped_refptr<GLSurface> surface) {
-  if (!surface->Initialize())

[bajones, 2017/01/04 22:31:55]

Nit: This function doesn't actually need to change, right? Calling Initialize()
will use a "Default" surface format.

I think I'd prefer to either leave this call alone or get rid of the default
Initialize() call.

[klausw, 2017/01/05 00:55:13]

I needed a new Initialize..WithFormat, and I don't want two copies of the code,
so I changed the no-format version to call the new
WithFormat one to avoid things getting out of sync in the future.

I'm not sure what you mean by "default Initialize() call", it's being
called with a format argument.

+scoped_refptr<GLSurface> InitializeGLSurfaceWithFormat(
+    scoped_refptr<GLSurface> surface, GLSurfaceFormat format) {
+  if (!surface->Initialize(format))
     return nullptr;
   return surface;
 }
 
+scoped_refptr<GLSurface> InitializeGLSurface(scoped_refptr<GLSurface> surface) {
+  return InitializeGLSurfaceWithFormat(surface, GLSurfaceFormat());
+}
+
 GLSurface::CALayerInUseQuery::CALayerInUseQuery() = default;
 GLSurface::CALayerInUseQuery::CALayerInUseQuery(const CALayerInUseQuery&) =
     default;
 GLSurface::CALayerInUseQuery::~CALayerInUseQuery() = default;
 
 }  // namespace gl