Remove GPU relinquish resources infrastructure and stop GPU process.

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 67 matching lines @@
 unsigned int NativeViewGLSurfaceEGL::swaps_this_generation_ = 0;
 unsigned int NativeViewGLSurfaceEGL::last_multiswap_generation_ = 0;
 
 const unsigned int MULTISWAP_FRAME_VSYNC_THRESHOLD = 60;
 #endif
 
 namespace {
 
 EGLConfig g_config;
 EGLDisplay g_display;
-EGLNativeDisplayType g_native_display_type;
-
-// In the Cast environment, we need to destroy the EGLNativeDisplayType and
-// EGLDisplay 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;
+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;
 
 class EGLSyncControlVSyncProvider
     : public gfx::SyncControlVSyncProvider {
  public:
@@ skipping 23 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);
-  }
-}
-
 EGLDisplay GetPlatformANGLEDisplay(EGLNativeDisplayType native_display,
                                    EGLenum platform_type,
                                    bool warpDevice) {
   std::vector<EGLint> display_attribs;
 
   display_attribs.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE);
   display_attribs.push_back(platform_type);
 
   if (warpDevice) {
     display_attribs.push_back(EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE);
@@ skipping 105 matching lines @@
     }
   }
 
   // If no displays are available due to missing angle extensions or invalid
   // flags, request the default display.
   if (init_displays->empty()) {
     init_displays->push_back(DEFAULT);
   }
 }
 
-GLSurfaceEGL::GLSurfaceEGL() {
-  ++g_num_surfaces;
-  if (!g_initialized) {
-    bool result = GLSurfaceEGL::InitializeOneOff();
-    DCHECK(result);
-    DCHECK(g_initialized);
-  }
-}
+GLSurfaceEGL::GLSurfaceEGL() {}
 
 bool GLSurfaceEGL::InitializeOneOff() {
-  if (g_initialized)
+  static bool initialized = false;
+  if (initialized)
     return true;
 
   InitializeDisplay();
   if (g_display == EGL_NO_DISPLAY)
     return false;
 
   // Choose an EGL configuration.
   // On X this is only used for PBuffer surfaces.
   EGLint renderable_type = EGL_OPENGL_ES2_BIT;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 46 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() {
-  DCHECK(g_initialized);
   return g_display;
 }
 
-// static
 EGLDisplay GLSurfaceEGL::GetHardwareDisplay() {
-  if (!g_initialized) {
-    bool result = GLSurfaceEGL::InitializeOneOff();
-    DCHECK(result);
-  }
   return g_display;
 }
 
-// static
 EGLNativeDisplayType GLSurfaceEGL::GetNativeDisplay() {
-  if (!g_initialized) {
-    bool result = GLSurfaceEGL::InitializeOneOff();
-    DCHECK(result);
-  }
-  return g_native_display_type;
+  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;
 }
 
-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) {
-    DeinitializeEgl();
-    g_terminate_pending = false;
-  }
-}
+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;
   }
 
-  g_native_display_type = GetPlatformDefaultEGLNativeDisplay();
+  g_native_display = GetPlatformDefaultEGLNativeDisplay();
 
   // If EGL_EXT_client_extensions not supported this call to eglQueryString
   // will return NULL.
   const char* client_extensions =
       eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
 
   bool supports_angle_d3d = false;
   bool supports_angle_opengl = false;
   // Check for availability of ANGLE extensions.
   if (client_extensions &&
       ExtensionsContain(client_extensions, "EGL_ANGLE_platform_angle")) {
     supports_angle_d3d =
         ExtensionsContain(client_extensions, "EGL_ANGLE_platform_angle_d3d");
     supports_angle_opengl =
         ExtensionsContain(client_extensions, "EGL_ANGLE_platform_angle_opengl");
   }
 
   std::vector<DisplayType> init_displays;
   GetEGLInitDisplays(supports_angle_d3d, supports_angle_opengl,
                      base::CommandLine::ForCurrentProcess(), &init_displays);
 
   for (size_t disp_index = 0; disp_index < init_displays.size(); ++disp_index) {
     DisplayType display_type = init_displays[disp_index];
     EGLDisplay display =
-        GetDisplayFromType(display_type, g_native_display_type);
+        GetDisplayFromType(display_type, g_native_display);
     if (display == EGL_NO_DISPLAY) {
       LOG(ERROR) << "EGL display query failed with error "
                  << GetLastEGLErrorString();
     }
 
     if (!eglInitialize(display, nullptr, nullptr)) {
       bool is_last = disp_index == init_displays.size() - 1;
 
       LOG(ERROR) << "eglInitialize " << DisplayTypeString(display_type)
                  << " failed with error " << GetLastEGLErrorString()
@@ skipping 475 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gfx