Fix EGL configs with GLSurfaceOzoneSurfaceless.

ui/gl/gl_surface_ozone.cc

 // Copyright 2014 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 <stddef.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 37 matching lines @@
 }
 
 // Helper function for base::Bind to create callback to eglGetConfigAttrib.
 bool EglGetConfigAttribute(EGLDisplay display,
                            EGLConfig config,
                            int32_t attribute,
                            int32_t* value) {
   return eglGetConfigAttrib(display, config, attribute, value);
 }
 
+// Populates EglConfigCallbacks with appropriate callbacks.
+ui::EglConfigCallbacks GetEglConfigCallbacks(EGLDisplay display) {
+  ui::EglConfigCallbacks callbacks;
+  callbacks.choose_config = base::Bind(EglChooseConfig, display);
+  callbacks.get_config_attribute = base::Bind(EglGetConfigAttribute, display);
+  callbacks.get_last_error_string = base::Bind(&ui::GetLastEGLErrorString);
+  return callbacks;
+}
+
 void WaitForFence(EGLDisplay display, EGLSyncKHR fence) {
   eglClientWaitSyncKHR(display, fence, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
                        EGL_FOREVER_KHR);
 }
 
 // A thin wrapper around GLSurfaceEGL that owns the EGLNativeWindow.
 class GL_EXPORT GLSurfaceOzoneEGL : public NativeViewGLSurfaceEGL {
  public:
   GLSurfaceOzoneEGL(scoped_ptr<ui::SurfaceOzoneEGL> ozone_surface,
                     AcceleratedWidget widget);
@@ skipping 62 matching lines @@
                                              OverlayTransform transform,
                                              GLImage* image,
                                              const Rect& bounds_rect,
                                              const RectF& crop_rect) {
   return image->ScheduleOverlayPlane(widget_, z_order, transform, bounds_rect,
                                      crop_rect);
 }
 
 EGLConfig GLSurfaceOzoneEGL::GetConfig() {
   if (!config_) {
-    // Setup callbacks for configuring EGL on platform.
-    EGLDisplay display = GetDisplay();
-    ui::EglConfigCallbacks egl;
-    egl.choose_config = base::Bind(EglChooseConfig, display);
-    egl.get_config_attribute = base::Bind(EglGetConfigAttribute, display);
-    egl.get_last_error_string = base::Bind(&ui::GetLastEGLErrorString);
-
-    config_ = ozone_surface_->GetEGLSurfaceConfig(egl);
+    ui::EglConfigCallbacks callbacks = GetEglConfigCallbacks(GetDisplay());
+    config_ = ozone_surface_->GetEGLSurfaceConfig(callbacks);
   }
   if (config_)
     return config_;
   return NativeViewGLSurfaceEGL::GetConfig();
 }
 
 GLSurfaceOzoneEGL::~GLSurfaceOzoneEGL() {
   Destroy();  // The EGL surface must be destroyed before SurfaceOzone.
 }
 
@@ skipping 43 matching lines @@
   VSyncProvider* GetVSyncProvider() override;
   bool SupportsAsyncSwap() override;
   bool SupportsPostSubBuffer() override;
   gfx::SwapResult PostSubBuffer(int x, int y, int width, int height) override;
   void SwapBuffersAsync(const SwapCompletionCallback& callback) override;
   void PostSubBufferAsync(int x,
                           int y,
                           int width,
                           int height,
                           const SwapCompletionCallback& callback) override;
+  EGLConfig GetConfig() override;
 
  protected:
   struct PendingFrame {
     PendingFrame();
 
     bool ScheduleOverlayPlanes(gfx::AcceleratedWidget widget);
 
     bool ready;
     std::vector<GLSurfaceOverlay> overlays;
     SwapCompletionCallback callback;
@@ skipping 171 matching lines @@
 void GLSurfaceOzoneSurfaceless::PostSubBufferAsync(
     int x,
     int y,
     int width,
     int height,
     const SwapCompletionCallback& callback) {
   // The actual sub buffer handling is handled at higher layers.
   SwapBuffersAsync(callback);
 }
 
+EGLConfig GLSurfaceOzoneSurfaceless::GetConfig() {
+  if (!config_) {
+    ui::EglConfigCallbacks callbacks = GetEglConfigCallbacks(GetDisplay());
+    config_ = ozone_surface_->GetEGLSurfaceConfig(callbacks);
+  }
+  if (config_)
+    return config_;
+  return SurfacelessEGL::GetConfig();
+}
+
 GLSurfaceOzoneSurfaceless::~GLSurfaceOzoneSurfaceless() {
   Destroy();  // The EGL surface must be destroyed before SurfaceOzone.
 }
 
 void GLSurfaceOzoneSurfaceless::SubmitFrame() {
   DCHECK(!unsubmitted_frames_.empty());
 
   if (unsubmitted_frames_.front()->ready && !swap_buffers_pending_) {
     scoped_ptr<PendingFrame> frame(unsubmitted_frames_.front());
     unsubmitted_frames_.weak_erase(unsubmitted_frames_.begin());
@@ skipping 343 matching lines @@
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::OzonePlatform::GetInstance()
       ->GetSurfaceFactoryOzone()
       ->GetNativeDisplay();
 }
 
 }  // namespace gfx