X11: Use better visuals for OpenGL

ui/gl/gl_visual_picker_glx.cc

+// Copyright 2016 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_visual_picker_glx.h"
+
+#include <algorithm>
+#include <numeric>
+#include <vector>
+
+#include "base/memory/singleton.h"
+#include "ui/gfx/x/x11_types.h"
+#include "ui/gl/gl_bindings.h"
+#include "ui/gl/gl_context.h"
+#include "ui/gl/gl_surface_glx.h"
+
+namespace gl {
+
+namespace {
+
+bool IsRgbaVisual(const XVisualInfo& visual) {

[Julien Isorce Samsung, 2016/09/28 17:42:51]

argb ?

[Tom (Use chromium acct), 2016/09/28 18:36:01]

Done.

+  return visual.depth == 32 && visual.red_mask == 0xff0000 &&
+         visual.green_mask == 0x00ff00 && visual.blue_mask == 0x0000ff;
+}
+
+}  // anonymous namespace
+
+// static
+GLVisualPickerGLX* GLVisualPickerGLX::GetInstance() {
+  return base::Singleton<GLVisualPickerGLX>::get();
+}
+
+XVisualInfo GLVisualPickerGLX::PickBestGlVisual(
+    const std::vector<XVisualInfo>& visuals,
+    bool want_alpha) const {
+  // Find the highest scoring visual and return it.
+  Visual* default_visual = DefaultVisual(display_, DefaultScreen(display_));
+  int highest_score = -1;
+  XVisualInfo best_visual{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  for (const XVisualInfo& const_visual_info : visuals) {
+    int supports_gl, double_buffer, stereo, alpha_size, depth_size,
+        stencil_size, num_multisample, visual_caveat;
+    // glXGetConfig unfortunately doesn't use const.
+    XVisualInfo* visual_info = const_cast<XVisualInfo*>(&const_visual_info);
+    if (glXGetConfig(display_, visual_info, GLX_USE_GL, &supports_gl) ||
+        !supports_gl ||
+        glXGetConfig(display_, visual_info, GLX_DOUBLEBUFFER, &double_buffer) ||
+        !double_buffer ||
+        glXGetConfig(display_, visual_info, GLX_STEREO, &stereo) || stereo) {
+      continue;
+    }
+    if (has_glx_visual_rating_) {
+      if (glXGetConfig(display_, visual_info, GLX_VISUAL_CAVEAT_EXT,
+                       &visual_caveat) ||
+          visual_caveat != GLX_NONE_EXT) {
+        continue;
+      }
+    }
+
+    // Give precedence to the root visual if it satisfies the basic requirements
+    // above.  This can avoid an expensive copy-on-present.
+    if (const_visual_info.visual == default_visual)
+      return const_visual_info;
+
+    int score = 0;
+    if (!has_glx_multisample_ ||
+        (!glXGetConfig(display_, visual_info, GLX_SAMPLE_BUFFERS_ARB,
+                       &num_multisample) &&
+         num_multisample == 0)) {
+      score++;
+      if (!glXGetConfig(display_, visual_info, GLX_DEPTH_SIZE, &depth_size) &&
+          depth_size == 0 &&
+          !glXGetConfig(display_, visual_info, GLX_STENCIL_SIZE,
+                        &stencil_size) &&
+          stencil_size == 0) {
+        score++;
+        if (!glXGetConfig(display_, visual_info, GLX_ALPHA_SIZE, &alpha_size) &&
+            (alpha_size > 0) == want_alpha) {
+          score++;
+        }
+      }
+    }
+
+    if (score > highest_score) {
+      highest_score = score;
+      best_visual = const_visual_info;
+    }
+  }
+  return best_visual;
+}
+
+XVisualInfo GLVisualPickerGLX::PickBestSystemVisual(
+    const std::vector<XVisualInfo>& visuals) const {
+  Visual* default_visual = DefaultVisual(display_, DefaultScreen(display_));
+  auto it = std::find_if(visuals.begin(), visuals.end(),
+                         [default_visual](const XVisualInfo& visual_info) {
+                           return visual_info.visual == default_visual;
+                         });
+  DCHECK(it != visuals.end());
+
+  const XVisualInfo& default_visual_info = *it;
+  std::vector<XVisualInfo> filtered_visuals;
+  std::copy_if(
+      visuals.begin(), visuals.end(), std::back_inserter(filtered_visuals),
+      [&default_visual_info](const XVisualInfo& visual_info) {
+        const XVisualInfo& v1 = visual_info;
+        const XVisualInfo& v2 = default_visual_info;
+        return v1.c_class == v2.c_class && v1.depth == v2.depth &&
+               v1.red_mask == v2.red_mask && v1.green_mask == v2.green_mask &&
+               v1.blue_mask == v2.blue_mask &&
+               v1.colormap_size == v2.colormap_size &&
+               v1.bits_per_rgb == v2.bits_per_rgb;
+      });
+  return PickBestGlVisual(filtered_visuals, IsRgbaVisual(default_visual_info));

[Julien Isorce Samsung, 2016/09/28 17:42:52]

I see now why you do not call it default visual. But this is something that
should be mentioned in the commit message maybe, the fact that in the general
case it may not use the default visual.

[Tom (Use chromium acct), 2016/09/28 18:36:01]

Done.

+}
+
+XVisualInfo GLVisualPickerGLX::PickBestRgbaVisual(
+    const std::vector<XVisualInfo>& visuals) const {
+  // Filter the visuals by the best class.
+  auto score = [](int c_class) {
+    // A higher score is more preferable.
+    switch (c_class) {
+      case TrueColor:
+        return 1;
+      case DirectColor:
+        return 0;
+      default:
+        return -1;
+    }
+  };
+  int best_class_score =
+      std::accumulate(visuals.begin(), visuals.end(), -1,
+                      [&score](int acc, const XVisualInfo& visual_info) {
+                        return std::max(acc, score(visual_info.c_class));
+                      });
+  std::vector<XVisualInfo> filtered_visuals;
+  std::copy_if(visuals.begin(), visuals.end(),
+               std::back_inserter(filtered_visuals),
+               [best_class_score, &score](const XVisualInfo& visual_info) {
+                 if (!IsRgbaVisual(visual_info))
+                   return false;
+                 return score(visual_info.c_class) == best_class_score;
+               });
+  return PickBestGlVisual(filtered_visuals, true);
+}
+
+GLVisualPickerGLX::GLVisualPickerGLX() : display_(gfx::GetXDisplay()) {
+  has_glx_visual_rating_ =
+      GLSurfaceGLX::HasGLXExtension("GLX_EXT_visual_rating");
+  has_glx_multisample_ = GLSurfaceGLX::HasGLXExtension("GLX_EXT_multisample");
+
+  XVisualInfo visual_template;
+  visual_template.screen = DefaultScreen(display_);
+
+  // Get all of the visuals for the default screen.
+  int n_visuals;
+  gfx::XScopedPtr<XVisualInfo[]> x_visuals(
+      XGetVisualInfo(display_, VisualScreenMask, &visual_template, &n_visuals));
+  std::vector<XVisualInfo> visuals;
+  for (int i = 0; i < n_visuals; i++)
+    visuals.push_back(x_visuals[i]);
+
+  system_visual_ = PickBestSystemVisual(visuals);
+  rgba_visual_ = PickBestRgbaVisual(visuals);
+}
+
+GLVisualPickerGLX::~GLVisualPickerGLX() {}
+
+}  // namespace gl