(not for review) Fix composited-to-non-composited corruption on 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 293 matching lines @@
 // 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());
+    DCHECK(parent_to_child_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));
+    parent_to_child_map_.insert(std::make_pair(
+        parent_window, child_window));
   }
   void RemoveParentChildPair(gfx::AcceleratedWidget parent_window,
                              gfx::AcceleratedWidget child_window) {
     DCHECK(child_to_parent_map_.find(child_window) !=
            child_to_parent_map_.end());
+    DCHECK(parent_to_child_map_.find(parent_window) !=
+           parent_to_child_map_.end());
     child_to_parent_map_.erase(child_window);
+    parent_to_child_map_.erase(parent_window);
 
     if (child_to_parent_map_.empty())
       base::MessagePumpX11::Current()->RemoveObserver(this);
   }
+  void SetChildWindowVisible(gfx::AcceleratedWidget parent_window,
+                             bool visible) {
+    WindowMap::const_iterator found = parent_to_child_map_.find(parent_window);
+    if (found == parent_to_child_map_.end())
+      return;
+    gfx::AcceleratedWidget child_window = found->second;
+    if (visible)
+      XMapWindow(g_display, child_window);
+    else
+      XUnmapWindow(g_display, child_window);
+    // XFlush(g_display);
+  }
 
  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_;
+  WindowMap parent_to_child_map_;
 
   DISALLOW_COPY_AND_ASSIGN(XExposeEventForwarder);
 };
 
 static base::LazyInstance<XExposeEventForwarder> g_xexpose_event_forwarder =
     LAZY_INSTANCE_INITIALIZER;
 
 // Do not use this workaround when running in test harnesses that do not have
 // a message loop or do not have a TYPE_GPU message loop.
 bool g_create_child_windows = false;
@@ skipping 15 matching lines @@
   // 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.
   g_create_child_windows =
       base::MessageLoop::current() &&
       base::MessageLoop::current()->type() == base::MessageLoop::TYPE_GPU;
 
-  // Disable this path because it is causing window contents to disappear.
-  // http://crbug.com/292655
-  g_create_child_windows = false;
-
   if (g_create_child_windows)
     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.";
@@ skipping 283 matching lines @@
     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();
 }
 
+#if defined(TOOLKIT_GTK)
+void NativeViewGLSurfaceGLX::AcceleratedCompositingStateChange(
+    int32 surface_id, bool compositing_active) {
+  g_xexpose_event_forwarder.Pointer()->SetChildWindowVisible(
+      surface_id, compositing_active);
+}
+#endif
+
 NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX()
   : parent_window_(0),
 #if defined(TOOLKIT_GTK)
     child_window_(0),
     dummy_window_(0),
     backbuffer_allocated_(true),
     frontbuffer_allocated_(true),
 #endif
     config_(NULL) {
 }
@@ skipping 85 matching lines @@
 
 void* PbufferGLSurfaceGLX::GetConfig() {
   return config_;
 }
 
 PbufferGLSurfaceGLX::~PbufferGLSurfaceGLX() {
   Destroy();
 }
 
 }  // namespace gfx