Fix EGL configs with GLSurfaceOzoneSurfaceless.

ui/gl/gl_surface_egl.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_egl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 233 matching lines @@
                << GetLastEGLErrorString();
     return false;
   }
   if (*num_configs == 0) {
     LOG(ERROR) << "No suitable EGL configs found.";
     return false;
   }
   return true;
 }
 
-EGLConfig ChooseConfig(GLSurface::Format format) {
-  static std::map<GLSurface::Format, EGLConfig> config_map;
+EGLConfig ChooseConfig(GLSurface::Format format, bool is_surfaceless) {
+  static std::map<std::pair<GLSurface::Format, bool>, EGLConfig> config_map;

[no sievers, 2016/03/08 22:02:00]

It seems odd that surfaceless even cares about |Format|.
We could also add a FORMAT_SURFACELESS or something for Format instead. wdyt?

[kylechar, 2016/03/09 15:07:30]

This is all sort of black magic to me (and documentation is very sparse). The
EGL config for surfaceless GLSurfaces gets used when creating a context. It
would sort of make sense that EGL config ARGB should match the match whatever
framebuffer object the context is going to be rendering into, so maybe
GLSurface::Format does matter?

On the other hand maybe I'm just totally misunderstanding things here? The only
place SURFACE_RGB565 is actually ever set is with PbufferGLSurfaceEGL.

https://code.google.com/p/chromium/codesearch#chromium/src/ui/gl/gl_surface_e...

That means it can't matter for surfaceless (or it does matter but all
surfaceless contexts are drawing into ARGB8888 framebuffers?) I guess adding a
new format SURFACE_SURFACELESS should work.

 
-  if (config_map.find(format) != config_map.end()) {
-    return config_map[format];
+  auto config_type = std::make_pair(format, is_surfaceless);
+  if (config_map.find(config_type) != config_map.end()) {
+    return config_map[config_type];
   }
 
   // Choose an EGL configuration.
   // On X this is only used for PBuffer surfaces.
   EGLint renderable_type = EGL_OPENGL_ES2_BIT;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableUnsafeES3APIs)) {
     renderable_type = EGL_OPENGL_ES3_BIT;
   }
 
   EGLint buffer_size = 32;
   EGLint alpha_size = 8;
 
 #if defined(USE_X11) && !defined(OS_CHROMEOS)
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kWindowDepth)) {
     std::string depth =
         base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             switches::kWindowDepth);
 
     bool succeed = base::StringToInt(depth, &buffer_size);
     DCHECK(succeed);
 
     alpha_size = buffer_size == 32 ? 8 : 0;
   }
 #endif
 
+  EGLint surface_type =
+      is_surfaceless ? EGL_DONT_CARE : EGL_WINDOW_BIT | EGL_PBUFFER_BIT;
+
   EGLint config_attribs_8888[] = {
     EGL_BUFFER_SIZE, buffer_size,
     EGL_ALPHA_SIZE, alpha_size,
     EGL_BLUE_SIZE, 8,
     EGL_GREEN_SIZE, 8,
     EGL_RED_SIZE, 8,
     EGL_RENDERABLE_TYPE, renderable_type,
-    EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
+    EGL_SURFACE_TYPE, surface_type,
     EGL_NONE
   };
 
   EGLint* choose_attributes = config_attribs_8888;
   EGLint config_attribs_565[] = {
     EGL_BUFFER_SIZE, 16,
     EGL_BLUE_SIZE, 5,
     EGL_GREEN_SIZE, 6,
     EGL_RED_SIZE, 5,
     EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
-    EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
+    EGL_SURFACE_TYPE, surface_type,
     EGL_NONE
   };
   if (format == GLSurface::SURFACE_RGB565) {
     choose_attributes = config_attribs_565;
   }
 
   EGLint num_configs;
   EGLint config_size = 1;
   EGLConfig config = nullptr;
   EGLConfig* config_data = &config;
@@ skipping 52 matching lines @@
                            config_attribs_8888,
                            &config,
                            1,
                            &num_configs)) {
         LOG(ERROR) << "eglChooseConfig failed with error "
                    << GetLastEGLErrorString();
         return config;
       }
     }
   }
-  config_map[format] = config;
+  config_map[config_type] = config;
   return config;
 }
 
 }  // namespace
 
 void GetEGLInitDisplays(bool supports_angle_d3d,
                         bool supports_angle_opengl,
                         const base::CommandLine* command_line,
                         std::vector<DisplayType>* init_displays) {
   // SwiftShader does not use the platform extensions
@@ skipping 111 matching lines @@
 
   return true;
 }
 
 EGLDisplay GLSurfaceEGL::GetDisplay() {
   return g_display;
 }
 
 EGLConfig GLSurfaceEGL::GetConfig() {
   if (!config_) {
-    config_ = ChooseConfig(format_);
+    config_ = ChooseConfig(format_, IsSurfaceless());
   }
   return config_;
 }
 
 EGLDisplay GLSurfaceEGL::GetHardwareDisplay() {
   return g_display;
 }
 
 EGLNativeDisplayType GLSurfaceEGL::GetNativeDisplay() {
   return g_native_display;
@@ skipping 587 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gfx