ui: Enable virtual contexts for linux

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.
 
 extern "C" {
 #include <X11/Xlib.h>
 }
 
 #include "ui/gl/gl_surface_glx.h"
 
@@ skipping 15 matching lines @@
 #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/sync_control_vsync_provider.h"
 
 namespace gfx {
 
 namespace {
 
-Display* g_display = NULL;
-const char* g_glx_extensions = NULL;
+Display* g_display = nullptr;
+const char* g_glx_extensions = nullptr;
 bool g_glx_context_create = false;
 bool g_glx_create_context_robustness_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;
 
@@ skipping 65 matching lines @@
 
  private:
   friend class base::RefCounted<SGIVideoSyncThread>;
 
   SGIVideoSyncThread() : base::Thread("SGI_video_sync") {
     DCHECK(CalledOnValidThread());
   }
 
   ~SGIVideoSyncThread() override {
     DCHECK(CalledOnValidThread());
-    g_video_sync_thread = NULL;
+    g_video_sync_thread = nullptr;
     Stop();
   }
 
   static SGIVideoSyncThread* g_video_sync_thread;
 
   DISALLOW_COPY_AND_ASSIGN(SGIVideoSyncThread);
 };
 
 class SGIVideoSyncProviderThreadShim {
  public:
   explicit SGIVideoSyncProviderThreadShim(XID window)
       : window_(window),
-        context_(NULL),
+        context_(nullptr),
         task_runner_(base::ThreadTaskRunnerHandle::Get()),
         cancel_vsync_flag_(),
         vsync_lock_() {
     // This ensures that creation of |window_| has occured when this shim
     // is executing in the same process as the call to create |window_|.
     XSync(g_display, False);
   }
 
   virtual ~SGIVideoSyncProviderThreadShim() {
     if (context_) {
       glXDestroyContext(display_, context_);
-      context_ = NULL;
+      context_ = nullptr;
     }
   }
 
   base::CancellationFlag* cancel_vsync_flag() {
     return &cancel_vsync_flag_;
   }
 
   base::Lock* vsync_lock() {
     return &vsync_lock_;
   }
@@ skipping 14 matching lines @@
     int visual_info_count = 0;
     gfx::XScopedPtr<XVisualInfo> visual_info_list(XGetVisualInfo(
         display_, VisualIDMask, &visual_info_template, &visual_info_count));
 
     DCHECK(visual_info_list.get());
     if (visual_info_count == 0) {
       LOG(ERROR) << "No visual info for visual ID.";
       return;
     }
 
-    context_ = glXCreateContext(display_, visual_info_list.get(), NULL, True);
+    context_ =
+        glXCreateContext(display_, visual_info_list.get(), nullptr, True);
 
-    DCHECK(NULL != context_);
+    DCHECK(nullptr != context_);
   }
 
   void GetVSyncParameters(const VSyncProvider::UpdateVSyncCallback& callback) {
     base::TimeTicks now;
     {
       // Don't allow |window_| destruction while we're probing vsync.
       base::AutoLock locked(vsync_lock_);
 
       if (!context_ || cancel_vsync_flag_.IsSet())
         return;
@@ skipping 105 matching lines @@
   // These will only be referenced before we post a task to destroy
   // the shim_, so they are safe to access.
   base::CancellationFlag* cancel_vsync_flag_;
   base::Lock* vsync_lock_;
 
   base::TimeTicks last_get_vsync_parameters_time_;
 
   DISALLOW_COPY_AND_ASSIGN(SGIVideoSyncVSyncProvider);
 };
 
-SGIVideoSyncThread* SGIVideoSyncThread::g_video_sync_thread = NULL;
+SGIVideoSyncThread* SGIVideoSyncThread::g_video_sync_thread = nullptr;
 
 // In order to take advantage of GLX_SGI_video_sync, we need a display
 // for use on a separate thread. We must allocate this before the sandbox
 // goes up (rather than on-demand when we start the thread).
-Display* SGIVideoSyncProviderThreadShim::display_ = NULL;
+Display* SGIVideoSyncProviderThreadShim::display_ = nullptr;
 
 }  // namespace
 
 GLSurfaceGLX::GLSurfaceGLX() {}
 
 bool GLSurfaceGLX::InitializeOneOff() {
   static bool initialized = false;
   if (initialized)
     return true;
 
@@ skipping 70 matching lines @@
 bool GLSurfaceGLX::IsOMLSyncControlSupported() {
   return g_glx_oml_sync_control_supported;
 }
 
 void* GLSurfaceGLX::GetDisplay() {
   return g_display;
 }
 
 GLSurfaceGLX::~GLSurfaceGLX() {}
 
+void* GLSurfaceGLX::GetConfig(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
+  // support it, we should use glXChooseFBConfig in the browser
+  // process to choose the FBConfig and from there the X Visual to
+  // use when creating the window in the first place. Then we can
+  // pass that FBConfig down rather than attempting to reconstitute
+  // it.
+
+  XWindowAttributes attributes;
+  if (!XGetWindowAttributes(g_display, window, &attributes)) {
+    LOG(ERROR) << "XGetWindowAttributes failed for window " << window << ".";
+    return nullptr;
+  }
+
+  int visual_id = XVisualIDFromVisual(attributes.visual);
+
+  int num_elements = 0;
+  gfx::XScopedPtr<GLXFBConfig> configs(
+      glXGetFBConfigs(g_display, DefaultScreen(g_display), &num_elements));
+  if (!configs.get()) {
+    LOG(ERROR) << "glXGetFBConfigs failed.";
+    return nullptr;
+  }
+  if (!num_elements) {
+    LOG(ERROR) << "glXGetFBConfigs returned 0 elements.";
+    return nullptr;
+  }
+  bool found = false;
+  int i;
+  for (i = 0; i < num_elements; ++i) {
+    int value;
+    if (glXGetFBConfigAttrib(g_display, configs.get()[i], GLX_VISUAL_ID,
+                             &value)) {
+      LOG(ERROR) << "glXGetFBConfigAttrib failed.";
+      return nullptr;
+    }
+    if (value == visual_id) {
+      found = true;
+      break;
+    }
+  }
+  if (found) {
+    return configs.get()[i];
+  }
+  return nullptr;
+}
+
 NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX(gfx::AcceleratedWidget window)
-  : parent_window_(window),
-    window_(0),
-    config_(NULL) {
+    : parent_window_(window), window_(0), config_(nullptr) {
 }
 
 gfx::AcceleratedWidget NativeViewGLSurfaceGLX::GetDrawableHandle() const {
   return window_;
 }
 
 bool NativeViewGLSurfaceGLX::Initialize() {
   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);
   // 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.
-  window_ = XCreateWindow(g_display,
-                          parent_window_,
-                          0,
-                          0,
-                          size_.width(),
-                          size_.height(),
-                          0,
-                          CopyFromParent,
-                          InputOutput,
-                          CopyFromParent,
-                          0,
-                          NULL);
+  window_ = XCreateWindow(g_display, parent_window_, 0, 0, size_.width(),
+                          size_.height(), 0, CopyFromParent, InputOutput,
+                          CopyFromParent, 0, nullptr);
   XMapWindow(g_display, window_);
 
   ui::PlatformEventSource* event_source =
       ui::PlatformEventSource::GetInstance();
-  // Can be NULL in tests, when we don't care about Exposes.
+  // Can be nullptr in tests, when we don't care about Exposes.
   if (event_source) {
     XSelectInput(g_display, window_, ExposureMask);
     ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
   }
   XFlush(g_display);
 
   gfx::AcceleratedWidget window_for_vsync = window_;
 
   if (g_glx_oml_sync_control_supported)
     vsync_provider_.reset(new OMLSyncControlVSyncProvider(window_for_vsync));
@@ skipping 55 matching lines @@
 
 void* NativeViewGLSurfaceGLX::GetHandle() {
   return reinterpret_cast<void*>(GetDrawableHandle());
 }
 
 bool NativeViewGLSurfaceGLX::SupportsPostSubBuffer() {
   return gfx::g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer;
 }
 
 void* NativeViewGLSurfaceGLX::GetConfig() {
-  if (!config_) {
-    // 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
-    // support it, we should use glXChooseFBConfig in the browser
-    // process to choose the FBConfig and from there the X Visual to
-    // use when creating the window in the first place. Then we can
-    // pass that FBConfig down rather than attempting to reconstitute
-    // it.
-
-    XWindowAttributes attributes;
-    if (!XGetWindowAttributes(
-        g_display,
-        window_,
-        &attributes)) {
-      LOG(ERROR) << "XGetWindowAttributes failed for window " <<
-          window_ << ".";
-      return NULL;
-    }
-
-    int visual_id = XVisualIDFromVisual(attributes.visual);
-
-    int num_elements = 0;
-    gfx::XScopedPtr<GLXFBConfig> configs(
-        glXGetFBConfigs(g_display, DefaultScreen(g_display), &num_elements));
-    if (!configs.get()) {
-      LOG(ERROR) << "glXGetFBConfigs failed.";
-      return NULL;
-    }
-    if (!num_elements) {
-      LOG(ERROR) << "glXGetFBConfigs returned 0 elements.";
-      return NULL;
-    }
-    bool found = false;
-    int i;
-    for (i = 0; i < num_elements; ++i) {
-      int value;
-      if (glXGetFBConfigAttrib(
-              g_display, configs.get()[i], GLX_VISUAL_ID, &value)) {
-        LOG(ERROR) << "glXGetFBConfigAttrib failed.";
-        return NULL;
-      }
-      if (value == visual_id) {
-        found = true;
-        break;
-      }
-    }
-    if (found) {
-      config_ = configs.get()[i];
-    }
-  }
-
+  if (!config_)
+    config_ = GLSurfaceGLX::GetConfig(window_);
   return config_;
 }
 
 bool NativeViewGLSurfaceGLX::PostSubBuffer(
     int x, int y, int width, int height) {
   DCHECK(gfx::g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer);
   glXCopySubBufferMESA(g_display, GetDrawableHandle(), x, y, width, height);
   return true;
 }
 
 VSyncProvider* NativeViewGLSurfaceGLX::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 
 NativeViewGLSurfaceGLX::~NativeViewGLSurfaceGLX() {
   Destroy();
 }
 
-PbufferGLSurfaceGLX::PbufferGLSurfaceGLX(const gfx::Size& size)
-  : size_(size),
-    config_(NULL),
-    pbuffer_(0) {
-  // Some implementations of Pbuffer do not support having a 0 size. For such
-  // cases use a (1, 1) surface.
+UnmappedNativeViewGLSurfaceGLX::UnmappedNativeViewGLSurfaceGLX(
+    const gfx::Size& size)
+    : size_(size), config_(nullptr), window_(0) {
+  // Ensure that we don't create a window with zero size.
   if (size_.GetArea() == 0)

[hendrikw, 2015/04/17 18:59:46]

I think it's safer to leave this in, but it would be nice to know if it's really
needed?

[piman, 2015/04/17 19:37:29]

AIUI yes it's needed. XCreatWindow(3) isn't clear about it, but
XConfigureWindow(3) says width/height must be !0.

     size_.SetSize(1, 1);
 }
 
-bool PbufferGLSurfaceGLX::Initialize() {
-  DCHECK(!pbuffer_);
+bool UnmappedNativeViewGLSurfaceGLX::Initialize() {
+  DCHECK(!window_);
 
-  static const int config_attributes[] = {
-    GLX_BUFFER_SIZE, 32,
-    GLX_ALPHA_SIZE, 8,
-    GLX_BLUE_SIZE, 8,
-    GLX_GREEN_SIZE, 8,
-    GLX_RED_SIZE, 8,
-    GLX_RENDER_TYPE, GLX_RGBA_BIT,
-    GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
-    GLX_DOUBLEBUFFER, False,
-    0
-  };
+  gfx::AcceleratedWidget parent_window =
+      RootWindow(g_display, DefaultScreen(g_display));
 
-  int num_elements = 0;
-  gfx::XScopedPtr<GLXFBConfig> configs(glXChooseFBConfig(
-      g_display, DefaultScreen(g_display), config_attributes, &num_elements));
-  if (!configs.get()) {
-    LOG(ERROR) << "glXChooseFBConfig failed.";
-    return false;
+  // 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.
+  window_ = XCreateWindow(g_display, parent_window, 0, 0, size_.width(),
+                          size_.height(), 0, CopyFromParent, InputOutput,
+                          CopyFromParent, 0, nullptr);
+  return window_ != 0;
+}
+
+void UnmappedNativeViewGLSurfaceGLX::Destroy() {
+  config_ = nullptr;
+  if (window_) {
+    XDestroyWindow(g_display, window_);
+    window_ = 0;
   }
-  if (!num_elements) {
-    LOG(ERROR) << "glXChooseFBConfig returned 0 elements.";
-    return false;
-  }
+}
 
-  config_ = configs.get()[0];
-
-  const int pbuffer_attributes[] = {
-    GLX_PBUFFER_WIDTH, size_.width(),
-    GLX_PBUFFER_HEIGHT, size_.height(),
-    0
-  };
-  pbuffer_ = glXCreatePbuffer(g_display,
-                              static_cast<GLXFBConfig>(config_),
-                              pbuffer_attributes);
-  if (!pbuffer_) {
-    Destroy();
-    LOG(ERROR) << "glXCreatePbuffer failed.";
-    return false;
-  }
-
+bool UnmappedNativeViewGLSurfaceGLX::IsOffscreen() {
   return true;
 }
 
-void PbufferGLSurfaceGLX::Destroy() {
-  if (pbuffer_) {
-    glXDestroyPbuffer(g_display, pbuffer_);
-    pbuffer_ = 0;
-  }
-
-  config_ = NULL;
-}
-
-bool PbufferGLSurfaceGLX::IsOffscreen() {
-  return true;
-}
-
-bool PbufferGLSurfaceGLX::SwapBuffers() {
-  NOTREACHED() << "Attempted to call SwapBuffers on a pbuffer.";
+bool UnmappedNativeViewGLSurfaceGLX::SwapBuffers() {
+  NOTREACHED() << "Attempted to call SwapBuffers on an unmapped window.";
   return false;
 }
 
-gfx::Size PbufferGLSurfaceGLX::GetSize() {
+gfx::Size UnmappedNativeViewGLSurfaceGLX::GetSize() {
   return size_;
 }
 
-void* PbufferGLSurfaceGLX::GetHandle() {
-  return reinterpret_cast<void*>(pbuffer_);
+void* UnmappedNativeViewGLSurfaceGLX::GetHandle() {
+  return reinterpret_cast<void*>(window_);
 }
 
-void* PbufferGLSurfaceGLX::GetConfig() {
+void* UnmappedNativeViewGLSurfaceGLX::GetConfig() {
+  if (!config_)
+    config_ = GLSurfaceGLX::GetConfig(window_);
   return config_;
 }
 
-PbufferGLSurfaceGLX::~PbufferGLSurfaceGLX() {
+UnmappedNativeViewGLSurfaceGLX::~UnmappedNativeViewGLSurfaceGLX() {
   Destroy();
 }
 
 }  // namespace gfx