Destroy GLX windows when they are backgrounded

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"
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "third_party/mesa/src/include/GL/osmesa.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/vsync_provider.h"
 
 namespace gfx {
 
 namespace {
 
 // scoped_ptr functor for XFree(). Use as follows:
 //   scoped_ptr_malloc<XVisualInfo, ScopedPtrXFree> foo(...);
 // where "XVisualInfo" is any X type that is freed with XFree.
 class ScopedPtrXFree {
  public:
   void operator()(void* x) const {
     ::XFree(x);
   }
 };
 
-Display* g_display;
+Display* g_display = NULL;
 const char* g_glx_extensions = NULL;
 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 239 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SGIVideoSyncVSyncProvider);
 };
 
 SGIVideoSyncThread* SGIVideoSyncThread::g_video_sync_thread = NULL;
 
 // 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;
 
+#if defined(TOOLKIT_GTK)
+// A mechanism for forwarding XExpose events from one window to another.
+// Because in the workaround for http://crbug.com/145600 the child window
+// is placed on top of the parent window, only the child window will receive
+// all expose events. These need to be forwared to the parent window to inform
+// it that it should paint.
+class XExposeEventForwarder : public base::MessagePumpObserver {
+ public:
+  XExposeEventForwarder() {}
+  virtual ~XExposeEventForwarder() {
+    DCHECK(child_to_parent_map_.empty());
+  }
+  void AddParentChildPair(gfx::AcceleratedWidget parent_window,
+                          gfx::AcceleratedWidget child_window) {
+    if (child_to_parent_map_.empty())
+      base::MessagePumpX11::Current()->AddObserver(this);
+
+    DCHECK(child_to_parent_map_.find(child_window) ==
+           child_to_parent_map_.end());
+    child_to_parent_map_.insert(std::make_pair(
+        child_window, parent_window));
+  }
+  void RemoveParentChildPair(gfx::AcceleratedWidget parent_window,
+                             gfx::AcceleratedWidget child_window) {
+    DCHECK(child_to_parent_map_.find(child_window) !=
+           child_to_parent_map_.end());
+    child_to_parent_map_.erase(child_window);
+
+    if (child_to_parent_map_.empty())
+      base::MessagePumpX11::Current()->RemoveObserver(this);
+  }
+
+ private:
+  virtual base::EventStatus WillProcessEvent (
+      const base::NativeEvent& xevent) OVERRIDE {
+    if (xevent->type != Expose)
+      return base::EVENT_CONTINUE;
+
+    WindowMap::const_iterator found = child_to_parent_map_.find(
+        xevent->xexpose.window);
+    if (found == child_to_parent_map_.end())
+      return base::EVENT_CONTINUE;
+
+    gfx::AcceleratedWidget target_window = found->second;
+    XEvent forwarded_event = *xevent;
+    forwarded_event.xexpose.window = target_window;
+    XSendEvent(g_display, target_window, False, ExposureMask,
+               &forwarded_event);
+    return base::EVENT_CONTINUE;
+  }
+  virtual void DidProcessEvent(const base::NativeEvent& xevent) OVERRIDE {
+  }
+
+  typedef std::map<gfx::AcceleratedWidget, gfx::AcceleratedWidget> WindowMap;
+  WindowMap child_to_parent_map_;
+
+  DISALLOW_COPY_AND_ASSIGN(XExposeEventForwarder);
+};
+
+static base::LazyInstance<XExposeEventForwarder> g_xexpose_event_forwarder =
+    LAZY_INSTANCE_INITIALIZER;
+#endif
+
 }  // namespace
 
 GLSurfaceGLX::GLSurfaceGLX() {}
 
 bool GLSurfaceGLX::InitializeOneOff() {
   static bool initialized = false;
   if (initialized)
     return true;
 
   // http://crbug.com/245466
   setenv("force_s3tc_enable", "true", 1);
 
   // SGIVideoSyncProviderShim (if instantiated) will issue X commands on
   // it's own thread.
   XInitThreads();
 
+#if defined(TOOLKIT_GTK)
+  // Be sure to use the X display handle and not the GTK display handle if this
+  // is the GPU process.
+  if (base::MessageLoop::current()->type() == base::MessageLoop::TYPE_GPU)
+    g_display = base::MessagePumpX11::GetDefaultXDisplay();
+  else
+    g_display = base::MessagePumpForUI::GetDefaultXDisplay();
+#else
   g_display = base::MessagePumpForUI::GetDefaultXDisplay();
+#endif
+
   if (!g_display) {
     LOG(ERROR) << "XOpenDisplay failed.";
     return false;
   }
 
   int major, minor;
   if (!glXQueryVersion(g_display, &major, &minor)) {
     LOG(ERROR) << "glxQueryVersion failed";
     return false;
   }
@@ skipping 52 matching lines @@
 bool GLSurfaceGLX::IsOMLSyncControlSupported() {
   return g_glx_oml_sync_control_supported;
 }
 
 void* GLSurfaceGLX::GetDisplay() {
   return g_display;
 }
 
 GLSurfaceGLX::~GLSurfaceGLX() {}
 
+#if defined(TOOLKIT_GTK)
+bool NativeViewGLSurfaceGLX::SetBackbufferAllocation(bool allocated) {
+  backbuffer_allocated_ = allocated;
+  AdjustBufferAllocation();
+  return true;
+}
+
+void NativeViewGLSurfaceGLX::SetFrontbufferAllocation(bool allocated) {
+  frontbuffer_allocated_ = allocated;
+  AdjustBufferAllocation();
+}
+
+void NativeViewGLSurfaceGLX::AdjustBufferAllocation() {
+  if (frontbuffer_allocated_ || backbuffer_allocated_)
+    CreateChildWindow();
+  else
+    DestroyChildWindow();
+}
+
+void NativeViewGLSurfaceGLX::CreateChildWindow() {
+  if (child_window_)
+    return;
+
+  XSetWindowAttributes set_window_attributes;
+  set_window_attributes.event_mask = ExposureMask;
+  child_window_ = XCreateWindow(
+      g_display, parent_window_, 0, 0, size_.width(), size_.height(), 0,
+      CopyFromParent, InputOutput, CopyFromParent, CWEventMask,
+      &set_window_attributes);
+  g_xexpose_event_forwarder.Pointer()->AddParentChildPair(
+      parent_window_, child_window_);
+
+  XMapWindow(g_display, child_window_);
+  XFlush(g_display);
+}
+
+void NativeViewGLSurfaceGLX::DestroyChildWindow() {
+  if (!child_window_)
+    return;
+
+  g_xexpose_event_forwarder.Pointer()->RemoveParentChildPair(
+      parent_window_, child_window_);
+  XDestroyWindow(g_display, child_window_);
+  XFlush(g_display);
+  child_window_ = 0;
+}
+#endif
+
 NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX(gfx::AcceleratedWidget window)
-  : window_(window),
+  : parent_window_(window),
+#if defined(TOOLKIT_GTK)
+    child_window_(0),
+    dummy_window_(0),
+    backbuffer_allocated_(true),
+    frontbuffer_allocated_(true),
+#endif
     config_(NULL) {
 }
 
+gfx::AcceleratedWidget NativeViewGLSurfaceGLX::GetDrawableHandle() const {
+#if defined(TOOLKIT_GTK)
+  if (child_window_)
+    return child_window_;
+  return dummy_window_;
+#else
+  return parent_window_;
+#endif
+}
+
 bool NativeViewGLSurfaceGLX::Initialize() {
   XWindowAttributes attributes;
-  if (!XGetWindowAttributes(g_display, window_, &attributes)) {
-    LOG(ERROR) << "XGetWindowAttributes failed for window " << window_ << ".";
+  if (!XGetWindowAttributes(g_display, parent_window_, &attributes)) {
+    LOG(ERROR) << "XGetWindowAttributes failed for window " << parent_window_
+        << ".";
     return false;
   }
   size_ = gfx::Size(attributes.width, attributes.height);
 
+  gfx::AcceleratedWidget window_for_vsync = parent_window_;
+
+#if defined(TOOLKIT_GTK)
+  dummy_window_ = XCreateWindow(
+      g_display,
+      RootWindow(g_display, XScreenNumberOfScreen(attributes.screen)),
+      0, 0, 1, 1, 0, CopyFromParent, InputOutput, attributes.visual, 0, NULL);
+  window_for_vsync = dummy_window_;
+  CreateChildWindow();
+#endif
+
   if (g_glx_oml_sync_control_supported)
-    vsync_provider_.reset(new OMLSyncControlVSyncProvider(window_));
+    vsync_provider_.reset(new OMLSyncControlVSyncProvider(window_for_vsync));
   else if (g_glx_sgi_video_sync_supported)
-    vsync_provider_.reset(new SGIVideoSyncVSyncProvider(window_));
+    vsync_provider_.reset(new SGIVideoSyncVSyncProvider(window_for_vsync));
 
   return true;
 }
 
 void NativeViewGLSurfaceGLX::Destroy() {
+#if defined(TOOLKIT_GTK)
+  DestroyChildWindow();
+  if (dummy_window_)
+    XDestroyWindow(g_display, dummy_window_);
+  dummy_window_ = 0;
+#endif
 }
 
 bool NativeViewGLSurfaceGLX::Resize(const gfx::Size& size) {
+#if defined(TOOLKIT_GTK)
+  if (child_window_) {
+    XResizeWindow(g_display, child_window_, size.width(), size.height());
+    XFlush(g_display);
+  }
+#endif
   size_ = size;
   return true;
 }
 
 bool NativeViewGLSurfaceGLX::IsOffscreen() {
   return false;
 }
 
 bool NativeViewGLSurfaceGLX::SwapBuffers() {
-  glXSwapBuffers(g_display, window_);
+  glXSwapBuffers(g_display, GetDrawableHandle());
   return true;
 }
 
 gfx::Size NativeViewGLSurfaceGLX::GetSize() {
   return size_;
 }
 
 void* NativeViewGLSurfaceGLX::GetHandle() {
-  return reinterpret_cast<void*>(window_);
+  return reinterpret_cast<void*>(GetDrawableHandle());
 }
 
 std::string NativeViewGLSurfaceGLX::GetExtensions() {
   std::string extensions = GLSurface::GetExtensions();
   if (gfx::g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer) {
     extensions += extensions.empty() ? "" : " ";
     extensions += "GL_CHROMIUM_post_sub_buffer";
   }
   return extensions;
 }
 
 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_,
+        parent_window_,
         &attributes)) {
       LOG(ERROR) << "XGetWindowAttributes failed for window " <<
-          window_ << ".";
+          parent_window_ << ".";
       return NULL;
     }
 
     int visual_id = XVisualIDFromVisual(attributes.visual);
 
     int num_elements = 0;
     scoped_ptr_malloc<GLXFBConfig, ScopedPtrXFree> configs(
         glXGetFBConfigs(g_display,
                         DefaultScreen(g_display),
                         &num_elements));
@@ skipping 23 matching lines @@
       config_ = configs.get()[i];
     }
   }
 
   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, window_, x, y, width, height);
+  glXCopySubBufferMESA(g_display, GetDrawableHandle(), x, y, width, height);
   return true;
 }
 
 VSyncProvider* NativeViewGLSurfaceGLX::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 
 NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX()
-  : window_(0),
+  : parent_window_(0),
+#if defined(TOOLKIT_GTK)
+    child_window_(0),
+    dummy_window_(0),
+    backbuffer_allocated_(true),
+    frontbuffer_allocated_(true),
+#endif
     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