Added switch to disable specified GL extensions.

ui/gl/gl_api_unittest.cc

Index: ui/gl/gl_api_unittest.cc
diff --git a/ui/gl/gl_api_unittest.cc b/ui/gl/gl_api_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f58a59d5d4c722c6db7927253c714ca41c5c0767
--- /dev/null
+++ b/ui/gl/gl_api_unittest.cc
@@ -0,0 +1,139 @@
+// Copyright 2015 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 "base/command_line.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gl/gl_gl_api_implementation.h"
+#include "ui/gl/gl_surface.h"

[no sievers, 2015/05/01 21:54:59]

nit: gl_surface.h not needed. what about string_util/split above?

[David Yen, 2015/05/01 22:34:38]

Done.

+#include "ui/gl/gl_switches.h"
+
+namespace gfx {
+
+class GLApiTest : public testing::Test {
+ public:
+  void SetUp() override {
+    g_fake_extension_string = "";

[no sievers, 2015/05/01 21:55:00]

nit: no "g_" prefix here and for other static variables since they are not in
the global namespace

[David Yen, 2015/05/01 22:34:38]

Done.

+    g_num_fake_extension_strings = 0;
+    g_fake_extension_strings = nullptr;
+
+    driver_.fn.glGetStringFn = &FakeGetString;
+    driver_.fn.glGetStringiFn = &FakeGetStringi;
+    driver_.fn.glGetIntegervFn = &FakeGetIntegervFn;
+  }
+
+  void TearDown() override {
+    SetGLImplementation(kGLImplementationNone);
+    g_fake_extension_string = "";
+    g_num_fake_extension_strings = 0;
+    g_fake_extension_strings = nullptr;
+  }
+
+  void SetFakeExtensionString(const char* fake_string) {
+    SetGLImplementation(kGLImplementationDesktopGL);
+    g_fake_extension_string = fake_string;
+  }
+
+  void SetFakeExtensionStrings(const char** fake_strings, uint32_t count) {
+    SetGLImplementation(kGLImplementationDesktopGLCoreProfile);
+    g_num_fake_extension_strings = count;
+    g_fake_extension_strings = fake_strings;
+  }
+
+  static const GLubyte* FakeGetString(GLenum name) {
+    return reinterpret_cast<const GLubyte*>(g_fake_extension_string);
+  }
+
+  static void FakeGetIntegervFn(GLenum pname, GLint* params) {
+    *params = g_num_fake_extension_strings;
+  }
+
+  static const GLubyte* FakeGetStringi(GLenum name, GLuint index) {
+    return (index < g_num_fake_extension_strings) ?
+           reinterpret_cast<const GLubyte*>(g_fake_extension_strings[index]) :
+           nullptr;
+  }
+
+  const char* GetExtensions() {
+    return reinterpret_cast<const char*>(api_.glGetStringFn(GL_EXTENSIONS));
+  }
+
+  uint32_t GetNumExtensions() {
+    GLint num_extensions = 0;
+    api_.glGetIntegervFn(GL_NUM_EXTENSIONS, &num_extensions);
+    return static_cast<uint32_t>(num_extensions);
+  }
+
+  const char* GetExtensioni(uint32_t index) {
+    return reinterpret_cast<const char*>(api_.glGetStringiFn(GL_EXTENSIONS,
+                                                             index));
+  }
+
+ protected:
+  static const char* g_fake_extension_string;
+
+  static uint32_t g_num_fake_extension_strings;

[no sievers, 2015/05/01 21:55:00]

Actually can you make them non-static since you are modifying them in the test?

[David Yen, 2015/05/01 22:34:38]

They are being modified in static functions so they need to be static. I could
put them all in another class that gets instantiated statically maybe, but that
is more of a style difference I think.

[no sievers, 2015/05/01 22:44:49]

Why do the functions have to be static? If they are protected the test will be
able to access member functions and variables.

[David Yen, 2015/05/01 22:46:03]

FakeGetString, FakeGetIntegervFn, FakeGetStringi are used as function pointers
to set into the driver.

+  static const char** g_fake_extension_strings;
+
+  DriverGL driver_;
+  RealGLApi api_;
+};
+
+const char* GLApiTest::g_fake_extension_string = "";
+
+uint32_t GLApiTest::g_num_fake_extension_strings = 0;
+const char** GLApiTest::g_fake_extension_strings = nullptr;
+
+TEST_F(GLApiTest, DisabledExtensionStringTest) {
+  static const char* kFakeExtensions = "GL_EXT_1 GL_EXT_2 GL_EXT_3 GL_EXT_4";
+  static const char* kFakeDisabledExtensions = "GL_EXT_1,GL_EXT_2,GL_FAKE";
+  static const char* kFilteredExtensions = "GL_EXT_3 GL_EXT_4";
+
+  SetFakeExtensionString(kFakeExtensions);
+  api_.Initialize(&driver_);
+
+  EXPECT_STREQ(kFakeExtensions, GetExtensions());
+
+  base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
+  command_line.AppendSwitchASCII(switches::kDisableGLExtensions,
+                                 kFakeDisabledExtensions);
+  api_.InitializeWithCommandLine(&driver_, &command_line);
+
+  EXPECT_STREQ(kFilteredExtensions, GetExtensions());
+}
+
+TEST_F(GLApiTest, DisabledExtensionStringIndexTest) {
+  static const char* kFakeExtensions[] = {
+    "GL_EXT_1",
+    "GL_EXT_2",
+    "GL_EXT_3",
+    "GL_EXT_4"
+  };
+  static const char* kFakeDisabledExtensions = "GL_EXT_1,GL_EXT_2,GL_FAKE";
+  static const char* kFilteredExtensions[] = {
+    "GL_EXT_3",
+    "GL_EXT_4"
+  };
+
+  SetFakeExtensionStrings(kFakeExtensions, arraysize(kFakeExtensions));
+  api_.Initialize(&driver_);
+
+  EXPECT_EQ(arraysize(kFakeExtensions), GetNumExtensions());
+  for (uint32_t i = 0; i < arraysize(kFakeExtensions); ++i) {
+    EXPECT_STREQ(kFakeExtensions[i], GetExtensioni(i));
+  }
+
+  base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
+  command_line.AppendSwitchASCII(switches::kDisableGLExtensions,
+                                 kFakeDisabledExtensions);
+  api_.InitializeWithCommandLine(&driver_, &command_line);
+
+  EXPECT_EQ(arraysize(kFilteredExtensions), GetNumExtensions());
+  for (uint32_t i = 0; i < arraysize(kFilteredExtensions); ++i) {
+    EXPECT_STREQ(kFilteredExtensions[i], GetExtensioni(i));
+  }
+}
+
+}  // namespace gpu