egl/x11: Created a child window to control resizes and prevent flashes

ui/gl/gl_surface_egl.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.
 
 #include "ui/gl/gl_surface_egl.h"
 
 #if defined(OS_ANDROID)
 #include <android/native_window_jni.h>
 #endif
 
@@ skipping 12 matching lines @@
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/scoped_make_current.h"
 #include "ui/gl/sync_control_vsync_provider.h"
 
 #if defined(USE_X11)
 extern "C" {
 #include <X11/Xlib.h>
 }
+#include "ui/events/platform/platform_event_source.h"
 #endif
 
 #if defined (USE_OZONE)
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #endif
 
 #if defined(USE_X11) && !defined(OS_CHROMEOS)
 #include "ui/gfx/x/x11_switches.h"
 #endif
@@ skipping 422 matching lines @@
       g_display = display;
       break;
     }
   }
 
   return g_display;
 }
 
 NativeViewGLSurfaceEGL::NativeViewGLSurfaceEGL(EGLNativeWindowType window)
     : window_(window),
+#if defined(USE_X11)
+      parent_window_(0),
+#endif
       surface_(NULL),
       supports_post_sub_buffer_(false),
       config_(NULL),
       size_(1, 1),
       swap_interval_(1) {
 #if defined(OS_ANDROID)
   if (window)
     ANativeWindow_acquire(window);
 #endif
 
 #if defined(OS_WIN)
   vsync_override_ = false;
   swap_generation_ = 0;
   RECT windowRect;
   if (GetClientRect(window_, &windowRect))
     size_ = gfx::Rect(windowRect).size();
 #endif
+
+#if defined(USE_X11)
+  // We use a child XWindow for X11, to help avoiding artifacts while resizing.
+  parent_window_ = window_;
+  window_ = 0;
+#endif
 }
 
 bool NativeViewGLSurfaceEGL::Initialize() {
   return Initialize(nullptr);
 }
 
 bool NativeViewGLSurfaceEGL::Initialize(
     scoped_ptr<VSyncProvider> sync_provider) {
   DCHECK(!surface_);
 
   if (!GetDisplay()) {
     LOG(ERROR) << "Trying to create surface with invalid display.";
     return false;
   }
 
+#if defined(USE_X11)
+  Display* x11_display = GetNativeDisplay();
+  XWindowAttributes attributes;
+  if (!XGetWindowAttributes(x11_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.
+  XSetWindowAttributes swa;
+  memset(&swa, 0, sizeof(swa));
+  swa.background_pixmap = 0;
+  swa.bit_gravity = NorthWestGravity;
+  window_ = XCreateWindow(x11_display, parent_window_, 0, 0, size_.width(),
+                          size_.height(), 0, CopyFromParent, InputOutput,
+                          CopyFromParent, CWBackPixmap | CWBitGravity, &swa);
+  XMapWindow(x11_display, window_);
+
+  ui::PlatformEventSource* source = ui::PlatformEventSource::GetInstance();
+  // The event source can be nullptr in tests, when we don't care about Exposes.
+  if (source) {
+    XSelectInput(x11_display, window_, ExposureMask);
+    source->AddPlatformEventDispatcher(this);
+  }
+  XFlush(x11_display);
+#endif // USE_X11
+
   std::vector<EGLint> egl_window_attributes;
 
   if (g_egl_window_fixed_size_supported) {
     egl_window_attributes.push_back(EGL_FIXED_SIZE_ANGLE);
     egl_window_attributes.push_back(EGL_TRUE);
     egl_window_attributes.push_back(EGL_WIDTH);
     egl_window_attributes.push_back(size_.width());
     egl_window_attributes.push_back(EGL_HEIGHT);
     egl_window_attributes.push_back(size_.height());
   }
@@ skipping 30 matching lines @@
 }
 
 void NativeViewGLSurfaceEGL::Destroy() {
   if (surface_) {
     if (!eglDestroySurface(GetDisplay(), surface_)) {
       LOG(ERROR) << "eglDestroySurface failed with error "
                  << GetLastEGLErrorString();
     }
     surface_ = NULL;
   }
+
+#if defined(USE_X11)
+  if (window_) {
+    ui::PlatformEventSource* source = ui::PlatformEventSource::GetInstance();
+    if (source)
+      source->RemovePlatformEventDispatcher(this);
+
+    Display* x11_display = GetNativeDisplay();
+    XDestroyWindow(x11_display, window_);
+    window_ = 0;
+    XFlush(x11_display);
+  }
+#endif
 }
 
 EGLConfig NativeViewGLSurfaceEGL::GetConfig() {
 #if !defined(USE_X11)
   return g_config;
 #else
   if (!config_) {
     // Get a config compatible with the window
     DCHECK(window_);
     XWindowAttributes win_attribs;
@@ skipping 131 matching lines @@
 
   return gfx::Size(width, height);
 }
 
 bool NativeViewGLSurfaceEGL::Resize(const gfx::Size& size, float scale_factor) {
   if (size == GetSize())
     return true;
 
   size_ = size;
 
+#if defined(USE_X11)
+  eglWaitGL();
+  XResizeWindow(GetNativeDisplay(), window_, size.width(), size.height());
+  eglWaitNative(EGL_CORE_NATIVE_ENGINE);
+#else
   scoped_ptr<ui::ScopedMakeCurrent> scoped_make_current;
   GLContext* current_context = GLContext::GetCurrent();
   bool was_current =
       current_context && current_context->IsCurrent(this);
   if (was_current) {
     scoped_make_current.reset(
         new ui::ScopedMakeCurrent(current_context, this));
     current_context->ReleaseCurrent(this);
   }
 
   Destroy();
 
   if (!Initialize()) {
     LOG(ERROR) << "Failed to resize window.";
     return false;
   }
+#endif
 
   return true;
 }
 
 bool NativeViewGLSurfaceEGL::Recreate() {
   Destroy();
   if (!Initialize()) {
     LOG(ERROR) << "Failed to create surface.";
     return false;
   }
@@ skipping 47 matching lines @@
 }
 
 NativeViewGLSurfaceEGL::~NativeViewGLSurfaceEGL() {
   Destroy();
 #if defined(OS_ANDROID)
   if (window_)
     ANativeWindow_release(window_);
 #endif
 }
 
+#if defined(USE_X11)
+bool NativeViewGLSurfaceEGL::CanDispatchEvent(const ui::PlatformEvent& event) {
+  return event->type == Expose && event->xexpose.window == window_;
+}
+
+uint32_t NativeViewGLSurfaceEGL::DispatchEvent(const ui::PlatformEvent& event) {
+  XEvent x_event = *event;
+  x_event.xexpose.window = parent_window_;
+
+  Display* x11_display = GetNativeDisplay();
+  XSendEvent(x11_display, parent_window_, False, ExposureMask, &x_event);
+  XFlush(x11_display);
+  return ui::POST_DISPATCH_STOP_PROPAGATION;
+}
+#endif
+
 PbufferGLSurfaceEGL::PbufferGLSurfaceEGL(const gfx::Size& size)
     : size_(size),
       surface_(NULL) {
   // Some implementations of Pbuffer do not support having a 0 size. For such
   // cases use a (1, 1) surface.
   if (size_.GetArea() == 0)
     size_.SetSize(1, 1);
 }
 
 bool PbufferGLSurfaceEGL::Initialize() {
@@ skipping 154 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gfx