Revert of GLContextGLX: try all GL versions from the highest.

ui/gl/gl_context_glx.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_context_glx.h"
 
 extern "C" {
 #include <X11/Xlib.h>
 }
 #include <memory>
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gl/GL/glextchromium.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_glx.h"
 
 namespace gfx {
 
-namespace {
-
-static int IgnoreX11Errors(Display*, XErrorEvent*) {
-  return 0;
-}
-
-using GLVersion = std::pair<int, int>;
-
-GLXContext CreateContextAttribs(Display* display,
-                                GLXFBConfig config,
-                                GLXContext share,
-                                GLVersion version,
-                                int profileMask) {
-  std::vector<int> attribs;
-
-  if (GLSurfaceGLX::IsCreateContextRobustnessSupported()) {
-    attribs.push_back(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB);
-    attribs.push_back(GLX_LOSE_CONTEXT_ON_RESET_ARB);
-  }
-
-  if (version.first != 0 || version.second != 0) {
-    attribs.push_back(GLX_CONTEXT_MAJOR_VERSION_ARB);
-    attribs.push_back(version.first);
-
-    attribs.push_back(GLX_CONTEXT_MINOR_VERSION_ARB);
-    attribs.push_back(version.second);
-  }
-
-  if (profileMask != 0 && GLSurfaceGLX::IsCreateContextProfileSupported()) {
-    attribs.push_back(GLX_CONTEXT_PROFILE_MASK_ARB);
-    attribs.push_back(profileMask);
-  }
-
-  attribs.push_back(0);
-
-  // When creating a context with glXCreateContextAttribsARB, a variety of X11
-  // errors can be generated. To prevent these errors from crashing our process,
-  // we simply ignore them and only look if the GLXContext was created.
-  auto oldErrorHandler = XSetErrorHandler(IgnoreX11Errors);
-  GLXContext context =
-      glXCreateContextAttribsARB(display, config, share, True, attribs.data());
-  XSetErrorHandler(oldErrorHandler);
-
-  return context;
-}
-
-GLXContext CreateHighestVersionContext(Display* display,
-                                       GLXFBConfig config,
-                                       GLXContext share) {
-  // It is commonly assumed that glXCreateContextAttrib will create a context
-  // of the highest version possible but it is not specified in the spec and
-  // is not true on the Mesa drivers. On Mesa, Instead we try to create a
-  // context per GL version until we succeed, starting from newer version.
-  // On both Mesa and other drivers we try to create a desktop context and fall
-  // back to ES context.
-  // The code could be simpler if the Mesa code path was used for all drivers,
-  // however the cost of failing a context creation can be high (3 milliseconds
-  // for the NVIDIA driver). The good thing is that failed context creation only
-  // takes 0.1 milliseconds on Mesa.
-
-  struct ContextCreationInfo {
-    int profileFlag;
-    GLVersion version;
-  };
-
-  // clang-format off
-  // For regular drivers we try to create a core, compatibility, then ES
-  // context. Without requiring any specific version.
-  const ContextCreationInfo contexts_to_try[] = {
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, GLVersion(0, 0) },
-      { 0, GLVersion(0, 0) },
-      { GLX_CONTEXT_ES2_PROFILE_BIT_EXT, GLVersion(0, 0) },
-  };
-
-  // On Mesa we try to create a core context, except for versions below 3.2
-  // where it is not applicable. (and fallback to ES as well)
-  const ContextCreationInfo mesa_contexts_to_try[] = {
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, { GLVersion(4, 5) } },
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, { GLVersion(4, 4) } },
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, { GLVersion(4, 3) } },
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, { GLVersion(4, 2) } },
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, { GLVersion(4, 1) } },
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, { GLVersion(4, 0) } },
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, { GLVersion(3, 3) } },
-      { GLX_CONTEXT_CORE_PROFILE_BIT_ARB, { GLVersion(3, 2) } },
-      { 0, { GLVersion(3, 1) } },
-      { 0, { GLVersion(3, 0) } },
-      { 0, { GLVersion(2, 0) } },
-      { 0, { GLVersion(1, 5) } },
-      { 0, { GLVersion(1, 4) } },
-      { 0, { GLVersion(1, 3) } },
-      { 0, { GLVersion(1, 2) } },
-      { 0, { GLVersion(1, 1) } },
-      { 0, { GLVersion(1, 0) } },
-      { GLX_CONTEXT_ES2_PROFILE_BIT_EXT, { GLVersion(3, 2) } },
-      { GLX_CONTEXT_ES2_PROFILE_BIT_EXT, { GLVersion(3, 1) } },
-      { GLX_CONTEXT_ES2_PROFILE_BIT_EXT, { GLVersion(3, 0) } },
-      { GLX_CONTEXT_ES2_PROFILE_BIT_EXT, { GLVersion(2, 0) } },
-  };
-  // clang-format on
-
-  std::string client_vendor = glXGetClientString(display, GLX_VENDOR);
-  bool is_mesa = client_vendor.find("Mesa") != std::string::npos;
-
-  const ContextCreationInfo* to_try = contexts_to_try;
-  size_t to_try_length = arraysize(contexts_to_try);
-  if (is_mesa) {
-    to_try = mesa_contexts_to_try;
-    to_try_length = arraysize(mesa_contexts_to_try);
-  }
-
-  for (size_t i = 0; i < to_try_length; ++i) {
-    const ContextCreationInfo& info = to_try[i];
-    if (!GLSurfaceGLX::IsCreateContextES2ProfileSupported() &&
-        info.profileFlag == GLX_CONTEXT_ES2_PROFILE_BIT_EXT) {
-      continue;
-    }
-    GLXContext context = CreateContextAttribs(display, config, share,
-                                              info.version, info.profileFlag);
-    if (context != nullptr) {
-      return context;
-    }
-  }
-
-  return nullptr;
-}
-}
-
 GLContextGLX::GLContextGLX(GLShareGroup* share_group)
   : GLContextReal(share_group),
     context_(nullptr),
     display_(nullptr) {
 }
 
 XDisplay* GLContextGLX::display() {
   return display_;
 }
 
 bool GLContextGLX::Initialize(
     GLSurface* compatible_surface, GpuPreference gpu_preference) {
   display_ = static_cast<XDisplay*>(compatible_surface->GetDisplay());
 
   GLXContext share_handle = static_cast<GLXContext>(
       share_group() ? share_group()->GetHandle() : nullptr);
 
   if (GLSurfaceGLX::IsCreateContextSupported()) {
     DVLOG(1) << "GLX_ARB_create_context supported.";
-    context_ = CreateHighestVersionContext(
-        display_, static_cast<GLXFBConfig>(compatible_surface->GetConfig()),
-        share_handle);
+    std::vector<int> attribs;
+    if (GLSurfaceGLX::IsCreateContextRobustnessSupported()) {
+      DVLOG(1) << "GLX_ARB_create_context_robustness supported.";
+      attribs.push_back(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB);
+      attribs.push_back(GLX_LOSE_CONTEXT_ON_RESET_ARB);
+    }
+    attribs.push_back(0);
+    context_ = glXCreateContextAttribsARB(
+        display_,
+        static_cast<GLXFBConfig>(compatible_surface->GetConfig()),
+        share_handle,
+        True,
+        &attribs.front());
     if (!context_) {
       LOG(ERROR) << "Failed to create GL context with "
                  << "glXCreateContextAttribsARB.";
       return false;
     }
   } else {
     DVLOG(1) << "GLX_ARB_create_context not supported.";
     context_ = glXCreateNewContext(
        display_,
        static_cast<GLXFBConfig>(compatible_surface->GetConfig()),
@@ skipping 131 matching lines @@
 
 bool GLContextGLX::WasAllocatedUsingRobustnessExtension() {
   return GLSurfaceGLX::IsCreateContextRobustnessSupported();
 }
 
 GLContextGLX::~GLContextGLX() {
   Destroy();
 }
 
 }  // namespace gfx