command_buffer_gles2: Implement EGL default Display as a global object

gpu/command_buffer/tests/egl_test.cc

Index: gpu/command_buffer/tests/egl_test.cc
diff --git a/gpu/command_buffer/tests/egl_test.cc b/gpu/command_buffer/tests/egl_test.cc
index bf7e30e5f81610aafbdf6fa9072756a2f277ea3a..fceffdfbc4e6ba54e2f08eff22f976249948d078 100644
--- a/gpu/command_buffer/tests/egl_test.cc
+++ b/gpu/command_buffer/tests/egl_test.cc
@@ -6,31 +6,621 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include <EGL/egl.h>
+#include <GLES2/gl2.h>
+
+#include "base/bind.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/thread.h"
+#include "gpu/gles2_conform_support/egl/test_support.h"
 
 // This file tests EGL basic interface for command_buffer_gles2, the mode of
 // command buffer where the code is compiled as a standalone dynamic library and
 // exposed through EGL API.
 namespace gpu {
 
-using testing::Test;
+class EGLTest : public testing::Test {
+ public:
+  void TearDown() override;
+};
+
+void EGLTest::TearDown() {
+  EXPECT_TRUE(eglReleaseThread());
+}
+
+TEST_F(EGLTest, OnlyReleaseThread) {}
+
+TEST_F(EGLTest, GetDisplay) {
+  EGLDisplay display1 = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  EXPECT_NE(display1, EGL_NO_DISPLAY);
+
+  EGLDisplay display2 = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  EXPECT_EQ(display1, display2);
+
+  EGLNativeDisplayType invalid_display_type =
+      reinterpret_cast<EGLNativeDisplayType>(0x1);
+  EXPECT_NE(invalid_display_type, EGL_DEFAULT_DISPLAY);
+  EXPECT_EQ(EGL_NO_DISPLAY, eglGetDisplay(invalid_display_type));
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+
+  // eglTerminate can be called with uninitialized display.
+  EXPECT_TRUE(eglTerminate(display1));
+}
+
+TEST_F(EGLTest, GetError) {
+  // GetError returns success.
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+
+  // "calling eglGetError twice without any other intervening EGL calls will
+  // always return EGL_SUCCESS on the second call"
+  EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  EXPECT_NE(display, EGL_NO_DISPLAY);
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+  EXPECT_EQ(nullptr, eglQueryString(display, EGL_EXTENSIONS));
+  EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+
+  EXPECT_TRUE(eglTerminate(display));
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+}
 
-TEST_F(Test, BasicEGLInitialization) {
+TEST_F(EGLTest, Initialize) {
   EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-  ASSERT_NE(display, EGL_NO_DISPLAY);
+  EXPECT_NE(display, EGL_NO_DISPLAY);
 
   // Test for no crash even though passing nullptrs for major, minor.
-  EGLBoolean success = eglInitialize(display, nullptr, nullptr);
-  ASSERT_TRUE(success);
+  EXPECT_TRUE(eglInitialize(display, nullptr, nullptr));
 
   EGLint major = 0;
   EGLint minor = 0;
-  success = eglInitialize(display, &major, &minor);
-  ASSERT_TRUE(success);
-  ASSERT_EQ(major, 1);
-  ASSERT_EQ(minor, 4);
+  EXPECT_TRUE(eglInitialize(display, &major, &minor));
+  EXPECT_EQ(major, 1);
+  EXPECT_EQ(minor, 4);
+
+  EGLDisplay invalid_display = reinterpret_cast<EGLDisplay>(0x1);
+  EXPECT_FALSE(eglInitialize(invalid_display, nullptr, nullptr));
+  EXPECT_EQ(EGL_BAD_DISPLAY, eglGetError());
+}
+
+TEST_F(EGLTest, Terminate) {
+  EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  EXPECT_NE(display, EGL_NO_DISPLAY);
+
+  // eglTerminate can be called multiple times without initialization.
+  EXPECT_TRUE(eglTerminate(display));
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+  EXPECT_TRUE(eglTerminate(display));
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+
+  EXPECT_TRUE(eglInitialize(display, nullptr, nullptr));
+
+  // eglTerminate can be called multiple times.
+  EXPECT_TRUE(eglTerminate(display));
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+  EXPECT_TRUE(eglTerminate(display));
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+
+  // After Terminate, an egl call returns not initialized.
+  EXPECT_EQ(nullptr, eglQueryString(display, EGL_EXTENSIONS));
+  EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
+
+  // Re-initialization of same display.
+  EXPECT_TRUE(eglInitialize(display, nullptr, nullptr));
+  EXPECT_NE(nullptr, eglQueryString(display, EGL_EXTENSIONS));
+  EXPECT_TRUE(eglTerminate(display));
+
+  EGLDisplay invalid_display = reinterpret_cast<EGLDisplay>(0x1);
+  EXPECT_FALSE(eglTerminate(invalid_display));
+  EXPECT_EQ(EGL_BAD_DISPLAY, eglGetError());
+}
+
+TEST_F(EGLTest, QueryString) {
+  EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  EXPECT_NE(display, EGL_NO_DISPLAY);
+  EXPECT_EQ(nullptr, eglQueryString(display, EGL_EXTENSIONS));
+  EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
+  EXPECT_STREQ("", eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS));
+
+  EXPECT_EQ(nullptr, eglQueryString(display, EGL_VERSION));
+  EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
+  EXPECT_STREQ("1.4", eglQueryString(EGL_NO_DISPLAY, EGL_VERSION));
+
+  EXPECT_EQ(nullptr, eglQueryString(display, EGL_CLIENT_APIS));
+  EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
+  EXPECT_EQ(nullptr, eglQueryString(EGL_NO_DISPLAY, EGL_CLIENT_APIS));
+  EXPECT_EQ(EGL_BAD_DISPLAY, eglGetError());
+  EXPECT_EQ(nullptr, eglQueryString(display, EGL_VENDOR));
+  EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
+  EXPECT_EQ(nullptr, eglQueryString(EGL_NO_DISPLAY, EGL_VENDOR));
+  EXPECT_EQ(EGL_BAD_DISPLAY, eglGetError());
+
+  EXPECT_TRUE(eglInitialize(display, nullptr, nullptr));
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+
+  EXPECT_STREQ("", eglQueryString(display, EGL_EXTENSIONS));
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+  EXPECT_STREQ("1.4", eglQueryString(display, EGL_VERSION));
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+  EXPECT_STREQ("OpenGL_ES", eglQueryString(display, EGL_CLIENT_APIS));
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+  EXPECT_STREQ("Google Inc.", eglQueryString(display, EGL_VENDOR));
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+}
+
+TEST_F(EGLTest, GetConfigsUninitialized) {
+  EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  EXPECT_NE(display, EGL_NO_DISPLAY);
+
+  EGLint num_config = 0;
+  const int kConfigsSize = 5;
+  EGLConfig configs[kConfigsSize] = {
+      0,
+  };
+
+  EXPECT_FALSE(eglGetConfigs(display, configs, kConfigsSize, &num_config));
+  EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
+
+  EXPECT_FALSE(eglGetConfigs(display, configs, kConfigsSize, nullptr));
+  EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
+}
+
+TEST_F(EGLTest, ChooseConfigUninitialized) {
+  EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  EXPECT_NE(display, EGL_NO_DISPLAY);
+
+  EGLint num_config = 0;
+  EGLint attrib_list[] = {EGL_NONE};
+  const int kConfigsSize = 5;
+  EGLConfig configs[kConfigsSize] = {
+      0,
+  };
+
+  EXPECT_FALSE(eglChooseConfig(display, attrib_list, configs, kConfigsSize,
+                               &num_config));
+  EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
+
+  EXPECT_FALSE(
+      eglChooseConfig(display, attrib_list, configs, kConfigsSize, nullptr));
+  EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
+}
+
+class EGLConfigTest : public EGLTest {
+ public:
+  void SetUp() override;
+
+ protected:
+  void CheckConfigsExist(EGLint num_config);
+
+  enum { kConfigsSize = 5 };
+  EGLDisplay display_;
+  EGLConfig configs_[kConfigsSize];
+};
+
+void EGLConfigTest::SetUp() {
+  display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  ASSERT_NE(display_, EGL_NO_DISPLAY);
+  EXPECT_TRUE(eglInitialize(display_, nullptr, nullptr));
+  memset(configs_, 0, sizeof(configs_));
+}
+
+void EGLConfigTest::CheckConfigsExist(EGLint num_config) {
+  EGLint i;
+  if (num_config > kConfigsSize)
+    num_config = static_cast<EGLint>(kConfigsSize);
+  for (i = 0; i < num_config; ++i)
+    EXPECT_NE(nullptr, configs_[i]);
+  for (; i < kConfigsSize; ++i)
+    EXPECT_EQ(nullptr, configs_[i]);
+}
+
+TEST_F(EGLConfigTest, GetConfigsBadNumConfigs) {
+  EXPECT_FALSE(eglGetConfigs(display_, configs_, kConfigsSize, nullptr));
+  EXPECT_EQ(EGL_BAD_PARAMETER, eglGetError());
+}
+
+TEST_F(EGLConfigTest, GetConfigsNullConfigs) {
+  EGLint num_config = 0;
+  EXPECT_TRUE(eglGetConfigs(display_, nullptr, 55, &num_config));
+  EXPECT_GT(num_config, 0);
+}
+
+TEST_F(EGLConfigTest, GetConfigsZeroConfigsSize) {
+  EGLint num_config = 0;
+  EXPECT_TRUE(eglGetConfigs(display_, configs_, 0, &num_config));
+  EXPECT_GT(num_config, 0);
+  EXPECT_EQ(nullptr, configs_[0]);
+}
+
+TEST_F(EGLConfigTest, GetConfigs) {
+  EGLint num_config = 0;
+  EXPECT_TRUE(eglGetConfigs(display_, configs_, kConfigsSize, &num_config));
+  EXPECT_GT(num_config, 0);
+  CheckConfigsExist(num_config);
+}
+
+TEST_F(EGLConfigTest, ChooseConfigBadNumConfigs) {
+  EGLint attrib_list[] = {EGL_NONE};
+  EXPECT_FALSE(
+      eglChooseConfig(display_, attrib_list, configs_, kConfigsSize, nullptr));
+  EXPECT_EQ(EGL_BAD_PARAMETER, eglGetError());
+}
+
+TEST_F(EGLConfigTest, ChooseConfigNullConfigs) {
+  EGLint num_config = 0;
+  EGLint attrib_list[] = {EGL_NONE};
+  EXPECT_TRUE(eglChooseConfig(display_, attrib_list, nullptr, 55, &num_config));
+  EXPECT_GT(num_config, 0);
+}
+
+TEST_F(EGLConfigTest, ChooseConfigZeroConfigsSize) {
+  EGLint num_config = 0;
+  EGLint attrib_list[] = {EGL_NONE};
+  EXPECT_TRUE(eglChooseConfig(display_, attrib_list, configs_, 0, &num_config));
+  EXPECT_GT(num_config, 0);
+  EXPECT_EQ(nullptr, configs_[0]);
+}
+
+TEST_F(EGLConfigTest, ChooseConfig) {
+  EGLint num_config = 0;
+  EGLint attrib_list[] = {EGL_NONE};
+  EXPECT_TRUE(eglChooseConfig(display_, attrib_list, configs_, kConfigsSize,
+                              &num_config));
+  EXPECT_GT(num_config, 0);
+  CheckConfigsExist(num_config);
+}
+
+TEST_F(EGLConfigTest, ChooseConfigInvalidAttrib) {
+  const EGLint kNotModified = 55;
+  EGLint num_config = kNotModified;
+  EGLint invalid_attrib_list[] = {0xABCD};
+  EXPECT_FALSE(eglChooseConfig(display_, invalid_attrib_list, configs_,
+                               kConfigsSize, &num_config));
+  EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError());
+  EXPECT_EQ(kNotModified, num_config);
+}
+
+TEST_F(EGLConfigTest, ChooseConfigWindow) {
+  EGLint num_config = 0;
+  EGLint attrib_list[] = {EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_NONE};
+  EXPECT_TRUE(eglChooseConfig(display_, attrib_list, configs_, kConfigsSize,
+                              &num_config));
+  EXPECT_GT(num_config, 0);
+  for (int i = 0; i < num_config; ++i) {
+    EGLint value = EGL_NONE;
+    eglGetConfigAttrib(display_, configs_[i], EGL_SURFACE_TYPE, &value);
+    EXPECT_NE(0, value & EGL_WINDOW_BIT);
+  }
+}
+
+TEST_F(EGLConfigTest, ChooseConfigPBuffer) {
+  EGLint num_config = 0;
+  EGLint attrib_list[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_NONE};
+  EXPECT_TRUE(eglChooseConfig(display_, attrib_list, configs_, kConfigsSize,
+                              &num_config));
+  EXPECT_GT(num_config, 0);
+  for (int i = 0; i < num_config; ++i) {
+    EGLint value = EGL_NONE;
+    eglGetConfigAttrib(display_, configs_[0], EGL_SURFACE_TYPE, &value);
+    EXPECT_NE(0, value & EGL_PBUFFER_BIT);
+  }
+}
+
+TEST_F(EGLConfigTest, ChooseConfigWindowPBufferNotPossible) {
+  EGLint num_config = 0;
+  EGLint attrib_list[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT | EGL_WINDOW_BIT,
+                          EGL_NONE};
+  EXPECT_TRUE(eglChooseConfig(display_, attrib_list, configs_, kConfigsSize,
+                              &num_config));
+  EXPECT_EQ(0, num_config);
+}
+
+TEST_F(EGLConfigTest, ChooseConfigBugExample) {
+  static const EGLint kConfigAttribs[] = {
+      EGL_RED_SIZE,       8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE,    8,
+      EGL_ALPHA_SIZE,     8, EGL_DEPTH_SIZE, 8, EGL_STENCIL_SIZE, 8,
+      EGL_SAMPLE_BUFFERS, 1, EGL_SAMPLES,    4, EGL_NONE};
+  EGLint num_config = 0;
+  EXPECT_TRUE(eglChooseConfig(display_, kConfigAttribs, configs_, kConfigsSize,
+                              &num_config));
+
+  // The EGL attribs are not really implemented at the moment.
+  EGLint value = EGL_NONE;
+  EXPECT_TRUE(eglGetConfigAttrib(display_, configs_[0], EGL_RED_SIZE, &value));
+  EXPECT_EQ(0, value);
+}
+
+TEST_F(EGLTest, MakeCurrent) {
+  EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  EXPECT_NE(display, EGL_NO_DISPLAY);
+  // "This is the only case where an uninitialized display may be passed to
+  //  eglMakeCurrent."
+  EXPECT_TRUE(
+      eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
+  EGLDisplay invalid_display = reinterpret_cast<EGLDisplay>(0x1);
+  EXPECT_FALSE(eglMakeCurrent(invalid_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
+                              EGL_NO_CONTEXT));
+  EXPECT_EQ(EGL_BAD_DISPLAY, eglGetError());
+
+  EXPECT_TRUE(eglInitialize(display, nullptr, nullptr));
+  EXPECT_TRUE(
+      eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
+  EXPECT_FALSE(eglMakeCurrent(invalid_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
+                              EGL_NO_CONTEXT));
+}
+
+class EGLSurfaceTest : public EGLTest {
+ public:
+  void SetUp() override;
+  void CreateSurfaceAndContext(EGLSurface* surface, EGLContext* context);
+
+ protected:
+  EGLDisplay display_;
+};
+
+void EGLSurfaceTest::SetUp() {
+  EGLTest::SetUp();
+  display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  EXPECT_TRUE(eglInitialize(display_, nullptr, nullptr));
+}
+
+void EGLSurfaceTest::CreateSurfaceAndContext(EGLSurface* surface,
+                                             EGLContext* context) {
+  static const EGLint config_attribs[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
+                                          EGL_NONE};
+  EGLint num_config;
+  EGLConfig config;
+  EXPECT_TRUE(
+      eglChooseConfig(display_, config_attribs, &config, 1, &num_config));
+  ASSERT_GT(num_config, 0);
+  static const EGLint surface_attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1,
+                                           EGL_NONE};
+  *surface = eglCreatePbufferSurface(display_, config, surface_attribs);
+  static const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2,
+                                           EGL_NONE};
+  *context = eglCreateContext(display_, config, nullptr, context_attribs);
+}
+
+class EGLMultipleSurfacesContextsTest : public EGLSurfaceTest {
+ public:
+  void SetUp() override;
+  void TearDown() override;
+
+ protected:
+  EGLSurface surface1_;
+  EGLSurface surface2_;
+  EGLContext context1_;
+  EGLContext context2_;
+};
+
+void EGLMultipleSurfacesContextsTest::SetUp() {
+  EGLSurfaceTest::SetUp();
+  CreateSurfaceAndContext(&surface1_, &context1_);
+  CreateSurfaceAndContext(&surface2_, &context2_);
+  EXPECT_NE(EGL_NO_SURFACE, surface1_);
+  EXPECT_NE(EGL_NO_SURFACE, surface2_);
+  EXPECT_NE(surface1_, surface2_);
+  EXPECT_NE(EGL_NO_CONTEXT, context1_);
+  EXPECT_NE(EGL_NO_CONTEXT, context2_);
+  EXPECT_NE(context1_, context2_);
+}
+
+void EGLMultipleSurfacesContextsTest::TearDown() {
+  EXPECT_TRUE(eglDestroyContext(display_, context1_));
+  EXPECT_TRUE(eglDestroySurface(display_, surface1_));
+  EXPECT_TRUE(eglDestroyContext(display_, context2_));
+  EXPECT_TRUE(eglDestroySurface(display_, surface2_));
+  EGLTest::TearDown();
+}
+
+TEST_F(EGLMultipleSurfacesContextsTest, NoMakeCurrent) {}
+
+TEST_F(EGLMultipleSurfacesContextsTest, MakeCurrentSurfaces) {
+  EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context1_));
+  EXPECT_TRUE(eglMakeCurrent(display_, surface2_, surface2_, context2_));
+  EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context2_));
+  EXPECT_TRUE(eglMakeCurrent(display_, surface2_, surface2_, context1_));
+}
+
+TEST_F(EGLMultipleSurfacesContextsTest, MakeCurrentSameSurface1) {
+  EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context1_));
+  EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context2_));
+}
+
+TEST_F(EGLMultipleSurfacesContextsTest, MakeCurrentSameSurface2) {
+  EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context1_));
+  EXPECT_TRUE(eglMakeCurrent(display_, surface2_, surface2_, context1_));
+  EXPECT_TRUE(eglMakeCurrent(display_, surface2_, surface2_, context2_));
+}
+
+TEST_F(EGLMultipleSurfacesContextsTest, MakeCurrentSurfacesAndReleases) {
+  EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context1_));
+  EXPECT_TRUE(
+      eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
+  EXPECT_TRUE(eglMakeCurrent(display_, surface2_, surface2_, context2_));
+  EXPECT_TRUE(
+      eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
+  EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context2_));
+  EXPECT_TRUE(
+      eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
+  EXPECT_TRUE(eglMakeCurrent(display_, surface2_, surface2_, context1_));
+  EXPECT_TRUE(
+      eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
+}
+
+TEST_F(EGLMultipleSurfacesContextsTest, MakeCurrentSurfaceFails) {
+  EXPECT_FALSE(eglMakeCurrent(display_, surface1_, surface1_, EGL_NO_CONTEXT));
+  EXPECT_EQ(EGL_BAD_CONTEXT, eglGetError());
+  EXPECT_FALSE(eglMakeCurrent(display_, surface1_, EGL_NO_SURFACE, context1_));
+  EXPECT_EQ(EGL_BAD_SURFACE, eglGetError());
+  EXPECT_FALSE(eglMakeCurrent(display_, EGL_NO_SURFACE, surface1_, context1_));
+  EXPECT_EQ(EGL_BAD_SURFACE, eglGetError());
+
+  EGLDisplay invalid_display = reinterpret_cast<EGLDisplay>(0x1);
+  EGLSurface invalid_surface = reinterpret_cast<EGLSurface>(0x1);
+  EGLSurface invalid_context = reinterpret_cast<EGLContext>(0x1);
+  EXPECT_FALSE(
+      eglMakeCurrent(invalid_display, surface1_, surface1_, context1_));
+  EXPECT_EQ(EGL_BAD_DISPLAY, eglGetError());
+  EXPECT_FALSE(eglMakeCurrent(display_, surface1_, surface1_, invalid_context));
+  EXPECT_EQ(EGL_BAD_CONTEXT, eglGetError());
+  EXPECT_FALSE(eglMakeCurrent(display_, surface1_, invalid_surface, context1_));
+  EXPECT_EQ(EGL_BAD_SURFACE, eglGetError());
+  EXPECT_FALSE(eglMakeCurrent(display_, invalid_surface, surface1_, context1_));
+  EXPECT_EQ(EGL_BAD_SURFACE, eglGetError());
+
+  // Command buffer limitation:
+  // Different read and draw surfaces fail.
+  EXPECT_FALSE(eglMakeCurrent(display_, surface1_, surface2_, context1_));
+  EXPECT_EQ(EGL_BAD_MATCH, eglGetError());
+}
+
+TEST_F(EGLMultipleSurfacesContextsTest, CallGLOnMultipleContextNoCrash) {
+  EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context1_));
+
+  typedef void(GL_APIENTRY * glEnableProc)(GLenum);
+  glEnableProc glEnable =
+      reinterpret_cast<glEnableProc>(eglGetProcAddress("glEnable"));
+  EXPECT_NE(nullptr, glEnable);
+
+  glEnable(GL_BLEND);
+
+  EXPECT_TRUE(eglMakeCurrent(display_, surface2_, surface2_, context2_));
+  glEnable(GL_BLEND);
+}
+
+class EGLThreadTest : public EGLSurfaceTest {
+ public:
+  EGLThreadTest();
+  void SetUp() override;
+  void TearDown() override;
+  void OtherThreadTearDown(base::WaitableEvent*);
+  void OtherThreadMakeCurrent(EGLSurface surface,
+                              EGLContext context,
+                              EGLBoolean* result,
+                              base::WaitableEvent*);
+  void OtherThreadGetError(EGLint* result, base::WaitableEvent*);
+
+ protected:
+  base::Thread other_thread_;
+};
+
+EGLThreadTest::EGLThreadTest()
+    : EGLSurfaceTest(), other_thread_("EGLThreadTest thread") {}
+void EGLThreadTest::SetUp() {
+  EGLSurfaceTest::SetUp();
+  other_thread_.Start();
+}
+
+void EGLThreadTest::TearDown() {
+  base::WaitableEvent completion(true, false);
+  other_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&EGLThreadTest::OtherThreadTearDown,
+                            base::Unretained(this), &completion));
+  completion.Wait();
+  other_thread_.Stop();
+  EGLSurfaceTest::TearDown();
+}
+
+void EGLThreadTest::OtherThreadTearDown(base::WaitableEvent* completion) {
+  EXPECT_TRUE(eglReleaseThread());
+  completion->Signal();
+}
+
+void EGLThreadTest::OtherThreadMakeCurrent(EGLSurface surface,
+                                           EGLContext context,
+                                           EGLBoolean* result,
+                                           base::WaitableEvent* completion) {
+  *result = eglMakeCurrent(display_, surface, surface, context);
+  completion->Signal();
+}
+
+void EGLThreadTest::OtherThreadGetError(EGLint* result,
+                                        base::WaitableEvent* completion) {
+  *result = eglGetError();
+  completion->Signal();
+}
+
+TEST_F(EGLThreadTest, OnlyReleaseThreadInOther) {}
+
+TEST_F(EGLThreadTest, Basic) {
+  EGLSurface surface;
+  EGLContext context;
+  CreateSurfaceAndContext(&surface, &context);
+  EXPECT_NE(EGL_NO_SURFACE, surface);
+  EXPECT_NE(EGL_NO_CONTEXT, context);
+
+  EXPECT_TRUE(eglMakeCurrent(display_, surface, surface, context));
+
+  base::WaitableEvent completion(false, false);
+
+  EGLBoolean result = EGL_FALSE;
+  other_thread_.task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&EGLThreadTest::OtherThreadMakeCurrent, base::Unretained(this),
+                 surface, context, &result, &completion));
+  completion.Wait();
+  EXPECT_FALSE(result);
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+
+  EGLint error = EGL_NONE;
+  other_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&EGLThreadTest::OtherThreadGetError,
+                            base::Unretained(this), &error, &completion));
+  completion.Wait();
+  EXPECT_EQ(EGL_BAD_ACCESS, error);
+  EXPECT_EQ(EGL_SUCCESS, eglGetError());
+
+  other_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&EGLThreadTest::OtherThreadGetError,
+                            base::Unretained(this), &error, &completion));
+  completion.Wait();
+  EXPECT_EQ(EGL_SUCCESS, error);
+
+  EXPECT_TRUE(
+      eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
+
+  other_thread_.task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&EGLThreadTest::OtherThreadMakeCurrent, base::Unretained(this),
+                 surface, context, &result, &completion));
+  completion.Wait();
+  EXPECT_TRUE(result);
+
+  EXPECT_FALSE(eglMakeCurrent(display_, surface, surface, context));
+  EXPECT_EQ(EGL_BAD_ACCESS, eglGetError());
+
+  EXPECT_TRUE(eglDestroySurface(display_, surface));
+  EXPECT_TRUE(eglDestroyContext(display_, context));
+}
+
+TEST_F(EGLTest, WindowlessNativeWindows) {
+  EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  EXPECT_TRUE(eglInitialize(display, nullptr, nullptr));
+
+  static const EGLint config_attribs[] = {EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+                                          EGL_NONE};
+  EGLint num_config;
+  EGLConfig config;
+  EXPECT_TRUE(
+      eglChooseConfig(display, config_attribs, &config, 1, &num_config));
+  ASSERT_GT(num_config, 0);
+  static const EGLint surface_attribs[] = {EGL_NONE};
+  CommandBufferGLESSetNextCreateWindowSurfaceCreatesPBuffer(display, 100, 100);
+  EGLNativeWindowType win = 0;
+  EGLSurface surface =
+      eglCreateWindowSurface(display, config, win, surface_attribs);
+  EXPECT_NE(EGL_NO_SURFACE, surface);
+
+  // Test that SwapBuffers can be called on windowless window surfaces.
+
+  static const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2,
+                                           EGL_NONE};
+  EGLContext context =
+      eglCreateContext(display, config, nullptr, context_attribs);
+  EXPECT_TRUE(eglMakeCurrent(display, surface, surface, context));
+  EXPECT_TRUE(eglSwapBuffers(display, surface));
 
-  success = eglTerminate(display);
-  ASSERT_TRUE(success);
+  EXPECT_TRUE(eglDestroySurface(display, surface));
+  EXPECT_TRUE(eglDestroyContext(display, context));
 }
 
 }  // namespace gpu