Flutter Windows Embedder
compositor_opengl_unittests.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter 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 
5 #include <memory>
6 #include <type_traits>
7 #include <vector>
8 
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"
23 
24 namespace flutter {
25 namespace testing {
26 
27 namespace {
28 using ::testing::AnyNumber;
29 using ::testing::Return;
30 
31 void MockGetIntegerv(GLenum name, int* value) {
32  if (name == GL_NUM_EXTENSIONS) {
33  *value = 1;
34  } else {
35  *value = 0;
36  }
37 }
38 
39 const unsigned char* MockGetString(GLenum name) {
40  switch (name) {
41  case GL_VERSION:
42  case GL_SHADING_LANGUAGE_VERSION:
43  return reinterpret_cast<const unsigned char*>("3.0");
44  default:
45  return reinterpret_cast<const unsigned char*>("");
46  }
47 }
48 
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");
52  } else {
53  return reinterpret_cast<const unsigned char*>("");
54  }
55 }
56 
57 GLenum MockGetError() {
58  return GL_NO_ERROR;
59 }
60 
61 void MockGetIntegervWithMSAA(GLenum name, int* value) {
62  if (name == GL_NUM_EXTENSIONS) {
63  *value = 2;
64  } else {
65  *value = 0;
66  }
67 }
68 
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]);
74  }
75  return reinterpret_cast<const unsigned char*>("");
76 }
77 
78 void DoNothing() {}
79 
80 template <typename T, typename U>
81 struct CheckSameSignature : std::false_type {};
82 
83 template <typename Ret, typename... Args>
84 struct CheckSameSignature<Ret(Args...), Ret(Args...)> : std::true_type {};
85 
86 const impeller::ProcTableGLES::Resolver kMockResolver = [](const char* name) {
87  std::string function_name{name};
88 
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);
97  } else {
98  return reinterpret_cast<void*>(&DoNothing);
99  }
100 };
101 
102 const impeller::ProcTableGLES::Resolver kMockResolverWithMSAA =
103  [](const char* name) {
104  std::string_view function_name{name};
105 
106  if (function_name == "glGetStringi") {
107  return reinterpret_cast<void*>(&MockGetStringiWithMSAA);
108  } else if (function_name == "glGetIntegerv") {
109  return reinterpret_cast<void*>(&MockGetIntegervWithMSAA);
110  }
111  return kMockResolver(name);
112  };
113 
114 void MockGetIntegervWithOffscreenMSAA(GLenum name, int* value) {
115  if (name == GL_NUM_EXTENSIONS) {
116  *value = 1;
117  } else if (name == GL_MAX_SAMPLES) {
118  *value = 4;
119  } else {
120  *value = 0;
121  }
122 }
123 
124 const unsigned char* MockGetStringWithOffscreenMSAA(GLenum name) {
125  switch (name) {
126  case GL_VERSION:
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");
130  default:
131  return reinterpret_cast<const unsigned char*>("");
132  }
133 }
134 
135 const impeller::ProcTableGLES::Resolver kMockResolverWithOffscreenMSAA =
136  [](const char* name) -> void* {
137  std::string_view function_name{name};
138 
139  if (function_name == "glGetString") {
140  return reinterpret_cast<void*>(&MockGetStringWithOffscreenMSAA);
141  } else if (function_name == "glGetIntegerv") {
142  return reinterpret_cast<void*>(&MockGetIntegervWithOffscreenMSAA);
143  }
144  return kMockResolver(name);
145 };
146 
147 // ANGLE returns these strings for an OpenGL ES 2.0 context
148 const unsigned char* MockGetStringGLES2(GLenum name) {
149  switch (name) {
150  case GL_VERSION:
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");
154  case GL_EXTENSIONS:
155  return reinterpret_cast<const unsigned char*>(
156  "GL_ANGLE_framebuffer_blit GL_EXT_texture_format_BGRA8888");
157  default:
158  return reinterpret_cast<const unsigned char*>("");
159  }
160 }
161 
162 static_assert(CheckSameSignature<decltype(MockGetStringGLES2), //
163  decltype(glGetString)>::value);
164 
165 const unsigned char* MockGetStringGLES3(GLenum name) {
166  switch (name) {
167  case GL_VERSION:
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");
171  default:
172  return reinterpret_cast<const unsigned char*>("");
173  }
174 }
175 
176 static_assert(CheckSameSignature<decltype(MockGetStringGLES3), //
177  decltype(glGetString)>::value);
178 
179 std::vector<GLint>& TexImage2DInternalFormats() {
180  static std::vector<GLint> internal_formats;
181  return internal_formats;
182 }
183 
184 void RecordTexImage2D(GLenum,
185  GLint,
186  GLint internalformat,
187  GLsizei,
188  GLsizei,
189  GLint,
190  GLenum,
191  GLenum,
192  const void*) {
193  TexImage2DInternalFormats().push_back(internalformat);
194 }
195 
196 static_assert(CheckSameSignature<decltype(RecordTexImage2D), //
197  decltype(glTexImage2D)>::value);
198 
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);
206  }
207  return kMockResolver(name);
208 };
209 
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);
217  }
218  return kMockResolver(name);
219 };
220 
221 // Tests the compositor against mocked EGL and OpenGL, unlike
222 // CompositorOpenGLANGLETest in compositor_opengl_angle_unittests.cc, which uses
223 // ANGLE.
224 class CompositorOpenGLTest : public WindowsTest {
225  public:
226  CompositorOpenGLTest() = default;
227  virtual ~CompositorOpenGLTest() = default;
228 
229  protected:
230  void TearDown() override {
231  TexImage2DInternalFormats().clear();
232  WindowsTest::TearDown();
233  }
234 
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_; }
240 
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();
245 
246  EXPECT_CALL(*egl_manager_, render_context)
247  .Times(AnyNumber())
248  .WillRepeatedly(Return(render_context_.get()));
249 
250  FlutterWindowsEngineBuilder builder{GetContext()};
251 
252  engine_ = builder.Build();
253  EngineModifier modifier{engine_.get()};
254  modifier.SetEGLManager(std::move(egl_manager));
255  }
256 
257  void UseEngineWithView(bool add_surface = true) {
258  UseHeadlessEngine();
259 
260  auto window = std::make_unique<MockWindowBindingHandler>();
261  EXPECT_CALL(*window.get(), SetView).Times(1);
262  EXPECT_CALL(*window.get(), GetWindowHandle).WillRepeatedly(Return(nullptr));
263 
264  view_ = std::make_unique<FlutterWindowsView>(kImplicitViewId, engine_.get(),
265  std::move(window), false,
266  BoxConstraints());
267 
268  if (add_surface) {
269  auto surface = std::make_unique<egl::MockWindowSurface>();
270  surface_ = surface.get();
271 
272  EXPECT_CALL(*surface_, Destroy).Times(AnyNumber());
273 
274  ViewModifier modifier{view_.get()};
275  modifier.SetSurface(std::move(surface));
276  }
277  }
278 
279  private:
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_;
285 
286  FML_DISALLOW_COPY_AND_ASSIGN(CompositorOpenGLTest);
287 };
288 
289 } // namespace
290 
291 TEST_F(CompositorOpenGLTest, CreateBackingStore) {
292  UseHeadlessEngine();
293 
294  auto compositor =
295  CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/false};
296 
297  FlutterBackingStoreConfig config = {};
298  FlutterBackingStore backing_store = {};
299 
300  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
301  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
302  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
303 }
304 
305 TEST_F(CompositorOpenGLTest, CreateBackingStoreImpellerNoMSAA) {
306  UseHeadlessEngine();
307 
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;
312 
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++;
320  });
321  } else if (function_name == "glFramebufferTexture2DMultisampleEXT") {
322  return reinterpret_cast<void*>(
323  +[](GLenum, GLenum, GLenum, GLuint, GLint, GLsizei) {
324  framebuffer_texture2d_multisample_calls++;
325  });
326  }
327  return kMockResolver(name);
328  };
329 
330  auto compositor =
331  CompositorOpenGL{engine(), resolver, /*enable_impeller=*/true};
332  FlutterBackingStoreConfig config = {};
333  FlutterBackingStore backing_store = {};
334 
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));
340 }
341 
342 TEST_F(CompositorOpenGLTest, CreateBackingStoreImpellerMSAA) {
343  UseHeadlessEngine();
344 
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;
349 
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++;
357  });
358  } else if (function_name == "glFramebufferTexture2DMultisampleEXT") {
359  return reinterpret_cast<void*>(
360  +[](GLenum, GLenum, GLenum, GLuint, GLint, GLsizei) {
361  framebuffer_texture2d_multisample_calls++;
362  });
363  }
364  return kMockResolverWithMSAA(name);
365  };
366 
367  auto compositor =
368  CompositorOpenGL{engine(), resolver, /*enable_impeller=*/true};
369  FlutterBackingStoreConfig config = {};
370  FlutterBackingStore backing_store = {};
371 
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));
377 }
378 
379 // Verifies that when implicit MSAA is unsupported but offscreen MSAA is
380 // supported (OpenGL ES 3.0+ with GL_MAX_SAMPLES >= 4), CompositorOpenGL
381 // creates 4x MSAA color and depth/stencil renderbuffers.
382 TEST_F(CompositorOpenGLTest, CreateBackingStoreImpellerOffscreenMSAA) {
383  UseHeadlessEngine();
384 
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;
392 
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;
400 
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++;
408  });
409  } else if (function_name == "glFramebufferTexture2DMultisampleEXT") {
410  return reinterpret_cast<void*>(
411  +[](GLenum, GLenum, GLenum, GLuint, GLint, GLsizei) {
412  framebuffer_texture2d_multisample_calls++;
413  });
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++;
419  }
420  });
421  } else if (function_name == "glRenderbufferStorageMultisample") {
422  return reinterpret_cast<void*>(+[](GLenum target, GLsizei samples,
423  GLenum internalformat, GLsizei width,
424  GLsizei height) {
425  renderbuffer_storage_multisample_calls++;
426  renderbuffer_storage_multisample_samples = samples;
427  });
428  } else if (function_name == "glFramebufferRenderbuffer") {
429  return reinterpret_cast<void*>(+[](GLenum, GLenum, GLenum, GLuint) {
430  framebuffer_renderbuffer_calls++;
431  });
432  } else if (function_name == "glDeleteRenderbuffers") {
433  return reinterpret_cast<void*>(
434  +[](GLsizei n, const GLuint* renderbuffers) {
435  delete_renderbuffers_calls += n;
436  });
437  } else if (function_name == "glDeleteTextures") {
438  return reinterpret_cast<void*>(+[](GLsizei n, const GLuint* textures) {
439  delete_textures_calls += n;
440  });
441  }
442  return kMockResolverWithOffscreenMSAA(name);
443  };
444 
445  auto compositor =
446  CompositorOpenGL{engine(), resolver, /*enable_impeller=*/true};
447  FlutterBackingStoreConfig config = {};
448  FlutterBackingStore backing_store = {};
449 
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);
457 
458  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
459  EXPECT_EQ(delete_renderbuffers_calls, 2);
460  EXPECT_EQ(delete_textures_calls, 0);
461 }
462 
463 // OpenGL ES 2.0 rejects a sized internal format in glTexImage2D, so the
464 // texture gets the unsized format while the engine still receives the sized one
465 TEST_F(CompositorOpenGLTest, CreateBackingStoreGLES2Unsized) {
466  UseHeadlessEngine();
467 
468  auto compositor = CompositorOpenGL{engine(), kRecordingResolverGLES2,
469  /*enable_impeller=*/false};
470  FlutterBackingStoreConfig config = {};
471  FlutterBackingStore backing_store = {};
472 
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));
479 }
480 
481 TEST_F(CompositorOpenGLTest, CreateBackingStoreImpellerGLES2Unsized) {
482  UseHeadlessEngine();
483 
484  auto compositor = CompositorOpenGL{engine(), kRecordingResolverGLES2,
485  /*enable_impeller=*/true};
486  FlutterBackingStoreConfig config = {};
487  FlutterBackingStore backing_store = {};
488 
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));
493 }
494 
495 TEST_F(CompositorOpenGLTest, CreateBackingStoreGLES3Sized) {
496  UseHeadlessEngine();
497 
498  auto compositor = CompositorOpenGL{engine(), kRecordingResolverGLES3,
499  /*enable_impeller=*/false};
500  FlutterBackingStoreConfig config = {};
501  FlutterBackingStore backing_store = {};
502 
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));
507 }
508 
509 TEST_F(CompositorOpenGLTest, InitializationFailure) {
510  UseHeadlessEngine();
511 
512  auto compositor =
513  CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/false};
514 
515  FlutterBackingStoreConfig config = {};
516  FlutterBackingStore backing_store = {};
517 
518  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(false));
519  EXPECT_FALSE(compositor.CreateBackingStore(config, &backing_store));
520 }
521 
522 TEST_F(CompositorOpenGLTest, InitializationRequiresBlit) {
523  UseHeadlessEngine();
524 
525  const impeller::ProcTableGLES::Resolver resolver = [](const char* name) {
526  std::string function_name{name};
527 
528  if (function_name == "glBlitFramebuffer" ||
529  function_name == "glBlitFramebufferANGLE") {
530  return (void*)nullptr;
531  }
532 
533  return kMockResolver(name);
534  };
535 
536  auto compositor =
537  CompositorOpenGL{engine(), resolver, /*enable_impeller=*/false};
538 
539  FlutterBackingStoreConfig config = {};
540  FlutterBackingStore backing_store = {};
541 
542  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
543  ASSERT_FALSE(compositor.CreateBackingStore(config, &backing_store));
544 }
545 
546 TEST_F(CompositorOpenGLTest, Present) {
547  UseEngineWithView();
548 
549  auto compositor =
550  CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/false};
551 
552  FlutterBackingStoreConfig config = {};
553  FlutterBackingStore backing_store = {};
554 
555  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
556  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
557 
558  FlutterLayer layer = {};
559  layer.type = kFlutterLayerContentTypeBackingStore;
560  layer.backing_store = &backing_store;
561  const FlutterLayer* layer_ptr = &layer;
562 
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));
567 
568  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
569 }
570 
571 TEST_F(CompositorOpenGLTest, PresentEmpty) {
572  UseEngineWithView();
573 
574  auto compositor =
575  CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/false};
576 
577  // The context will be bound twice: first to initialize the compositor, second
578  // to clear the surface.
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));
584 }
585 
586 TEST_F(CompositorOpenGLTest, NoSurfaceIgnored) {
587  UseEngineWithView(/*add_surface = */ false);
588 
589  auto compositor =
590  CompositorOpenGL{engine(), kMockResolver, /*enable_impeller=*/false};
591 
592  FlutterBackingStoreConfig config = {};
593  FlutterBackingStore backing_store = {};
594 
595  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
596  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
597 
598  FlutterLayer layer = {};
599  layer.type = kFlutterLayerContentTypeBackingStore;
600  layer.backing_store = &backing_store;
601  const FlutterLayer* layer_ptr = &layer;
602 
603  EXPECT_FALSE(compositor.Present(view(), &layer_ptr, 1));
604 
605  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
606 }
607 
608 TEST_F(CompositorOpenGLTest, PresentUsingANGLEBlitExtension) {
609  UseEngineWithView();
610 
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};
615 
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);
621  }
622 
623  return kMockResolver(name);
624  };
625 
626  auto compositor =
627  CompositorOpenGL{engine(), resolver, /*enable_impeller=*/false};
628 
629  FlutterBackingStoreConfig config = {};
630  FlutterBackingStore backing_store = {};
631 
632  EXPECT_CALL(*render_context(), MakeCurrent).WillOnce(Return(true));
633  ASSERT_TRUE(compositor.CreateBackingStore(config, &backing_store));
634 
635  FlutterLayer layer = {};
636  layer.type = kFlutterLayerContentTypeBackingStore;
637  layer.backing_store = &backing_store;
638  const FlutterLayer* layer_ptr = &layer;
639 
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);
645 
646  ASSERT_TRUE(compositor.CollectBackingStore(&backing_store));
647 }
648 
649 } // namespace testing
650 } // namespace flutter
const char * name
TEST_F(AccessibilityPluginTest, DirectAnnounceCall)
constexpr FlutterViewId kImplicitViewId