Infrastructure for temportarily relinquishing GPU resources.

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 44 matching lines @@
 namespace gfx {
 
 unsigned int NativeViewGLSurfaceEGL::current_swap_generation_ = 0;
 
 namespace {
 
 EGLConfig g_config;
 EGLDisplay g_display;
 EGLNativeDisplayType g_native_display;
 
+// In the Cast environment, we need to destroy the displayType
+// returned by the GPU platform when we switch to an external app
+// which will temporarily own all screen and GPU resources.
+// Even though Chromium is still in the background.
+// As such, it must be reinitialized each time we come back to the foreground.
+bool g_initialized = false;
+int g_num_surfaces = 0;
+
 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;
 
 class EGLSyncControlVSyncProvider
     : public gfx::SyncControlVSyncProvider {
  public:
   explicit EGLSyncControlVSyncProvider(EGLSurface surface)
@@ skipping 27 matching lines @@
   EGLSurface surface_;
 
   DISALLOW_COPY_AND_ASSIGN(EGLSyncControlVSyncProvider);
 };
 
 }  // namespace
 
 GLSurfaceEGL::GLSurfaceEGL() {}
 
 bool GLSurfaceEGL::InitializeOneOff() {
-  static bool initialized = false;
-  if (initialized)
+  if (g_initialized)
     return true;
 
   g_native_display = GetPlatformDefaultEGLNativeDisplay();
 
 #if defined(OS_WIN)
   g_display = GetPlatformDisplay(g_native_display);
 #else
   g_display = eglGetDisplay(g_native_display);
 #endif
 
@@ skipping 55 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");
 
+  // We always succeed beyond this point so set g_initialized here to avoid
+  // infinite recursion through CreateGLContext and GetDisplay
+  // if g_egl_surfaceless_context_supported.
+  g_initialized = true;
+
   // 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");
   if (g_egl_surfaceless_context_supported) {
     // EGL_KHR_surfaceless_context is supported but ensure
     // GL_OES_surfaceless_context is also supported. We need a current context
     // to query for supported GL extensions.
     scoped_refptr<GLSurface> surface = new SurfacelessEGL(Size(1, 1));
     scoped_refptr<GLContext> context = GLContext::CreateGLContext(
       NULL, surface.get(), PreferIntegratedGpu);
     if (!context->MakeCurrent(surface.get()))
       g_egl_surfaceless_context_supported = false;
 
     // Ensure context supports GL_OES_surfaceless_context.
     if (g_egl_surfaceless_context_supported) {
       g_egl_surfaceless_context_supported = context->HasExtension(
           "GL_OES_surfaceless_context");
       context->ReleaseCurrent(surface.get());
     }
   }
 #endif
 
-  initialized = true;
-
   return true;
 }
 
+// static
+void GLSurfaceEGL::Deinitialize() {
+  if (g_initialized) {
+    g_initialized = false;
+    eglTerminate(g_display);
+  }
+}
+
 EGLDisplay GLSurfaceEGL::GetDisplay() {
+  if (!g_initialized) {
+    bool result = GLSurfaceEGL::InitializeOneOff();
+    DCHECK(result);
+  }
   return g_display;
 }
 
 EGLDisplay GLSurfaceEGL::GetHardwareDisplay() {
+  if (!g_initialized) {
+    bool result = GLSurfaceEGL::InitializeOneOff();
+    DCHECK(result);
+  }
   return g_display;
 }
 
 EGLNativeDisplayType GLSurfaceEGL::GetNativeDisplay() {
+  if (!g_initialized) {
+    bool result = GLSurfaceEGL::InitializeOneOff();
+    DCHECK(result);
+  }
   return g_native_display;
 }
 
 const char* GLSurfaceEGL::GetEGLExtensions() {
+  // No need for InitializeOneOff. Assume that extensions will not change
+  // after the first initialization.
   return g_egl_extensions;
 }
 
 bool GLSurfaceEGL::HasEGLExtension(const char* name) {
   return ExtensionsContain(GetEGLExtensions(), name);
 }
 
 bool GLSurfaceEGL::IsCreateContextRobustnessSupported() {
   return g_egl_create_context_robustness_supported;
 }
@@ skipping 102 matching lines @@
   EGLBoolean retVal = eglQuerySurface(GetDisplay(),
                                       surface_,
                                       EGL_POST_SUB_BUFFER_SUPPORTED_NV,
                                       &surfaceVal);
   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_));
+  ++g_num_surfaces;

[piman, 2014/11/18 20:55:34]

Could that tracking be done in the constructor/destructor of GLSurfaceEGL? That
way it'd avoid duplication.

[GusFernandez, 2014/11/19 18:50:13]

Good idea. This simplified the code somewhat.

   return true;
 }
 
 void NativeViewGLSurfaceEGL::Destroy() {
   if (surface_) {
     if (!eglDestroySurface(GetDisplay(), surface_)) {
       LOG(ERROR) << "eglDestroySurface failed with error "
                  << GetLastEGLErrorString();
     }
     surface_ = NULL;
+    DCHECK_GT(g_num_surfaces, 0) << "Bad surface count";
+    if (--g_num_surfaces == 0) {
+      DVLOG(2) << "Destroyed last (native) EGL surface. Deinitializing.";
+      GLSurfaceEGL::Deinitialize();
+    }
   }
 }
 
 EGLConfig NativeViewGLSurfaceEGL::GetConfig() {
 #if !defined(USE_X11)
   return g_config;
 #else
   if (!config_) {
     // Get a config compatible with the window
     DCHECK(window_);
@@ skipping 223 matching lines @@
 
   EGLSurface new_surface = eglCreatePbufferSurface(display,
                                                    GetConfig(),
                                                    pbuffer_attribs);
   if (!new_surface) {
     LOG(ERROR) << "eglCreatePbufferSurface failed with error "
                << GetLastEGLErrorString();
     return false;
   }
 
-  if (old_surface)
+  if (old_surface) {
     eglDestroySurface(display, old_surface);
+    DVLOG(2) << "Reinitialized pbuffer surface. EGL surface count remains at "
+             << g_num_surfaces;
+  } else {
+    ++g_num_surfaces;
+    DVLOG(2) << "Initialized new pbuffer surface. EGL surface count now "
+             << g_num_surfaces;
+  }
 
   surface_ = new_surface;
   return true;
 }
 
 void PbufferGLSurfaceEGL::Destroy() {
   if (surface_) {
     if (!eglDestroySurface(GetDisplay(), surface_)) {
       LOG(ERROR) << "eglDestroySurface failed with error "
                  << GetLastEGLErrorString();
     }
+    CHECK_GT(g_num_surfaces, 0) << "Bad surface count";

[piman, 2014/11/18 20:55:34]

nit: DCHECK_GT

[GusFernandez, 2014/11/19 18:50:13]

Irrelevant after the change above.

+    if (--g_num_surfaces == 0) {
+      DVLOG(2) << "Destroyed last (pbuffer) EGL surface. Deinitializing.";
+      GLSurfaceEGL::Deinitialize();
+    }
     surface_ = NULL;
   }
 }
 
 EGLConfig PbufferGLSurfaceEGL::GetConfig() {
   return g_config;
 }
 
 bool PbufferGLSurfaceEGL::IsOffscreen() {
   return true;
@@ skipping 104 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gfx