9 #include "flutter/impeller/renderer/backend/gles/gles.h"
13 #include "flutter/shell/platform/windows/testing/egl/mock_context.h"
14 #include "flutter/shell/platform/windows/testing/egl/mock_manager.h"
15 #include "flutter/shell/platform/windows/testing/egl/mock_window_surface.h"
16 #include "flutter/shell/platform/windows/testing/engine_modifier.h"
17 #include "flutter/shell/platform/windows/testing/flutter_windows_engine_builder.h"
18 #include "flutter/shell/platform/windows/testing/mock_window_binding_handler.h"
19 #include "flutter/shell/platform/windows/testing/view_modifier.h"
20 #include "flutter/shell/platform/windows/testing/windows_test.h"
21 #include "gmock/gmock.h"
22 #include "gtest/gtest.h"
28 using ::testing::AnyNumber;
29 using ::testing::Return;
31 void MockGetIntegerv(GLenum
name,
int* value) {
32 if (
name == GL_NUM_EXTENSIONS) {
39 const unsigned char* MockGetString(GLenum
name) {
42 case GL_SHADING_LANGUAGE_VERSION:
43 return reinterpret_cast<const unsigned char*
>(
"3.0");
45 return reinterpret_cast<const unsigned char*
>(
"");
49 const unsigned char* MockGetStringi(GLenum
name,
int index) {
50 if (
name == GL_EXTENSIONS) {
51 return reinterpret_cast<const unsigned char*
>(
"GL_ANGLE_framebuffer_blit");
53 return reinterpret_cast<const unsigned char*
>(
"");
57 GLenum MockGetError() {
61 void MockGetIntegervWithMSAA(GLenum
name,
int* value) {
62 if (
name == GL_NUM_EXTENSIONS) {
69 const unsigned char* MockGetStringiWithMSAA(GLenum
name,
int index) {
70 static constexpr
const char* extensions[] = {
71 "GL_ANGLE_framebuffer_blit",
"GL_EXT_multisampled_render_to_texture"};
72 if (
name == GL_EXTENSIONS && index < 2) {
73 return reinterpret_cast<const unsigned char*
>(extensions[index]);
75 return reinterpret_cast<const unsigned char*
>(
"");
80 template <
typename T,
typename U>
81 struct CheckSameSignature : std::false_type {};
83 template <
typename Ret,
typename... Args>
84 struct CheckSameSignature<Ret(Args...), Ret(Args...)> : std::true_type {};
86 const impeller::ProcTableGLES::Resolver kMockResolver = [](
const char*
name) {
87 std::string function_name{
name};
89 if (function_name ==
"glGetString") {
90 return reinterpret_cast<void*
>(&MockGetString);
91 }
else if (function_name ==
"glGetStringi") {
92 return reinterpret_cast<void*
>(&MockGetStringi);
93 }
else if (function_name ==
"glGetIntegerv") {
94 return reinterpret_cast<void*
>(&MockGetIntegerv);
95 }
else if (function_name ==
"glGetError") {
96 return reinterpret_cast<void*
>(&MockGetError);
98 return reinterpret_cast<void*
>(&DoNothing);
102 const impeller::ProcTableGLES::Resolver kMockResolverWithMSAA =
103 [](
const char*
name) {
104 std::string_view function_name{
name};
106 if (function_name ==
"glGetStringi") {
107 return reinterpret_cast<void*
>(&MockGetStringiWithMSAA);
108 }
else if (function_name ==
"glGetIntegerv") {
109 return reinterpret_cast<void*
>(&MockGetIntegervWithMSAA);
111 return kMockResolver(
name);
114 void MockGetIntegervWithOffscreenMSAA(GLenum
name,
int* value) {
115 if (
name == GL_NUM_EXTENSIONS) {
117 }
else if (
name == GL_MAX_SAMPLES) {
124 const unsigned char* MockGetStringWithOffscreenMSAA(GLenum
name) {
127 return reinterpret_cast<const unsigned char*
>(
"OpenGL ES 3.0");
128 case GL_SHADING_LANGUAGE_VERSION:
129 return reinterpret_cast<const unsigned char*
>(
"OpenGL ES GLSL ES 3.0");
131 return reinterpret_cast<const unsigned char*
>(
"");
135 const impeller::ProcTableGLES::Resolver kMockResolverWithOffscreenMSAA =
136 [](
const char*
name) ->
void* {
137 std::string_view function_name{
name};
139 if (function_name ==
"glGetString") {
140 return reinterpret_cast<void*
>(&MockGetStringWithOffscreenMSAA);
141 }
else if (function_name ==
"glGetIntegerv") {
142 return reinterpret_cast<void*
>(&MockGetIntegervWithOffscreenMSAA);
144 return kMockResolver(
name);
148 const unsigned char* MockGetStringGLES2(GLenum
name) {
151 return reinterpret_cast<const unsigned char*
>(
"OpenGL ES 2.0");
152 case GL_SHADING_LANGUAGE_VERSION:
153 return reinterpret_cast<const unsigned char*
>(
"OpenGL ES GLSL ES 1.00");
155 return reinterpret_cast<const unsigned char*
>(
156 "GL_ANGLE_framebuffer_blit GL_EXT_texture_format_BGRA8888");
158 return reinterpret_cast<const unsigned char*
>(
"");
162 static_assert(CheckSameSignature<decltype(MockGetStringGLES2),
163 decltype(glGetString)>::value);
165 const unsigned char* MockGetStringGLES3(GLenum
name) {
168 return reinterpret_cast<const unsigned char*
>(
"OpenGL ES 3.0");
169 case GL_SHADING_LANGUAGE_VERSION:
170 return reinterpret_cast<const unsigned char*
>(
"OpenGL ES GLSL ES 3.00");
172 return reinterpret_cast<const unsigned char*
>(
"");
176 static_assert(CheckSameSignature<decltype(MockGetStringGLES3),
177 decltype(glGetString)>::value);
179 std::vector<GLint>& TexImage2DInternalFormats() {
180 static std::vector<GLint> internal_formats;
181 return internal_formats;
184 void RecordTexImage2D(GLenum,
186 GLint internalformat,
193 TexImage2DInternalFormats().push_back(internalformat);
196 static_assert(CheckSameSignature<decltype(RecordTexImage2D),
197 decltype(glTexImage2D)>::value);
199 const impeller::ProcTableGLES::Resolver kRecordingResolverGLES2 =
200 [](
const char*
name) ->
void* {
201 std::string_view function_name{
name};
202 if (function_name ==
"glGetString") {
203 return reinterpret_cast<void*
>(&MockGetStringGLES2);
204 }
else if (function_name ==
"glTexImage2D") {
205 return reinterpret_cast<void*
>(&RecordTexImage2D);
207 return kMockResolver(
name);
210 const impeller::ProcTableGLES::Resolver kRecordingResolverGLES3 =
211 [](
const char*
name) ->
void* {
212 std::string_view function_name{
name};
213 if (function_name ==
"glGetString") {
214 return reinterpret_cast<void*
>(&MockGetStringGLES3);
215 }
else if (function_name ==
"glTexImage2D") {
216 return reinterpret_cast<void*
>(&RecordTexImage2D);
218 return kMockResolver(
name);
224 class CompositorOpenGLTest :
public WindowsTest {
226 CompositorOpenGLTest() =
default;
227 virtual ~CompositorOpenGLTest() =
default;
230 void TearDown()
override {
231 TexImage2DInternalFormats().clear();
232 WindowsTest::TearDown();
235 FlutterWindowsEngine* engine() {
return engine_.get(); }
236 FlutterWindowsView* view() {
return view_.get(); }
237 egl::MockManager* egl_manager() {
return egl_manager_; }
238 egl::MockContext* render_context() {
return render_context_.get(); }
239 egl::MockWindowSurface* surface() {
return surface_; }
241 void UseHeadlessEngine() {
242 auto egl_manager = std::make_unique<egl::MockManager>();
243 render_context_ = std::make_unique<egl::MockContext>();
244 egl_manager_ = egl_manager.get();
246 EXPECT_CALL(*egl_manager_, render_context)
248 .WillRepeatedly(Return(render_context_.get()));
250 FlutterWindowsEngineBuilder builder{GetContext()};
252 engine_ = builder.Build();
253 EngineModifier modifier{engine_.get()};
254 modifier.SetEGLManager(std::move(egl_manager));
257 void UseEngineWithView(
bool add_surface =
true) {
260 auto window = std::make_unique<MockWindowBindingHandler>();
261 EXPECT_CALL(*window.get(), SetView).Times(1);
262 EXPECT_CALL(*window.get(), GetWindowHandle).WillRepeatedly(Return(
nullptr));
264 view_ = std::make_unique<FlutterWindowsView>(
kImplicitViewId, engine_.get(),
265 std::move(window),
false,
269 auto surface = std::make_unique<egl::MockWindowSurface>();
270 surface_ = surface.get();
272 EXPECT_CALL(*surface_, Destroy).Times(AnyNumber());
274 ViewModifier modifier{view_.get()};
275 modifier.SetSurface(std::move(surface));
280 std::unique_ptr<FlutterWindowsEngine> engine_;
281 std::unique_ptr<FlutterWindowsView> view_;
282 std::unique_ptr<egl::MockContext> render_context_;
283 egl::MockWindowSurface* surface_;
284 egl::MockManager* egl_manager_;
286 FML_DISALLOW_COPY_AND_ASSIGN(CompositorOpenGLTest);
291 TEST_F(CompositorOpenGLTest, CreateBackingStore) {
297 FlutterBackingStoreConfig config = {};
298 FlutterBackingStore backing_store = {};
300 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(
true));
301 ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
302 ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
305 TEST_F(CompositorOpenGLTest, CreateBackingStoreImpellerNoMSAA) {
308 static int framebuffer_texture2d_calls = 0;
309 static int framebuffer_texture2d_multisample_calls = 0;
310 framebuffer_texture2d_calls = 0;
311 framebuffer_texture2d_multisample_calls = 0;
313 const impeller::ProcTableGLES::Resolver resolver =
314 [](
const char*
name) ->
void* {
315 std::string_view function_name{
name};
316 if (function_name ==
"glFramebufferTexture2D") {
317 return reinterpret_cast<void*
>(
318 +[](GLenum, GLenum, GLenum, GLuint, GLint) {
319 framebuffer_texture2d_calls++;
321 }
else if (function_name ==
"glFramebufferTexture2DMultisampleEXT") {
322 return reinterpret_cast<void*
>(
323 +[](GLenum, GLenum, GLenum, GLuint, GLint, GLsizei) {
324 framebuffer_texture2d_multisample_calls++;
327 return kMockResolver(
name);
332 FlutterBackingStoreConfig config = {};
333 FlutterBackingStore backing_store = {};
335 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(
true));
336 ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
337 EXPECT_EQ(framebuffer_texture2d_calls, 1);
338 EXPECT_EQ(framebuffer_texture2d_multisample_calls, 0);
339 ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
342 TEST_F(CompositorOpenGLTest, CreateBackingStoreImpellerMSAA) {
345 static int framebuffer_texture2d_calls = 0;
346 static int framebuffer_texture2d_multisample_calls = 0;
347 framebuffer_texture2d_calls = 0;
348 framebuffer_texture2d_multisample_calls = 0;
350 const impeller::ProcTableGLES::Resolver resolver =
351 [](
const char*
name) ->
void* {
352 std::string_view function_name{
name};
353 if (function_name ==
"glFramebufferTexture2D") {
354 return reinterpret_cast<void*
>(
355 +[](GLenum, GLenum, GLenum, GLuint, GLint) {
356 framebuffer_texture2d_calls++;
358 }
else if (function_name ==
"glFramebufferTexture2DMultisampleEXT") {
359 return reinterpret_cast<void*
>(
360 +[](GLenum, GLenum, GLenum, GLuint, GLint, GLsizei) {
361 framebuffer_texture2d_multisample_calls++;
364 return kMockResolverWithMSAA(
name);
369 FlutterBackingStoreConfig config = {};
370 FlutterBackingStore backing_store = {};
372 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(
true));
373 ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
374 EXPECT_EQ(framebuffer_texture2d_calls, 0);
375 EXPECT_EQ(framebuffer_texture2d_multisample_calls, 1);
376 ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
382 TEST_F(CompositorOpenGLTest, CreateBackingStoreImpellerOffscreenMSAA) {
385 static int framebuffer_texture2d_calls = 0;
386 static int framebuffer_texture2d_multisample_calls = 0;
387 static int renderbuffer_storage_multisample_calls = 0;
388 static int renderbuffer_storage_multisample_samples = 0;
389 static int framebuffer_renderbuffer_calls = 0;
390 static int delete_renderbuffers_calls = 0;
391 static int delete_textures_calls = 0;
393 framebuffer_texture2d_calls = 0;
394 framebuffer_texture2d_multisample_calls = 0;
395 renderbuffer_storage_multisample_calls = 0;
396 renderbuffer_storage_multisample_samples = 0;
397 framebuffer_renderbuffer_calls = 0;
398 delete_renderbuffers_calls = 0;
399 delete_textures_calls = 0;
401 const impeller::ProcTableGLES::Resolver resolver =
402 [](
const char*
name) ->
void* {
403 std::string_view function_name{
name};
404 if (function_name ==
"glFramebufferTexture2D") {
405 return reinterpret_cast<void*
>(
406 +[](GLenum, GLenum, GLenum, GLuint, GLint) {
407 framebuffer_texture2d_calls++;
409 }
else if (function_name ==
"glFramebufferTexture2DMultisampleEXT") {
410 return reinterpret_cast<void*
>(
411 +[](GLenum, GLenum, GLenum, GLuint, GLint, GLsizei) {
412 framebuffer_texture2d_multisample_calls++;
414 }
else if (function_name ==
"glGenRenderbuffers") {
415 return reinterpret_cast<void*
>(+[](GLsizei n, GLuint* renderbuffers) {
416 static GLuint next_id = 1;
417 for (GLsizei i = 0; i < n; i++) {
418 renderbuffers[i] = next_id++;
421 }
else if (function_name ==
"glRenderbufferStorageMultisample") {
422 return reinterpret_cast<void*
>(+[](GLenum target, GLsizei samples,
423 GLenum internalformat, GLsizei width,
425 renderbuffer_storage_multisample_calls++;
426 renderbuffer_storage_multisample_samples = samples;
428 }
else if (function_name ==
"glFramebufferRenderbuffer") {
429 return reinterpret_cast<void*
>(+[](GLenum, GLenum, GLenum, GLuint) {
430 framebuffer_renderbuffer_calls++;
432 }
else if (function_name ==
"glDeleteRenderbuffers") {
433 return reinterpret_cast<void*
>(
434 +[](GLsizei n,
const GLuint* renderbuffers) {
435 delete_renderbuffers_calls += n;
437 }
else if (function_name ==
"glDeleteTextures") {
438 return reinterpret_cast<void*
>(+[](GLsizei n,
const GLuint* textures) {
439 delete_textures_calls += n;
442 return kMockResolverWithOffscreenMSAA(
name);
447 FlutterBackingStoreConfig config = {};
448 FlutterBackingStore backing_store = {};
450 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(
true));
451 ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
452 EXPECT_EQ(framebuffer_texture2d_calls, 0);
453 EXPECT_EQ(framebuffer_texture2d_multisample_calls, 0);
454 EXPECT_EQ(renderbuffer_storage_multisample_calls, 2);
455 EXPECT_EQ(renderbuffer_storage_multisample_samples, 4);
456 EXPECT_EQ(framebuffer_renderbuffer_calls, 3);
458 ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
459 EXPECT_EQ(delete_renderbuffers_calls, 2);
460 EXPECT_EQ(delete_textures_calls, 0);
465 TEST_F(CompositorOpenGLTest, CreateBackingStoreGLES2Unsized) {
470 FlutterBackingStoreConfig config = {};
471 FlutterBackingStore backing_store = {};
473 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(
true));
474 ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
475 EXPECT_EQ(TexImage2DInternalFormats(), std::vector<GLint>{GL_BGRA_EXT});
476 EXPECT_EQ(backing_store.open_gl.framebuffer.target,
477 static_cast<uint32_t
>(GL_BGRA8_EXT));
478 ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
481 TEST_F(CompositorOpenGLTest, CreateBackingStoreImpellerGLES2Unsized) {
486 FlutterBackingStoreConfig config = {};
487 FlutterBackingStore backing_store = {};
489 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(
true));
490 ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
491 EXPECT_EQ(TexImage2DInternalFormats(), std::vector<GLint>{GL_BGRA_EXT});
492 ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
495 TEST_F(CompositorOpenGLTest, CreateBackingStoreGLES3Sized) {
500 FlutterBackingStoreConfig config = {};
501 FlutterBackingStore backing_store = {};
503 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(
true));
504 ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
505 EXPECT_EQ(TexImage2DInternalFormats(), std::vector<GLint>{GL_RGBA8});
506 ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
509 TEST_F(CompositorOpenGLTest, InitializationFailure) {
515 FlutterBackingStoreConfig config = {};
516 FlutterBackingStore backing_store = {};
518 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(
false));
519 EXPECT_FALSE(compositor.CreateBackingStore(config, &backing_store));
522 TEST_F(CompositorOpenGLTest, InitializationRequiresBlit) {
525 const impeller::ProcTableGLES::Resolver resolver = [](
const char*
name) {
526 std::string function_name{
name};
528 if (function_name ==
"glBlitFramebuffer" ||
529 function_name ==
"glBlitFramebufferANGLE") {
530 return (
void*)
nullptr;
533 return kMockResolver(
name);
539 FlutterBackingStoreConfig config = {};
540 FlutterBackingStore backing_store = {};
542 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(
true));
543 ASSERT_FALSE(compositor.CreateBackingStore(config, &backing_store));
552 FlutterBackingStoreConfig config = {};
553 FlutterBackingStore backing_store = {};
555 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(
true));
556 ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
558 FlutterLayer layer = {};
559 layer.type = kFlutterLayerContentTypeBackingStore;
560 layer.backing_store = &backing_store;
561 const FlutterLayer* layer_ptr = &layer;
563 EXPECT_CALL(*surface(), IsValid).WillRepeatedly(Return(
true));
564 EXPECT_CALL(*surface(), MakeCurrent).WillOnce(Return(
true));
565 EXPECT_CALL(*surface(), SwapBuffers).WillOnce(Return(
true));
566 EXPECT_TRUE(compositor.Present(view(), &layer_ptr, 1));
568 ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
571 TEST_F(CompositorOpenGLTest, PresentEmpty) {
579 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(
true));
580 EXPECT_CALL(*surface(), IsValid).WillRepeatedly(Return(
true));
581 EXPECT_CALL(*surface(), MakeCurrent).WillOnce(Return(
true));
582 EXPECT_CALL(*surface(), SwapBuffers).WillOnce(Return(
true));
583 EXPECT_TRUE(compositor.Present(view(),
nullptr, 0));
586 TEST_F(CompositorOpenGLTest, NoSurfaceIgnored) {
587 UseEngineWithView(
false);
592 FlutterBackingStoreConfig config = {};
593 FlutterBackingStore backing_store = {};
595 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(
true));
596 ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
598 FlutterLayer layer = {};
599 layer.type = kFlutterLayerContentTypeBackingStore;
600 layer.backing_store = &backing_store;
601 const FlutterLayer* layer_ptr = &layer;
603 EXPECT_FALSE(compositor.Present(view(), &layer_ptr, 1));
605 ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
608 TEST_F(CompositorOpenGLTest, PresentUsingANGLEBlitExtension) {
611 bool resolved_ANGLE_blit =
false;
612 const impeller::ProcTableGLES::Resolver resolver =
613 [&resolved_ANGLE_blit](
const char*
name) {
614 std::string function_name{
name};
616 if (function_name ==
"glBlitFramebuffer") {
617 return (
void*)
nullptr;
618 }
else if (function_name ==
"glBlitFramebufferANGLE") {
619 resolved_ANGLE_blit =
true;
620 return reinterpret_cast<void*
>(&DoNothing);
623 return kMockResolver(
name);
629 FlutterBackingStoreConfig config = {};
630 FlutterBackingStore backing_store = {};
632 EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(
true));
633 ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
635 FlutterLayer layer = {};
636 layer.type = kFlutterLayerContentTypeBackingStore;
637 layer.backing_store = &backing_store;
638 const FlutterLayer* layer_ptr = &layer;
640 EXPECT_CALL(*surface(), IsValid).WillRepeatedly(Return(
true));
641 EXPECT_CALL(*surface(), MakeCurrent).WillOnce(Return(
true));
642 EXPECT_CALL(*surface(), SwapBuffers).WillOnce(Return(
true));
643 EXPECT_TRUE(compositor.Present(view(), &layer_ptr, 1));
644 EXPECT_TRUE(resolved_ANGLE_blit);
646 ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
TEST_F(AccessibilityPluginTest, DirectAnnounceCall)
constexpr FlutterViewId kImplicitViewId