Added disabling EGL extensions support with --disable-extensions.

ui/gl/gl_egl_api_implementation.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_egl_api_implementation.h"
+
+#include "base/command_line.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 
 namespace gfx {
 
 RealEGLApi* g_real_egl;
 
 void InitializeStaticGLBindingsEGL() {
   if (!g_real_egl) {
     g_real_egl = new RealEGLApi();
   }
   g_real_egl->Initialize(&g_driver_egl);
   g_current_egl_context = g_real_egl;
   g_driver_egl.InitializeStaticBindings();
 }
 
+void InitializeDynamicGLBindingsEGL(GLContext* context) {

[no sievers, 2015/05/28 19:25:10]

I had actually previously removed the notion of initializing dynamic bindings
for EGL etc. :)

You don't need a context to call eglQueryString, can you do it from the end of
InitializeStaticGLBindingsEGL() instead?

[David Yen, 2015/06/05 23:59:51]

Done.

+  DCHECK(context && context->IsCurrent(NULL));
+  g_real_egl->InitializeWithContext();
+}
+
 void InitializeDebugGLBindingsEGL() {
   g_driver_egl.InitializeDebugBindings();
 }
 
 void ClearGLBindingsEGL() {
   if (g_real_egl) {
     delete g_real_egl;
     g_real_egl = NULL;
   }
   g_current_egl_context = NULL;
@@ skipping 17 matching lines @@
   driver_ = driver;
 }
 
 RealEGLApi::RealEGLApi() {
 }
 
 RealEGLApi::~RealEGLApi() {
 }
 
 void RealEGLApi::Initialize(DriverEGL* driver) {
+  InitializeWithCommandLine(driver, base::CommandLine::ForCurrentProcess());
+}
+
+void RealEGLApi::InitializeWithCommandLine(DriverEGL* driver,
+                                           base::CommandLine* command_line) {
+  DCHECK(command_line);
   InitializeBase(driver);
+
+  const std::string disabled_extensions = command_line->GetSwitchValueASCII(
+      switches::kDisableExtensions);
+  if (!disabled_extensions.empty()) {
+    Tokenize(disabled_extensions, ", ;", &disabled_exts_);
+  }
+}
+
+void RealEGLApi::InitializeWithContext() {
+  InitializeFilteredExtensions();
+}
+
+const char* RealEGLApi::eglQueryStringFn(EGLDisplay dpy, EGLint name) {
+  if (!filtered_exts_.empty() && name == EGL_EXTENSIONS) {
+    return filtered_exts_.c_str();
+  }
+  return EGLApiBase::eglQueryStringFn(dpy, name);
+}
+
+void RealEGLApi::InitializeFilteredExtensions() {
+  if (!disabled_exts_.empty() && filtered_exts_.empty()) {
+    EGLDisplay display = EGLApiBase::eglGetCurrentDisplayFn();
+    std::vector<std::string> extensions_vec;
+    const char* egl_extensions = EGLApiBase::eglQueryStringFn(display,

[no sievers, 2015/05/28 19:25:10]

You can call DriverEGL::GetPlatformExtensions() and
DriverEGL::GetClientExtensions() here (use the combined string). That takes care
of the display.

[David Yen, 2015/06/05 23:59:51]

Done, although I had to make RealEGLApi a friend of DriverEGL since those
functions are private. I combined them like you said and set it up to return no
matter what display is queried, is that correct? It seems like the
ClientExtensions() should be filtered and returned when the display is
EGL_NO_DISPLAY.

+                                                              EGL_EXTENSIONS);
+    if (egl_extensions)
+      base::SplitString(egl_extensions, ' ', &extensions_vec);
+
+    // Filter out extensions from the command line.
+    for (const std::string& disabled_ext : disabled_exts_) {
+      extensions_vec.erase(std::remove(extensions_vec.begin(),
+                                       extensions_vec.end(),
+                                       disabled_ext),
+                           extensions_vec.end());
+    }
+
+    // Construct filtered extensions string for GL_EXTENSIONS string lookups.
+    filtered_exts_ = JoinString(extensions_vec, " ");
+  }
 }
 
 TraceEGLApi::~TraceEGLApi() {
 }
 
 bool GetGLWindowSystemBindingInfoEGL(GLWindowSystemBindingInfo* info) {
   EGLDisplay display = eglGetCurrentDisplay();
   const char* vendor = eglQueryString(display, EGL_VENDOR);
   const char* version = eglQueryString(display, EGL_VERSION);
   const char* extensions = eglQueryString(display, EGL_EXTENSIONS);
   *info = GLWindowSystemBindingInfo();
   if (vendor)
     info->vendor = vendor;
   if (version)
     info->version = version;
   if (extensions)
     info->extensions = extensions;
   return true;
 }
 
 }  // namespace gfx