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
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #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>
-}
-#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
 
 #if !defined(EGL_FIXED_SIZE_ANGLE)
@@ skipping 420 matching lines @@
       g_display = display;
       break;
     }
   }
 
   return g_display;
 }
 
 NativeViewGLSurfaceEGL::NativeViewGLSurfaceEGL(EGLNativeWindowType window)
     : window_(window),
+      config_(NULL),
+      size_(1, 1),
       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
 }
 
 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;
   }
 
+  // We need to make sure that window_ is correctly initialized with all
+  // the platform-dependant quirks, if any, before creating the surface.
+  if (!InitializeNativeWindow()) {
+    LOG(ERROR) << "Error trying to initialize the native window.";
+    return false;
+  }
+
   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 22 matching lines @@
     supports_post_sub_buffer_ = (surfaceVal && retVal) == EGL_TRUE;
   }
 
   if (sync_provider)
     vsync_provider_.reset(sync_provider.release());
   else if (g_egl_sync_control_supported)
     vsync_provider_.reset(new EGLSyncControlVSyncProvider(surface_));
   return true;
 }
 
+bool NativeViewGLSurfaceEGL::InitializeNativeWindow() {
+  return true;
+}
+
 void NativeViewGLSurfaceEGL::Destroy() {
   if (surface_) {
     if (!eglDestroySurface(GetDisplay(), surface_)) {
       LOG(ERROR) << "eglDestroySurface failed with error "
                  << GetLastEGLErrorString();
     }
     surface_ = NULL;
   }
 }
 
 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;
-    if (!XGetWindowAttributes(GetNativeDisplay(), window_, &win_attribs)) {
-      return NULL;
-    }
-
-    // Try matching the window depth with an alpha channel,
-    // because we're worried the destination alpha width could
-    // constrain blending precision.
-    const int kBufferSizeOffset = 1;
-    const int kAlphaSizeOffset = 3;
-    EGLint config_attribs[] = {
-      EGL_BUFFER_SIZE, ~0,
-      EGL_ALPHA_SIZE, 8,
-      EGL_BLUE_SIZE, 8,
-      EGL_GREEN_SIZE, 8,
-      EGL_RED_SIZE, 8,
-      EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
-      EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT,
-      EGL_NONE
-    };
-    config_attribs[kBufferSizeOffset] = win_attribs.depth;
-
-    EGLint num_configs;
-    if (!eglChooseConfig(g_display,
-                         config_attribs,
-                         &config_,
-                         1,
-                         &num_configs)) {
-      LOG(ERROR) << "eglChooseConfig failed with error "
-                 << GetLastEGLErrorString();
-      return NULL;
-    }
-
-    if (num_configs) {
-      EGLint config_depth;
-      if (!eglGetConfigAttrib(g_display,
-                              config_,
-                              EGL_BUFFER_SIZE,
-                              &config_depth)) {
-        LOG(ERROR) << "eglGetConfigAttrib failed with error "
-                   << GetLastEGLErrorString();
-        return NULL;
-      }
-
-      if (config_depth == win_attribs.depth) {
-        return config_;
-      }
-    }
-
-    // Try without an alpha channel.
-    config_attribs[kAlphaSizeOffset] = 0;
-    if (!eglChooseConfig(g_display,
-                         config_attribs,
-                         &config_,
-                         1,
-                         &num_configs)) {
-      LOG(ERROR) << "eglChooseConfig failed with error "
-                 << GetLastEGLErrorString();
-      return NULL;
-    }
-
-    if (num_configs == 0) {
-      LOG(ERROR) << "No suitable EGL configs found.";
-      return NULL;
-    }
-  }
-  return config_;
-#endif
 }
 
 bool NativeViewGLSurfaceEGL::IsOffscreen() {
   return false;
 }
 
 gfx::SwapResult NativeViewGLSurfaceEGL::SwapBuffers() {
   TRACE_EVENT2("gpu", "NativeViewGLSurfaceEGL:RealSwapBuffers",
       "width", GetSize().width(),
       "height", GetSize().height());
@@ skipping 311 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gfx