Create child window in GPU process for DirectComposition

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"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/command_line.h"
@@ skipping 98 matching lines @@
 EGLConfig g_config;
 EGLDisplay g_display;
 EGLNativeDisplayType g_native_display;
 
 const char* g_egl_extensions = NULL;
 bool g_egl_create_context_robustness_supported = false;
 bool g_egl_sync_control_supported = false;
 bool g_egl_window_fixed_size_supported = false;
 bool g_egl_surfaceless_context_supported = false;
 bool g_egl_surface_orientation_supported = false;
+bool g_use_direct_composition = false;
 
 class EGLSyncControlVSyncProvider
     : public gfx::SyncControlVSyncProvider {
  public:
   explicit EGLSyncControlVSyncProvider(EGLSurface surface)
       : SyncControlVSyncProvider(),
         surface_(surface) {
   }
 
   ~EGLSyncControlVSyncProvider() override {}
@@ skipping 240 matching lines @@
   g_egl_extensions = eglQueryString(g_display, EGL_EXTENSIONS);
   g_egl_create_context_robustness_supported =
       HasEGLExtension("EGL_EXT_create_context_robustness");
   g_egl_sync_control_supported =
       HasEGLExtension("EGL_CHROMIUM_sync_control");
   g_egl_window_fixed_size_supported =
       HasEGLExtension("EGL_ANGLE_window_fixed_size");
   g_egl_surface_orientation_supported =
       HasEGLExtension("EGL_ANGLE_surface_orientation");
 
+  g_use_direct_composition = base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kUseDirectComposition);
+
   // TODO(oetuaho@nvidia.com): Surfaceless is disabled on Android as a temporary
   // workaround, since code written for Android WebView takes different paths
   // based on whether GL surface objects have underlying EGL surface handles,
   // conflicting with the use of surfaceless. See https://crbug.com/382349
 #if defined(OS_ANDROID)
   DCHECK(!g_egl_surfaceless_context_supported);
 #else
   // Check if SurfacelessEGL is supported.
   g_egl_surfaceless_context_supported =
       HasEGLExtension("EGL_KHR_surfaceless_context");
@@ skipping 42 matching lines @@
 }
 
 bool GLSurfaceEGL::IsCreateContextRobustnessSupported() {
   return g_egl_create_context_robustness_supported;
 }
 
 bool GLSurfaceEGL::IsEGLSurfacelessContextSupported() {
   return g_egl_surfaceless_context_supported;
 }
 
+bool GLSurfaceEGL::IsDirectCompositionSupported() {
+  return g_use_direct_composition;
+}
+
 GLSurfaceEGL::~GLSurfaceEGL() {}
 
 // InitializeDisplay is necessary because the static binding code
 // needs a full Display init before it can query the Display extensions.
 // static
 EGLDisplay GLSurfaceEGL::InitializeDisplay() {
   if (g_display != EGL_NO_DISPLAY) {
     return g_display;
   }
 
@@ skipping 42 matching lines @@
     }
   }
 
   return g_display;
 }
 
 NativeViewGLSurfaceEGL::NativeViewGLSurfaceEGL(EGLNativeWindowType window)
     : window_(window),
       config_(NULL),
       size_(1, 1),
+      alpha_(true),
+      enable_fixed_size_angle_(false),
       surface_(NULL),
       supports_post_sub_buffer_(false),
-      alpha_(true),
       flips_vertically_(false),
       swap_interval_(1) {
 #if defined(OS_ANDROID)
   if (window)
     ANativeWindow_acquire(window);
 #endif
 
 #if defined(OS_WIN)
   vsync_override_ = false;
   swap_generation_ = 0;
@@ skipping 18 matching lines @@
 
   // 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) {
+  if (g_egl_window_fixed_size_supported && enable_fixed_size_angle_) {
     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());
   }
 
   if (gfx::g_driver_egl.ext.b_EGL_NV_post_sub_buffer) {
     egl_window_attributes.push_back(EGL_POST_SUB_BUFFER_SUPPORTED_NV);
@@ skipping 430 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gfx