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

[dcheng, 2014/11/21 03:06:04]

What is "displayType"? Is this reference to a Chrome type or some other C/C++
type?

[GusFernandez, 2014/11/21 19:13:56]

I clarified the comment and also
s/g_native_display/g_native_display_type/
to be more consistent with EGL naming.

+// 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;
+bool g_terminate_pending = false;
+
 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 22 matching lines @@
   bool GetMscRate(int32* numerator, int32* denominator) override {
     return false;
   }
 
  private:
   EGLSurface surface_;
 
   DISALLOW_COPY_AND_ASSIGN(EGLSyncControlVSyncProvider);
 };
 
+void DeinitializeEgl() {
+  if (g_initialized) {
+    g_initialized = false;
+    eglTerminate(g_display);
+  }
+}
+
 }  // namespace
 
-GLSurfaceEGL::GLSurfaceEGL() {}
+GLSurfaceEGL::GLSurfaceEGL() {
+  ++g_num_surfaces;
+  if (!g_initialized) {
+    bool result = GLSurfaceEGL::InitializeOneOff();
+    DCHECK(result);
+    DCHECK(g_initialized);
+  }
+}
 
 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;
+  g_terminate_pending = false;
+
   // 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;
 }
 
 EGLDisplay GLSurfaceEGL::GetDisplay() {
+  if (!g_initialized) {

[dcheng, 2014/11/21 03:06:04]

This isn't a static method. How could we get here without initialization already
being triggered?

[GusFernandez, 2014/11/21 19:13:56]

Agreed. This is old code and no longer needed now that we do reference counting
in the constructor/destructor. I did leave a DCHECK there, however.

+    bool result = GLSurfaceEGL::InitializeOneOff();
+    DCHECK(result);
+  }
   return g_display;
 }
 
 EGLDisplay GLSurfaceEGL::GetHardwareDisplay() {
+  if (!g_initialized) {

[dcheng, 2014/11/21 03:06:04]

Why is this safe to do if there are no live GLSurfaceEGL objects live? To me,
the CL description seems to hint that the GPU resources would be owned by
another app if there are no GLSurfaceEGL objects--so it is really safe to
initialize here?

[GusFernandez, 2014/11/21 19:13:56]

Platform ensures that no EGL objects are used by chrome while the external app
owns the GPU. However, there are various entry points which access the EGL
display or NateiveDisplayType besides GLSurface, so this and similar code in
GetNativeDisplay are still needed.

Added //static comments here and below.

[dcheng, 2014/11/21 20:43:00]

I know these are static, but I don't follow the reasoning. It seems like the
whole point of this patch is to deinitialize the GPU while an external app is
using it. Presumably that's because there's an issue with leaving the resources
initialized while another app wants to use them. If that's the case, why is it
safe to re-initialize the GPU resources while an external app might be using
them?

+    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;
 }
 
 bool GLSurfaceEGL::IsEGLSurfacelessContextSupported() {
   return g_egl_surfaceless_context_supported;
 }
 
-GLSurfaceEGL::~GLSurfaceEGL() {}
+void GLSurfaceEGL::DestroyAndTerminateDisplay() {
+  DCHECK(g_initialized);
+  DCHECK_EQ(g_num_surfaces, 1);
+  Destroy();
+  g_terminate_pending = true;
+}
+
+GLSurfaceEGL::~GLSurfaceEGL() {
+  DCHECK_GT(g_num_surfaces, 0) << "Bad surface count";
+  if (--g_num_surfaces == 0 && g_terminate_pending) {

[dcheng, 2014/11/21 03:06:04]

Why isn't this simply gated on --g_num_surfaces == 0 && g_initialized? What
problem does g_terminate_pending solve?

[GusFernandez, 2014/11/21 19:13:56]

This is to resolve a problem with Win GL unit test framework which are expecting
the display to not already be terminated on exit.

[dcheng, 2014/11/21 20:43:00]

Shouldn't we fix the tests, rather than having to hack around it? Makes things
hard to reason about.

+    DeinitializeEgl();
+    g_terminate_pending = false;
+  }
+}
 
 #if defined(OS_WIN)
 static const EGLint kDisplayAttribsWarp[] {
   EGL_PLATFORM_ANGLE_TYPE_ANGLE,
   EGL_PLATFORM_ANGLE_TYPE_D3D11_WARP_ANGLE,
   EGL_NONE
 };
 
 // static
 EGLDisplay GLSurfaceEGL::GetPlatformDisplay(
@@ skipping 476 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gfx