Added switch to disable specified GL extensions.

ui/gl/gl_gl_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_gl_api_implementation.h"
 
 #include <algorithm>
 #include <vector>
 
 #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"
 #include "ui/gl/gl_state_restorer.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/gl_version_info.h"
 
 namespace gfx {
 
@@ skipping 379 matching lines @@
 RealGLApi::RealGLApi() {
 }
 
 RealGLApi::~RealGLApi() {
 }
 
 void RealGLApi::Initialize(DriverGL* driver) {
   InitializeBase(driver);
 }
 
+void RealGLApi::glGetIntegervFn(GLenum pname, GLint* params) {
+  if (pname == GL_NUM_EXTENSIONS) {
+    BuildFilteredExtensions();

[no sievers, 2015/04/29 18:48:10]

Can we do this once from initialization instead of lazily?

[David Yen, 2015/04/29 19:23:09]

Done.

+    *params = static_cast<GLint>(filtered_exts_str_.size());
+    return;
+  }
+  GLApiBase::glGetIntegervFn(pname, params);
+}
+
+const GLubyte* RealGLApi::glGetStringFn(GLenum name) {

[no sievers, 2015/04/29 18:48:10]

You have to do the same thing for VirtualGLApi also or it won't work for virtual
contexts (i.e. most Android devices and Mac).

[David Yen, 2015/04/29 19:23:09]

The VirtualGLApi obtains the list of extensions from its real GLContext in the
constructor which gets it from the RealGLApi. It did this to filter out
GL_EXT_occlusion_query_boolean I believe.

The only thing I was not sure of was whether we should also override
glGetIntegervFn() and glGetStringiFn(), but it seems like this would have been a
problem with GL_EXT_occlusion_query_boolean if that were the case.

[no sievers, 2015/04/30 20:45:02]

Yes, we should fix those functions too. But that should probably be a separate
patch.

[David Yen, 2015/04/30 22:14:17]

Acknowledged.

+  if (name == GL_EXTENSIONS) {
+    BuildFilteredExtensions();
+    return reinterpret_cast<const GLubyte*>(filtered_exts_str_.c_str());
+  }
+  return GLApiBase::glGetStringFn(name);
+}
+
+const GLubyte* RealGLApi::glGetStringiFn(GLenum name, GLuint index) {
+  if (name == GL_EXTENSIONS) {
+    BuildFilteredExtensions();
+    if (index >= filtered_exts_.size()) {
+      return NULL;
+    }
+    return reinterpret_cast<const GLubyte*>(filtered_exts_[index].c_str());
+  }
+  return GLApiBase::glGetStringiFn(name, index);
+}
+
 void RealGLApi::glFlushFn() {
   GLApiBase::glFlushFn();
 }
 
 void RealGLApi::glFinishFn() {
   GLApiBase::glFinishFn();
 }
 
+void RealGLApi::BuildFilteredExtensions() {
+  if (filtered_exts_.empty()) {
+    if (gfx::GetGLImplementation() !=
+        gfx::kGLImplementationDesktopGLCoreProfile) {
+      base::SplitString(
+          reinterpret_cast<const char*>(
+              GLApiBase::glGetStringFn(GL_EXTENSIONS)),
+          ' ',
+          &filtered_exts_);
+    } else {
+      GLint num_extensions = 0;
+      GLApiBase::glGetIntegervFn(GL_NUM_EXTENSIONS, &num_extensions);
+      for (GLint i = 0; i < num_extensions; ++i) {
+        const char* extension = reinterpret_cast<const char*>(
+            GLApiBase::glGetStringiFn(GL_EXTENSIONS, i));
+        DCHECK(extension != NULL);
+        filtered_exts_.push_back(extension);
+      }
+    }
+
+    const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
+    const std::string disabled_extensions = cmd_line->GetSwitchValueASCII(
+        switches::kDisableGLExtensions);
+    if (!disabled_extensions.empty()) {
+      std::vector<std::string> disabled_extensions_list;
+      Tokenize(disabled_extensions, ", ;", &disabled_extensions_list);
+
+      auto ext_iter = filtered_exts_.begin();
+      while (ext_iter != filtered_exts_.end()) {
+        bool filtered = false;

[no sievers, 2015/04/29 18:48:10]

nit:
Is it maybe slightly simpler to iterate over the disabled extensions and for
each std::find() it in the original vector, and erase if found?

[David Yen, 2015/04/29 19:23:09]

I've changed it to use std::remove instead.

+        for (const std::string& disabled_ext : disabled_extensions_list) {
+          if (*ext_iter == disabled_ext) {
+            filtered = true;
+            break;
+          }
+        }
+
+        if (filtered) {
+          ext_iter = filtered_exts_.erase(ext_iter);
+        } else {
+          ++ext_iter;
+        }
+      }
+    }
+
+    filtered_exts_str_ = JoinString(filtered_exts_, " ");
+  }
+}
+
 TraceGLApi::~TraceGLApi() {
 }
 
 NoContextGLApi::NoContextGLApi() {
 }
 
 NoContextGLApi::~NoContextGLApi() {
 }
 
 VirtualGLApi::VirtualGLApi()
@@ skipping 104 matching lines @@
 ScopedSetGLToRealGLApi::ScopedSetGLToRealGLApi()
     : old_gl_api_(GetCurrentGLApi()) {
   SetGLToRealGLApi();
 }
 
 ScopedSetGLToRealGLApi::~ScopedSetGLToRealGLApi() {
   SetGLApi(old_gl_api_);
 }
 
 }  // namespace gfx