X11: Use better visuals for OpenGL

ui/gl/gl_surface_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_surface_glx.h"
 
 extern "C" {
 #include <X11/Xlib.h>
 }
 #include <memory>
@@ skipping 11 matching lines @@
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/gfx/x/x11_connection.h"
 #include "ui/gfx/x/x11_types.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_visual_picker_glx.h"
 #include "ui/gl/sync_control_vsync_provider.h"
 
 namespace gl {
 
 namespace {
 
 Display* g_display = nullptr;
 bool g_glx_context_create = false;
 bool g_glx_create_context_robustness_supported = false;
 bool g_glx_create_context_profile_supported = false;
 bool g_glx_create_context_profile_es2_supported = false;
 bool g_glx_texture_from_pixmap_supported = false;
 bool g_glx_oml_sync_control_supported = false;
 
 // Track support of glXGetMscRateOML separately from GLX_OML_sync_control as a
 // whole since on some platforms (e.g. crosbug.com/34585), glXGetMscRateOML
 // always fails even though GLX_OML_sync_control is reported as being supported.
 bool g_glx_get_msc_rate_oml_supported = false;
 
 bool g_glx_sgi_video_sync_supported = false;
 
+// A 24-bit RGB visual and colormap to use when creating offscreen surfaces.
+Visual* g_visual = nullptr;
+int g_depth = CopyFromParent;
+Colormap g_colormap = CopyFromParent;
+
 GLXFBConfig GetConfigForWindow(Display* display,
                                gfx::AcceleratedWidget window) {
   DCHECK(window != 0);
 
   // This code path is expensive, but we only take it when
   // attempting to use GLX_ARB_create_context_robustness, in which
   // case we need a GLXFBConfig for the window in order to create a
   // context for it.
   //
   // TODO(kbr): this is not a reliable code path. On platforms which
@@ skipping 39 matching lines @@
   if (found) {
     return configs.get()[i];
   }
   return nullptr;
 }
 
 bool CreateDummyWindow(Display* display) {
   DCHECK(display);
   gfx::AcceleratedWidget parent_window =
       RootWindow(display, DefaultScreen(display));
-  // We create a window with CopyFromParent visual so that we have the same
-  // visual as NativeViewGLSurfaceGLX (i.e. same GLXFBConfig), to ensure
-  // contexts are compatible and can be made current with either.
   gfx::AcceleratedWidget window =
       XCreateWindow(display, parent_window, 0, 0, 1, 1, 0, CopyFromParent,
                     InputOutput, CopyFromParent, 0, nullptr);
   if (!window) {
     LOG(ERROR) << "XCreateWindow failed";
     return false;
   }
   GLXFBConfig config = GetConfigForWindow(display, window);
   GLXWindow glx_window = glXCreateWindow(display, config, window, nullptr);
   if (!glx_window) {
@@ skipping 290 matching lines @@
   g_glx_create_context_profile_supported =
       HasGLXExtension("GLX_ARB_create_context_profile");
   g_glx_create_context_profile_es2_supported =
       HasGLXExtension("GLX_ARB_create_context_es2_profile");
   g_glx_texture_from_pixmap_supported =
       HasGLXExtension("GLX_EXT_texture_from_pixmap");
   g_glx_oml_sync_control_supported = HasGLXExtension("GLX_OML_sync_control");
   g_glx_get_msc_rate_oml_supported = g_glx_oml_sync_control_supported;
   g_glx_sgi_video_sync_supported = HasGLXExtension("GLX_SGI_video_sync");
 
+  const XVisualInfo& visual_info =
+      gl::GLVisualPickerGLX::GetInstance()->system_visual();
+  g_visual = visual_info.visual;
+  g_depth = visual_info.depth;
+  g_colormap = XCreateColormap(g_display, DefaultRootWindow(g_display),
+                               visual_info.visual, AllocNone);
+
   // We create a dummy unmapped window for both the main Display and the video
   // sync Display so that the Nvidia driver can initialize itself before the
   // sandbox is set up.
   // Unfortunately some fds e.g. /dev/nvidia0 are cached per thread and because
   // we can't start threads before the sandbox is set up, these are accessed
   // through the broker process. See GpuProcessPolicy::InitGpuBrokerProcess.
   if (!CreateDummyWindow(g_display)) {
     LOG(ERROR) << "CreateDummyWindow(g_display) failed";
     return false;
   }
@@ skipping 51 matching lines @@
   return g_glx_oml_sync_control_supported;
 }
 
 void* GLSurfaceGLX::GetDisplay() {
   return g_display;
 }
 
 GLSurfaceGLX::~GLSurfaceGLX() {}
 
 NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX(gfx::AcceleratedWidget window)
-    : parent_window_(window), window_(0), glx_window_(0), config_(nullptr) {}
+    : parent_window_(window),
+      window_(0),
+      glx_window_(0),
+      config_(nullptr),
+      visual_id_(CopyFromParent) {}
 
 GLXDrawable NativeViewGLSurfaceGLX::GetDrawableHandle() const {
   return glx_window_;
 }
 
 bool NativeViewGLSurfaceGLX::Initialize(GLSurface::Format format) {
   XWindowAttributes attributes;
   if (!XGetWindowAttributes(g_display, parent_window_, &attributes)) {
     LOG(ERROR) << "XGetWindowAttributes failed for window " << parent_window_
                << ".";
     return false;
   }
   size_ = gfx::Size(attributes.width, attributes.height);
+  visual_id_ = XVisualIDFromVisual(attributes.visual);
   // Create a child window, with a CopyFromParent visual (to avoid inducing
   // extra blits in the driver), that we can resize exactly in Resize(),
   // correctly ordered with GL, so that we don't have invalid transient states.
   // See https://crbug.com/326995.
   XSetWindowAttributes swa;
   memset(&swa, 0, sizeof(swa));
   swa.background_pixmap = 0;
   swa.bit_gravity = NorthWestGravity;
   window_ = XCreateWindow(g_display, parent_window_, 0, 0, size_.width(),
                           size_.height(), 0, CopyFromParent, InputOutput,
@@ skipping 74 matching lines @@
 bool NativeViewGLSurfaceGLX::SupportsPostSubBuffer() {
   return g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer;
 }
 
 void* NativeViewGLSurfaceGLX::GetConfig() {
   if (!config_)
     config_ = GetConfigForWindow(g_display, window_);
   return config_;
 }
 
+unsigned long NativeViewGLSurfaceGLX::GetCompatibilityKey() {
+  return visual_id_;
+}
+
 gfx::SwapResult NativeViewGLSurfaceGLX::PostSubBuffer(int x,
                                                       int y,
                                                       int width,
                                                       int height) {
   DCHECK(g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer);
   glXCopySubBufferMESA(g_display, GetDrawableHandle(), x, y, width, height);
   return gfx::SwapResult::SWAP_ACK;
 }
 
 gfx::VSyncProvider* NativeViewGLSurfaceGLX::GetVSyncProvider() {
@@ skipping 20 matching lines @@
     const gfx::Size& size)
     : size_(size), config_(nullptr), window_(0), glx_window_(0) {
   // Ensure that we don't create a window with zero size.
   if (size_.GetArea() == 0)
     size_.SetSize(1, 1);
 }
 
 bool UnmappedNativeViewGLSurfaceGLX::Initialize(GLSurface::Format format) {
   DCHECK(!window_);
 
-  gfx::AcceleratedWidget parent_window =
-      RootWindow(g_display, DefaultScreen(g_display));
+  gfx::AcceleratedWidget parent_window = DefaultRootWindow(g_display);
 
-  // We create a window with CopyFromParent visual so that we have the same
-  // visual as NativeViewGLSurfaceGLX (i.e. same GLXFBConfig), to ensure
-  // contexts are compatible and can be made current with either.
+  XSetWindowAttributes attrs;
+  attrs.border_pixel = 0;
+  attrs.colormap = g_colormap;
   window_ = XCreateWindow(g_display, parent_window, 0, 0, size_.width(),
-                          size_.height(), 0, CopyFromParent, InputOutput,
-                          CopyFromParent, 0, nullptr);
+                          size_.height(), 0, g_depth, InputOutput, g_visual,
+                          CWBorderPixel | CWColormap, &attrs);
   GetConfig();
   DCHECK(config_);
   glx_window_ = glXCreateWindow(g_display, config_, window_, NULL);
   return window_ != 0;
 }
 
 void UnmappedNativeViewGLSurfaceGLX::Destroy() {
   config_ = nullptr;
   if (glx_window_) {
     glXDestroyWindow(g_display, glx_window_);
@@ skipping 21 matching lines @@
 void* UnmappedNativeViewGLSurfaceGLX::GetHandle() {
   return reinterpret_cast<void*>(glx_window_);
 }
 
 void* UnmappedNativeViewGLSurfaceGLX::GetConfig() {
   if (!config_)
     config_ = GetConfigForWindow(g_display, window_);
   return config_;
 }
 
+unsigned long UnmappedNativeViewGLSurfaceGLX::GetCompatibilityKey() {
+  return XVisualIDFromVisual(g_visual);
+}
+
 UnmappedNativeViewGLSurfaceGLX::~UnmappedNativeViewGLSurfaceGLX() {
   Destroy();
 }
 
 }  // namespace gl