Remove GetPlatformDefaultEGLNativeDisplay() function.

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 <map>
@@ skipping 98 matching lines @@
 #if defined(OS_WIN)
 unsigned int NativeViewGLSurfaceEGL::current_swap_generation_ = 0;
 unsigned int NativeViewGLSurfaceEGL::swaps_this_generation_ = 0;
 unsigned int NativeViewGLSurfaceEGL::last_multiswap_generation_ = 0;
 
 const unsigned int MULTISWAP_FRAME_VSYNC_THRESHOLD = 60;
 #endif
 
 namespace {
 
-EGLDisplay g_display;
-EGLNativeDisplayType g_native_display;
+EGLDisplay g_display = EGL_NO_DISPLAY;
+EGLNativeDisplayType g_native_display = EGL_DEFAULT_DISPLAY;
 
-const char* g_egl_extensions = NULL;
+const char* g_egl_extensions = nullptr;
 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 SyncControlVSyncProvider {
  public:
   explicit EGLSyncControlVSyncProvider(EGLSurface surface)
@@ skipping 307 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() {}
 
-bool GLSurfaceEGL::InitializeOneOff() {
+GLSurface::Format GLSurfaceEGL::GetFormat() {
+  return format_;
+}
+
+EGLDisplay GLSurfaceEGL::GetDisplay() {
+  return g_display;
+}
+
+EGLConfig GLSurfaceEGL::GetConfig() {
+  if (!config_) {
+    config_ = ChooseConfig(format_);
+  }
+  return config_;
+}
+
+// static
+bool GLSurfaceEGL::InitializeOneOff(EGLNativeDisplayType native_display) {
   static bool initialized = false;
   if (initialized)
     return true;
 
-  InitializeDisplay();
+  // Must be called before InitializeDisplay().
+  g_driver_egl.InitializeClientExtensionBindings();
+
+  InitializeDisplay(native_display);
   if (g_display == EGL_NO_DISPLAY)
     return false;
 
+  // Must be called after InitializeDisplay().
+  g_driver_egl.InitializeExtensionBindings();
+
   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");
 
@@ skipping 32 matching lines @@
       context->ReleaseCurrent(surface.get());
     }
   }
 #endif
 
   initialized = true;
 
   return true;
 }
 
-GLSurface::Format GLSurfaceEGL::GetFormat() {
-  return format_;
-}
-
-EGLDisplay GLSurfaceEGL::GetDisplay() {
-  return g_display;
-}
-
-EGLConfig GLSurfaceEGL::GetConfig() {
-  if (!config_) {
-    config_ = ChooseConfig(format_);
-  }
-  return config_;
-}
-
+// static
 EGLDisplay GLSurfaceEGL::GetHardwareDisplay() {
   return g_display;
 }
 
+// static
 EGLNativeDisplayType GLSurfaceEGL::GetNativeDisplay() {
   return g_native_display;
 }
 
+// static
 const char* GLSurfaceEGL::GetEGLExtensions() {
   return g_egl_extensions;
 }
 
+// static
 bool GLSurfaceEGL::HasEGLExtension(const char* name) {
   return ExtensionsContain(GetEGLExtensions(), name);
 }
 
+// static
 bool GLSurfaceEGL::IsCreateContextRobustnessSupported() {
   return g_egl_create_context_robustness_supported;
 }
 
+// static
 bool GLSurfaceEGL::IsEGLSurfacelessContextSupported() {
   return g_egl_surfaceless_context_supported;
 }
 
+// static
 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() {
+EGLDisplay GLSurfaceEGL::InitializeDisplay(
+    EGLNativeDisplayType native_display) {
   if (g_display != EGL_NO_DISPLAY) {
     return g_display;
   }
 
-  g_native_display = GetPlatformDefaultEGLNativeDisplay();
+  g_native_display = native_display;
 
   // 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 &&
@@ skipping 550 matching lines @@
 }
 
 void* SurfacelessEGL::GetShareHandle() {
   return NULL;
 }
 
 SurfacelessEGL::~SurfacelessEGL() {
 }
 
 }  // namespace gl