egl_test.cc 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635
  1. // Copyright 2015 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "testing/gmock/include/gmock/gmock.h"
  5. #include "testing/gtest/include/gtest/gtest.h"
  6. #include <EGL/egl.h>
  7. #include <GLES2/gl2.h>
  8. #include "base/bind.h"
  9. #include "base/synchronization/waitable_event.h"
  10. #include "base/threading/thread.h"
  11. #include "gpu/gles2_conform_support/egl/test_support.h"
  12. // This file tests EGL basic interface for command_buffer_gles2, the mode of
  13. // command buffer where the code is compiled as a standalone dynamic library and
  14. // exposed through EGL API.
  15. namespace gpu {
  16. class EGLTest : public testing::Test {
  17. public:
  18. void TearDown() override;
  19. };
  20. void EGLTest::TearDown() {
  21. EXPECT_TRUE(eglReleaseThread());
  22. }
  23. TEST_F(EGLTest, OnlyReleaseThread) {}
  24. TEST_F(EGLTest, GetDisplay) {
  25. EGLDisplay display1 = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  26. EXPECT_NE(display1, EGL_NO_DISPLAY);
  27. EGLDisplay display2 = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  28. EXPECT_EQ(display1, display2);
  29. #if defined(USE_OZONE)
  30. EGLNativeDisplayType invalid_display_type =
  31. static_cast<EGLNativeDisplayType>(0x1);
  32. #else
  33. EGLNativeDisplayType invalid_display_type =
  34. reinterpret_cast<EGLNativeDisplayType>(0x1);
  35. #endif
  36. EXPECT_NE(invalid_display_type, EGL_DEFAULT_DISPLAY);
  37. EXPECT_EQ(EGL_NO_DISPLAY, eglGetDisplay(invalid_display_type));
  38. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  39. // eglTerminate can be called with uninitialized display.
  40. EXPECT_TRUE(eglTerminate(display1));
  41. }
  42. TEST_F(EGLTest, GetError) {
  43. // GetError returns success.
  44. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  45. // "calling eglGetError twice without any other intervening EGL calls will
  46. // always return EGL_SUCCESS on the second call"
  47. EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  48. EXPECT_NE(display, EGL_NO_DISPLAY);
  49. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  50. EXPECT_EQ(nullptr, eglQueryString(display, EGL_EXTENSIONS));
  51. EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
  52. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  53. EXPECT_TRUE(eglTerminate(display));
  54. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  55. }
  56. TEST_F(EGLTest, Initialize) {
  57. EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  58. EXPECT_NE(display, EGL_NO_DISPLAY);
  59. // Test for no crash even though passing nullptrs for major, minor.
  60. EXPECT_TRUE(eglInitialize(display, nullptr, nullptr));
  61. EGLint major = 0;
  62. EGLint minor = 0;
  63. EXPECT_TRUE(eglInitialize(display, &major, &minor));
  64. EXPECT_EQ(major, 1);
  65. EXPECT_EQ(minor, 4);
  66. EGLDisplay invalid_display = reinterpret_cast<EGLDisplay>(0x1);
  67. EXPECT_FALSE(eglInitialize(invalid_display, nullptr, nullptr));
  68. EXPECT_EQ(EGL_BAD_DISPLAY, eglGetError());
  69. }
  70. TEST_F(EGLTest, Terminate) {
  71. EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  72. EXPECT_NE(display, EGL_NO_DISPLAY);
  73. // eglTerminate can be called multiple times without initialization.
  74. EXPECT_TRUE(eglTerminate(display));
  75. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  76. EXPECT_TRUE(eglTerminate(display));
  77. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  78. EXPECT_TRUE(eglInitialize(display, nullptr, nullptr));
  79. // eglTerminate can be called multiple times.
  80. EXPECT_TRUE(eglTerminate(display));
  81. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  82. EXPECT_TRUE(eglTerminate(display));
  83. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  84. // After Terminate, an egl call returns not initialized.
  85. EXPECT_EQ(nullptr, eglQueryString(display, EGL_EXTENSIONS));
  86. EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
  87. // Re-initialization of same display.
  88. EXPECT_TRUE(eglInitialize(display, nullptr, nullptr));
  89. EXPECT_NE(nullptr, eglQueryString(display, EGL_EXTENSIONS));
  90. EXPECT_TRUE(eglTerminate(display));
  91. EGLDisplay invalid_display = reinterpret_cast<EGLDisplay>(0x1);
  92. EXPECT_FALSE(eglTerminate(invalid_display));
  93. EXPECT_EQ(EGL_BAD_DISPLAY, eglGetError());
  94. }
  95. TEST_F(EGLTest, QueryString) {
  96. EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  97. EXPECT_NE(display, EGL_NO_DISPLAY);
  98. EXPECT_EQ(nullptr, eglQueryString(display, EGL_EXTENSIONS));
  99. EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
  100. EXPECT_STREQ("", eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS));
  101. EXPECT_EQ(nullptr, eglQueryString(display, EGL_VERSION));
  102. EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
  103. EXPECT_STREQ("1.4", eglQueryString(EGL_NO_DISPLAY, EGL_VERSION));
  104. EXPECT_EQ(nullptr, eglQueryString(display, EGL_CLIENT_APIS));
  105. EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
  106. EXPECT_EQ(nullptr, eglQueryString(EGL_NO_DISPLAY, EGL_CLIENT_APIS));
  107. EXPECT_EQ(EGL_BAD_DISPLAY, eglGetError());
  108. EXPECT_EQ(nullptr, eglQueryString(display, EGL_VENDOR));
  109. EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
  110. EXPECT_EQ(nullptr, eglQueryString(EGL_NO_DISPLAY, EGL_VENDOR));
  111. EXPECT_EQ(EGL_BAD_DISPLAY, eglGetError());
  112. EXPECT_TRUE(eglInitialize(display, nullptr, nullptr));
  113. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  114. EXPECT_STREQ("", eglQueryString(display, EGL_EXTENSIONS));
  115. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  116. EXPECT_STREQ("1.4", eglQueryString(display, EGL_VERSION));
  117. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  118. EXPECT_STREQ("OpenGL_ES", eglQueryString(display, EGL_CLIENT_APIS));
  119. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  120. EXPECT_STREQ("Google Inc.", eglQueryString(display, EGL_VENDOR));
  121. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  122. }
  123. TEST_F(EGLTest, GetConfigsUninitialized) {
  124. EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  125. EXPECT_NE(display, EGL_NO_DISPLAY);
  126. EGLint num_config = 0;
  127. const int kConfigsSize = 5;
  128. EGLConfig configs[kConfigsSize] = {
  129. 0,
  130. };
  131. EXPECT_FALSE(eglGetConfigs(display, configs, kConfigsSize, &num_config));
  132. EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
  133. EXPECT_FALSE(eglGetConfigs(display, configs, kConfigsSize, nullptr));
  134. EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
  135. }
  136. TEST_F(EGLTest, ChooseConfigUninitialized) {
  137. EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  138. EXPECT_NE(display, EGL_NO_DISPLAY);
  139. EGLint num_config = 0;
  140. EGLint attrib_list[] = {EGL_NONE};
  141. const int kConfigsSize = 5;
  142. EGLConfig configs[kConfigsSize] = {
  143. 0,
  144. };
  145. EXPECT_FALSE(eglChooseConfig(display, attrib_list, configs, kConfigsSize,
  146. &num_config));
  147. EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
  148. EXPECT_FALSE(
  149. eglChooseConfig(display, attrib_list, configs, kConfigsSize, nullptr));
  150. EXPECT_EQ(EGL_NOT_INITIALIZED, eglGetError());
  151. }
  152. class EGLConfigTest : public EGLTest {
  153. public:
  154. void SetUp() override;
  155. protected:
  156. void CheckConfigsExist(EGLint num_config);
  157. enum { kConfigsSize = 5 };
  158. EGLDisplay display_;
  159. EGLConfig configs_[kConfigsSize];
  160. };
  161. void EGLConfigTest::SetUp() {
  162. display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  163. ASSERT_NE(display_, EGL_NO_DISPLAY);
  164. EXPECT_TRUE(eglInitialize(display_, nullptr, nullptr));
  165. memset(configs_, 0, sizeof(configs_));
  166. }
  167. void EGLConfigTest::CheckConfigsExist(EGLint num_config) {
  168. EGLint i;
  169. if (num_config > kConfigsSize)
  170. num_config = static_cast<EGLint>(kConfigsSize);
  171. for (i = 0; i < num_config; ++i)
  172. EXPECT_NE(nullptr, configs_[i]);
  173. for (; i < kConfigsSize; ++i)
  174. EXPECT_EQ(nullptr, configs_[i]);
  175. }
  176. TEST_F(EGLConfigTest, GetConfigsBadNumConfigs) {
  177. EXPECT_FALSE(eglGetConfigs(display_, configs_, kConfigsSize, nullptr));
  178. EXPECT_EQ(EGL_BAD_PARAMETER, eglGetError());
  179. }
  180. TEST_F(EGLConfigTest, GetConfigsNullConfigs) {
  181. EGLint num_config = 0;
  182. EXPECT_TRUE(eglGetConfigs(display_, nullptr, 55, &num_config));
  183. EXPECT_GT(num_config, 0);
  184. }
  185. TEST_F(EGLConfigTest, GetConfigsZeroConfigsSize) {
  186. EGLint num_config = 0;
  187. EXPECT_TRUE(eglGetConfigs(display_, configs_, 0, &num_config));
  188. EXPECT_GT(num_config, 0);
  189. EXPECT_EQ(nullptr, configs_[0]);
  190. }
  191. TEST_F(EGLConfigTest, GetConfigs) {
  192. EGLint num_config = 0;
  193. EXPECT_TRUE(eglGetConfigs(display_, configs_, kConfigsSize, &num_config));
  194. EXPECT_GT(num_config, 0);
  195. CheckConfigsExist(num_config);
  196. }
  197. TEST_F(EGLConfigTest, ChooseConfigBadNumConfigs) {
  198. EGLint attrib_list[] = {EGL_NONE};
  199. EXPECT_FALSE(
  200. eglChooseConfig(display_, attrib_list, configs_, kConfigsSize, nullptr));
  201. EXPECT_EQ(EGL_BAD_PARAMETER, eglGetError());
  202. }
  203. TEST_F(EGLConfigTest, ChooseConfigNullConfigs) {
  204. EGLint num_config = 0;
  205. EGLint attrib_list[] = {EGL_NONE};
  206. EXPECT_TRUE(eglChooseConfig(display_, attrib_list, nullptr, 55, &num_config));
  207. EXPECT_GT(num_config, 0);
  208. }
  209. TEST_F(EGLConfigTest, ChooseConfigZeroConfigsSize) {
  210. EGLint num_config = 0;
  211. EGLint attrib_list[] = {EGL_NONE};
  212. EXPECT_TRUE(eglChooseConfig(display_, attrib_list, configs_, 0, &num_config));
  213. EXPECT_GT(num_config, 0);
  214. EXPECT_EQ(nullptr, configs_[0]);
  215. }
  216. TEST_F(EGLConfigTest, ChooseConfig) {
  217. EGLint num_config = 0;
  218. EGLint attrib_list[] = {EGL_NONE};
  219. EXPECT_TRUE(eglChooseConfig(display_, attrib_list, configs_, kConfigsSize,
  220. &num_config));
  221. EXPECT_GT(num_config, 0);
  222. CheckConfigsExist(num_config);
  223. }
  224. TEST_F(EGLConfigTest, ChooseConfigInvalidAttrib) {
  225. const EGLint kNotModified = 55;
  226. EGLint num_config = kNotModified;
  227. EGLint invalid_attrib_list[] = {0xABCD};
  228. EXPECT_FALSE(eglChooseConfig(display_, invalid_attrib_list, configs_,
  229. kConfigsSize, &num_config));
  230. EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError());
  231. EXPECT_EQ(kNotModified, num_config);
  232. }
  233. TEST_F(EGLConfigTest, ChooseConfigWindow) {
  234. EGLint num_config = 0;
  235. EGLint attrib_list[] = {EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_NONE};
  236. EXPECT_TRUE(eglChooseConfig(display_, attrib_list, configs_, kConfigsSize,
  237. &num_config));
  238. EXPECT_GT(num_config, 0);
  239. for (int i = 0; i < num_config; ++i) {
  240. EGLint value = EGL_NONE;
  241. eglGetConfigAttrib(display_, configs_[i], EGL_SURFACE_TYPE, &value);
  242. EXPECT_NE(0, value & EGL_WINDOW_BIT);
  243. }
  244. }
  245. TEST_F(EGLConfigTest, ChooseConfigPBuffer) {
  246. EGLint num_config = 0;
  247. EGLint attrib_list[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_NONE};
  248. EXPECT_TRUE(eglChooseConfig(display_, attrib_list, configs_, kConfigsSize,
  249. &num_config));
  250. EXPECT_GT(num_config, 0);
  251. for (int i = 0; i < num_config; ++i) {
  252. EGLint value = EGL_NONE;
  253. eglGetConfigAttrib(display_, configs_[0], EGL_SURFACE_TYPE, &value);
  254. EXPECT_NE(0, value & EGL_PBUFFER_BIT);
  255. }
  256. }
  257. TEST_F(EGLConfigTest, ChooseConfigWindowPBufferNotPossible) {
  258. EGLint num_config = 0;
  259. EGLint attrib_list[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT | EGL_WINDOW_BIT,
  260. EGL_NONE};
  261. EXPECT_TRUE(eglChooseConfig(display_, attrib_list, configs_, kConfigsSize,
  262. &num_config));
  263. EXPECT_EQ(0, num_config);
  264. }
  265. TEST_F(EGLConfigTest, ChooseConfigBugExample) {
  266. static const EGLint kConfigAttribs[] = {
  267. EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8,
  268. EGL_ALPHA_SIZE, 8, EGL_DEPTH_SIZE, 8, EGL_STENCIL_SIZE, 8,
  269. EGL_SAMPLE_BUFFERS, 1, EGL_SAMPLES, 4, EGL_NONE};
  270. EGLint num_config = 0;
  271. EXPECT_TRUE(eglChooseConfig(display_, kConfigAttribs, configs_, kConfigsSize,
  272. &num_config));
  273. // The EGL attribs are not really implemented at the moment.
  274. EGLint value = EGL_NONE;
  275. EXPECT_TRUE(eglGetConfigAttrib(display_, configs_[0], EGL_RED_SIZE, &value));
  276. EXPECT_EQ(0, value);
  277. }
  278. TEST_F(EGLTest, MakeCurrent) {
  279. EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  280. EXPECT_NE(display, EGL_NO_DISPLAY);
  281. // "This is the only case where an uninitialized display may be passed to
  282. // eglMakeCurrent."
  283. EXPECT_TRUE(
  284. eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
  285. EGLDisplay invalid_display = reinterpret_cast<EGLDisplay>(0x1);
  286. EXPECT_FALSE(eglMakeCurrent(invalid_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
  287. EGL_NO_CONTEXT));
  288. EXPECT_EQ(EGL_BAD_DISPLAY, eglGetError());
  289. EXPECT_TRUE(eglInitialize(display, nullptr, nullptr));
  290. EXPECT_TRUE(
  291. eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
  292. EXPECT_FALSE(eglMakeCurrent(invalid_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
  293. EGL_NO_CONTEXT));
  294. }
  295. class EGLSurfaceTest : public EGLTest {
  296. public:
  297. void SetUp() override;
  298. void CreateSurfaceAndContext(EGLSurface* surface, EGLContext* context);
  299. protected:
  300. EGLDisplay display_;
  301. };
  302. void EGLSurfaceTest::SetUp() {
  303. EGLTest::SetUp();
  304. display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  305. EXPECT_TRUE(eglInitialize(display_, nullptr, nullptr));
  306. }
  307. void EGLSurfaceTest::CreateSurfaceAndContext(EGLSurface* surface,
  308. EGLContext* context) {
  309. static const EGLint config_attribs[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
  310. EGL_NONE};
  311. EGLint num_config;
  312. EGLConfig config;
  313. EXPECT_TRUE(
  314. eglChooseConfig(display_, config_attribs, &config, 1, &num_config));
  315. ASSERT_GT(num_config, 0);
  316. static const EGLint surface_attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1,
  317. EGL_NONE};
  318. *surface = eglCreatePbufferSurface(display_, config, surface_attribs);
  319. static const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2,
  320. EGL_NONE};
  321. *context = eglCreateContext(display_, config, nullptr, context_attribs);
  322. }
  323. class EGLMultipleSurfacesContextsTest : public EGLSurfaceTest {
  324. public:
  325. void SetUp() override;
  326. void TearDown() override;
  327. protected:
  328. EGLSurface surface1_;
  329. EGLSurface surface2_;
  330. EGLContext context1_;
  331. EGLContext context2_;
  332. };
  333. void EGLMultipleSurfacesContextsTest::SetUp() {
  334. EGLSurfaceTest::SetUp();
  335. CreateSurfaceAndContext(&surface1_, &context1_);
  336. CreateSurfaceAndContext(&surface2_, &context2_);
  337. EXPECT_NE(EGL_NO_SURFACE, surface1_);
  338. EXPECT_NE(EGL_NO_SURFACE, surface2_);
  339. EXPECT_NE(surface1_, surface2_);
  340. EXPECT_NE(EGL_NO_CONTEXT, context1_);
  341. EXPECT_NE(EGL_NO_CONTEXT, context2_);
  342. EXPECT_NE(context1_, context2_);
  343. }
  344. void EGLMultipleSurfacesContextsTest::TearDown() {
  345. EXPECT_TRUE(eglDestroyContext(display_, context1_));
  346. EXPECT_TRUE(eglDestroySurface(display_, surface1_));
  347. EXPECT_TRUE(eglDestroyContext(display_, context2_));
  348. EXPECT_TRUE(eglDestroySurface(display_, surface2_));
  349. EGLTest::TearDown();
  350. }
  351. TEST_F(EGLMultipleSurfacesContextsTest, NoMakeCurrent) {}
  352. TEST_F(EGLMultipleSurfacesContextsTest, MakeCurrentSurfaces) {
  353. EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context1_));
  354. EXPECT_TRUE(eglMakeCurrent(display_, surface2_, surface2_, context2_));
  355. EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context2_));
  356. EXPECT_TRUE(eglMakeCurrent(display_, surface2_, surface2_, context1_));
  357. }
  358. TEST_F(EGLMultipleSurfacesContextsTest, MakeCurrentSameSurface1) {
  359. EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context1_));
  360. EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context2_));
  361. }
  362. TEST_F(EGLMultipleSurfacesContextsTest, MakeCurrentSameSurface2) {
  363. EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context1_));
  364. EXPECT_TRUE(eglMakeCurrent(display_, surface2_, surface2_, context1_));
  365. EXPECT_TRUE(eglMakeCurrent(display_, surface2_, surface2_, context2_));
  366. }
  367. TEST_F(EGLMultipleSurfacesContextsTest, MakeCurrentSurfacesAndReleases) {
  368. EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context1_));
  369. EXPECT_TRUE(
  370. eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
  371. EXPECT_TRUE(eglMakeCurrent(display_, surface2_, surface2_, context2_));
  372. EXPECT_TRUE(
  373. eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
  374. EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context2_));
  375. EXPECT_TRUE(
  376. eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
  377. EXPECT_TRUE(eglMakeCurrent(display_, surface2_, surface2_, context1_));
  378. EXPECT_TRUE(
  379. eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
  380. }
  381. TEST_F(EGLMultipleSurfacesContextsTest, MakeCurrentSurfaceFails) {
  382. EXPECT_FALSE(eglMakeCurrent(display_, surface1_, surface1_, EGL_NO_CONTEXT));
  383. EXPECT_EQ(EGL_BAD_CONTEXT, eglGetError());
  384. EXPECT_FALSE(eglMakeCurrent(display_, surface1_, EGL_NO_SURFACE, context1_));
  385. EXPECT_EQ(EGL_BAD_SURFACE, eglGetError());
  386. EXPECT_FALSE(eglMakeCurrent(display_, EGL_NO_SURFACE, surface1_, context1_));
  387. EXPECT_EQ(EGL_BAD_SURFACE, eglGetError());
  388. EGLDisplay invalid_display = reinterpret_cast<EGLDisplay>(0x1);
  389. EGLSurface invalid_surface = reinterpret_cast<EGLSurface>(0x1);
  390. EGLSurface invalid_context = reinterpret_cast<EGLContext>(0x1);
  391. EXPECT_FALSE(
  392. eglMakeCurrent(invalid_display, surface1_, surface1_, context1_));
  393. EXPECT_EQ(EGL_BAD_DISPLAY, eglGetError());
  394. EXPECT_FALSE(eglMakeCurrent(display_, surface1_, surface1_, invalid_context));
  395. EXPECT_EQ(EGL_BAD_CONTEXT, eglGetError());
  396. EXPECT_FALSE(eglMakeCurrent(display_, surface1_, invalid_surface, context1_));
  397. EXPECT_EQ(EGL_BAD_SURFACE, eglGetError());
  398. EXPECT_FALSE(eglMakeCurrent(display_, invalid_surface, surface1_, context1_));
  399. EXPECT_EQ(EGL_BAD_SURFACE, eglGetError());
  400. // Command buffer limitation:
  401. // Different read and draw surfaces fail.
  402. EXPECT_FALSE(eglMakeCurrent(display_, surface1_, surface2_, context1_));
  403. EXPECT_EQ(EGL_BAD_MATCH, eglGetError());
  404. }
  405. TEST_F(EGLMultipleSurfacesContextsTest, CallGLOnMultipleContextNoCrash) {
  406. EXPECT_TRUE(eglMakeCurrent(display_, surface1_, surface1_, context1_));
  407. typedef void(GL_APIENTRY * glEnableProc)(GLenum);
  408. glEnableProc glEnable =
  409. reinterpret_cast<glEnableProc>(eglGetProcAddress("glEnable"));
  410. EXPECT_NE(nullptr, glEnable);
  411. glEnable(GL_BLEND);
  412. EXPECT_TRUE(eglMakeCurrent(display_, surface2_, surface2_, context2_));
  413. glEnable(GL_BLEND);
  414. }
  415. class EGLThreadTest : public EGLSurfaceTest {
  416. public:
  417. EGLThreadTest();
  418. void SetUp() override;
  419. void TearDown() override;
  420. void OtherThreadTearDown(base::WaitableEvent*);
  421. void OtherThreadMakeCurrent(EGLSurface surface,
  422. EGLContext context,
  423. EGLBoolean* result,
  424. base::WaitableEvent*);
  425. void OtherThreadGetError(EGLint* result, base::WaitableEvent*);
  426. protected:
  427. base::Thread other_thread_;
  428. };
  429. EGLThreadTest::EGLThreadTest()
  430. : EGLSurfaceTest(), other_thread_("EGLThreadTest thread") {}
  431. void EGLThreadTest::SetUp() {
  432. EGLSurfaceTest::SetUp();
  433. other_thread_.Start();
  434. }
  435. void EGLThreadTest::TearDown() {
  436. base::WaitableEvent completion(
  437. base::WaitableEvent::ResetPolicy::MANUAL,
  438. base::WaitableEvent::InitialState::NOT_SIGNALED);
  439. other_thread_.task_runner()->PostTask(
  440. FROM_HERE, base::BindOnce(&EGLThreadTest::OtherThreadTearDown,
  441. base::Unretained(this), &completion));
  442. completion.Wait();
  443. other_thread_.Stop();
  444. EGLSurfaceTest::TearDown();
  445. }
  446. void EGLThreadTest::OtherThreadTearDown(base::WaitableEvent* completion) {
  447. EXPECT_TRUE(eglReleaseThread());
  448. completion->Signal();
  449. }
  450. void EGLThreadTest::OtherThreadMakeCurrent(EGLSurface surface,
  451. EGLContext context,
  452. EGLBoolean* result,
  453. base::WaitableEvent* completion) {
  454. *result = eglMakeCurrent(display_, surface, surface, context);
  455. completion->Signal();
  456. }
  457. void EGLThreadTest::OtherThreadGetError(EGLint* result,
  458. base::WaitableEvent* completion) {
  459. *result = eglGetError();
  460. completion->Signal();
  461. }
  462. TEST_F(EGLThreadTest, OnlyReleaseThreadInOther) {}
  463. TEST_F(EGLThreadTest, Basic) {
  464. EGLSurface surface;
  465. EGLContext context;
  466. CreateSurfaceAndContext(&surface, &context);
  467. EXPECT_NE(EGL_NO_SURFACE, surface);
  468. EXPECT_NE(EGL_NO_CONTEXT, context);
  469. EXPECT_TRUE(eglMakeCurrent(display_, surface, surface, context));
  470. base::WaitableEvent completion(
  471. base::WaitableEvent::ResetPolicy::AUTOMATIC,
  472. base::WaitableEvent::InitialState::NOT_SIGNALED);
  473. EGLBoolean result = EGL_FALSE;
  474. other_thread_.task_runner()->PostTask(
  475. FROM_HERE, base::BindOnce(&EGLThreadTest::OtherThreadMakeCurrent,
  476. base::Unretained(this), surface, context,
  477. &result, &completion));
  478. completion.Wait();
  479. EXPECT_FALSE(result);
  480. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  481. EGLint error = EGL_NONE;
  482. other_thread_.task_runner()->PostTask(
  483. FROM_HERE, base::BindOnce(&EGLThreadTest::OtherThreadGetError,
  484. base::Unretained(this), &error, &completion));
  485. completion.Wait();
  486. EXPECT_EQ(EGL_BAD_ACCESS, error);
  487. EXPECT_EQ(EGL_SUCCESS, eglGetError());
  488. other_thread_.task_runner()->PostTask(
  489. FROM_HERE, base::BindOnce(&EGLThreadTest::OtherThreadGetError,
  490. base::Unretained(this), &error, &completion));
  491. completion.Wait();
  492. EXPECT_EQ(EGL_SUCCESS, error);
  493. EXPECT_TRUE(
  494. eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
  495. other_thread_.task_runner()->PostTask(
  496. FROM_HERE, base::BindOnce(&EGLThreadTest::OtherThreadMakeCurrent,
  497. base::Unretained(this), surface, context,
  498. &result, &completion));
  499. completion.Wait();
  500. EXPECT_TRUE(result);
  501. EXPECT_FALSE(eglMakeCurrent(display_, surface, surface, context));
  502. EXPECT_EQ(EGL_BAD_ACCESS, eglGetError());
  503. EXPECT_TRUE(eglDestroySurface(display_, surface));
  504. EXPECT_TRUE(eglDestroyContext(display_, context));
  505. }
  506. TEST_F(EGLTest, WindowlessNativeWindows) {
  507. EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  508. EXPECT_TRUE(eglInitialize(display, nullptr, nullptr));
  509. static const EGLint config_attribs[] = {EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
  510. EGL_NONE};
  511. EGLint num_config;
  512. EGLConfig config;
  513. EXPECT_TRUE(
  514. eglChooseConfig(display, config_attribs, &config, 1, &num_config));
  515. ASSERT_GT(num_config, 0);
  516. static const EGLint surface_attribs[] = {EGL_NONE};
  517. CommandBufferGLESSetNextCreateWindowSurfaceCreatesPBuffer(display, 100, 100);
  518. EGLNativeWindowType win = 0;
  519. EGLSurface surface =
  520. eglCreateWindowSurface(display, config, win, surface_attribs);
  521. EXPECT_NE(EGL_NO_SURFACE, surface);
  522. // Test that SwapBuffers can be called on windowless window surfaces.
  523. static const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2,
  524. EGL_NONE};
  525. EGLContext context =
  526. eglCreateContext(display, config, nullptr, context_attribs);
  527. EXPECT_TRUE(eglMakeCurrent(display, surface, surface, context));
  528. EXPECT_TRUE(eglSwapBuffers(display, surface));
  529. EXPECT_TRUE(eglDestroySurface(display, surface));
  530. EXPECT_TRUE(eglDestroyContext(display, context));
  531. }
  532. } // namespace gpu