gpu/linux: create a child window to control resize and avoid flashes

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 373 matching lines @@
 }
 
 void* GLSurfaceGLX::GetDisplay() {
   return g_display;
 }
 
 GLSurfaceGLX::~GLSurfaceGLX() {}
 
 NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX(gfx::AcceleratedWidget window)
   : parent_window_(window),
+    window_(0),
     config_(NULL) {
 }
 
 gfx::AcceleratedWidget NativeViewGLSurfaceGLX::GetDrawableHandle() const {
-  return parent_window_;
+  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);
+  XMapWindow(g_display, window_);

[ccameron, 2014/05/23 09:09:06]

Looking back at
https://chromiumcodereview.appspot.com/23452026/diff/51001/ui/gl/gl_surface_g...,
it looks like I had to do an XFlush here (after the XMapWindow) ... I didn't
write why I had it there, so I can't say if it is indeed necessary.

 
-  gfx::AcceleratedWidget window_for_vsync = parent_window_;
+  gfx::AcceleratedWidget window_for_vsync = window_;
 
   if (g_glx_oml_sync_control_supported)
     vsync_provider_.reset(new OMLSyncControlVSyncProvider(window_for_vsync));
   else if (g_glx_sgi_video_sync_supported)
     vsync_provider_.reset(new SGIVideoSyncVSyncProvider(window_for_vsync));
 
   return true;
 }
 
 void NativeViewGLSurfaceGLX::Destroy() {
+  if (window_) {
+    XDestroyWindow(g_display, window_);
+    XFlush(g_display);
+  }
 }
 
 bool NativeViewGLSurfaceGLX::Resize(const gfx::Size& size) {
   size_ = size;
+  glXWaitGL();
+  XResizeWindow(g_display, window_, size.width(), size.height());
+  glXWaitX();
   return true;
 }
 
 bool NativeViewGLSurfaceGLX::IsOffscreen() {
   return false;
 }
 
 bool NativeViewGLSurfaceGLX::SwapBuffers() {
   TRACE_EVENT2("gpu", "NativeViewGLSurfaceGLX:RealSwapBuffers",
       "width", GetSize().width(),
@@ skipping 25 matching lines @@
     // 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,
-        parent_window_,
+        window_,
         &attributes)) {
       LOG(ERROR) << "XGetWindowAttributes failed for window " <<
-          parent_window_ << ".";
+          window_ << ".";
       return NULL;
     }
 
     int visual_id = XVisualIDFromVisual(attributes.visual);
 
     int num_elements = 0;
     scoped_ptr<GLXFBConfig, ScopedPtrXFree> configs(
         glXGetFBConfigs(g_display,
                         DefaultScreen(g_display),
                         &num_elements));
@@ skipping 33 matching lines @@
   glXCopySubBufferMESA(g_display, GetDrawableHandle(), x, y, width, height);
   return true;
 }
 
 VSyncProvider* NativeViewGLSurfaceGLX::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 
 NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX()
   : parent_window_(0),
+    window_(0),
     config_(NULL) {
 }
 
 NativeViewGLSurfaceGLX::~NativeViewGLSurfaceGLX() {
   Destroy();
 }
 
 PbufferGLSurfaceGLX::PbufferGLSurfaceGLX(const gfx::Size& size)
   : size_(size),
     config_(NULL),
@@ skipping 77 matching lines @@
 
 void* PbufferGLSurfaceGLX::GetConfig() {
   return config_;
 }
 
 PbufferGLSurfaceGLX::~PbufferGLSurfaceGLX() {
   Destroy();
 }
 
 }  // namespace gfx