Flutter Linux Embedder
fl_compositor_opengl_test.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 <thread>
6 #include "flutter/shell/platform/linux/testing/linux_test.h"
7 #include "gtest/gtest.h"
8 
9 #include "flutter/common/constants.h"
10 #include "flutter/fml/logging.h"
16 #include "flutter/shell/platform/linux/testing/mock_epoxy.h"
17 #include "flutter/shell/platform/linux/testing/mock_gtk.h"
18 #include "flutter/shell/platform/linux/testing/mock_renderable.h"
19 
20 #include <epoxy/egl.h>
21 
22 class FlCompositorOpenGLTest : public flutter::testing::LinuxTest {
23  protected:
24  void SetUp() override {
26  renderable = fl_mock_renderable_new();
27  fl_engine_set_implicit_view(engine, FL_RENDERABLE(renderable));
28  }
29 
31  g_clear_object(&compositor);
32  g_clear_object(&renderable);
33  g_clear_object(&opengl_manager);
34  }
35 
36  ::testing::NiceMock<flutter::testing::MockEpoxy> epoxy;
37  FlOpenGLManager* opengl_manager = nullptr;
38  FlMockRenderable* renderable = nullptr;
39  FlCompositorOpenGL* compositor = nullptr;
40 };
41 
42 // The layers replace the target contents, so a frame with nothing to
43 // rasterize (which has no layers) clears the previous frame.
44 TEST_F(FlCompositorOpenGLTest, CompositeNoLayers) {
45  compositor = fl_compositor_opengl_new(opengl_manager);
46 
47  EXPECT_CALL(epoxy, glClear(GL_COLOR_BUFFER_BIT));
48 
49  fl_compositor_opengl_composite_layers(compositor, nullptr, 0);
50 }
51 
53  constexpr size_t width = 100;
54  constexpr size_t height = 100;
55  compositor = fl_compositor_opengl_new(opengl_manager);
56  g_autoptr(FlFramebuffer) target =
57  fl_framebuffer_new(GL_RGBA, width, height, FALSE);
58  g_autoptr(FlFramebuffer) framebuffer =
59  fl_framebuffer_new(GL_RGB, width, height, FALSE);
60  FlutterBackingStore backing_store = {
61  .type = kFlutterBackingStoreTypeOpenGL,
62  .open_gl = {.framebuffer = {.user_data = framebuffer}}};
63  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
64  .backing_store = &backing_store,
65  .offset = {0, 0},
66  .size = {width, height}};
67  const FlutterLayer* layers[1] = {&layer};
68  // Composite the layers from a thread, as is done on the raster thread.
69  std::thread([&]() {
70  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fl_framebuffer_get_id(target));
72  }).join();
73 }
74 
75 TEST_F(FlCompositorOpenGLTest, RestoresGLState) {
76  constexpr size_t width = 100;
77  constexpr size_t height = 100;
78 
79  // OpenGL 3.0
80  ON_CALL(epoxy, glGetString(GL_VENDOR))
81  .WillByDefault(
82  ::testing::Return(reinterpret_cast<const GLubyte*>("Intel")));
83  ON_CALL(epoxy, epoxy_is_desktop_gl).WillByDefault(::testing::Return(true));
84  ON_CALL(epoxy, epoxy_gl_version).WillByDefault(::testing::Return(30));
85 
86  compositor = fl_compositor_opengl_new(opengl_manager);
87 
88  g_autoptr(FlFramebuffer) target =
89  fl_framebuffer_new(GL_RGBA, width, height, FALSE);
90  g_autoptr(FlFramebuffer) framebuffer =
91  fl_framebuffer_new(GL_RGB, width, height, FALSE);
92  FlutterBackingStore backing_store = {
93  .type = kFlutterBackingStoreTypeOpenGL,
94  .open_gl = {.framebuffer = {.user_data = framebuffer}}};
95  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
96  .backing_store = &backing_store,
97  .offset = {0, 0},
98  .size = {width, height}};
99  const FlutterLayer* layers[1] = {&layer};
100 
101  constexpr GLuint kFakeTextureName = 123;
102  glBindTexture(GL_TEXTURE_2D, kFakeTextureName);
103  glDisable(GL_BLEND);
104  glEnable(GL_SCISSOR_TEST);
105 
106  // Composite the layers.
107  std::thread([&]() {
108  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fl_framebuffer_get_id(target));
110  }).join();
111 
112  GLuint texture_2d_binding;
113  glGetIntegerv(GL_TEXTURE_BINDING_2D,
114  reinterpret_cast<GLint*>(&texture_2d_binding));
115  EXPECT_EQ(texture_2d_binding, kFakeTextureName);
116  EXPECT_EQ(glIsEnabled(GL_BLEND), GL_FALSE);
117  EXPECT_EQ(glIsEnabled(GL_SCISSOR_TEST), GL_TRUE);
118 }
119 
120 TEST_F(FlCompositorOpenGLTest, BlitFramebuffer) {
121  constexpr size_t width = 100;
122  constexpr size_t height = 100;
123 
124  // OpenGL 3.0
125  ON_CALL(epoxy, glGetString(GL_VENDOR))
126  .WillByDefault(
127  ::testing::Return(reinterpret_cast<const GLubyte*>("Intel")));
128  ON_CALL(epoxy, epoxy_is_desktop_gl).WillByDefault(::testing::Return(true));
129  EXPECT_CALL(epoxy, epoxy_gl_version).WillRepeatedly(::testing::Return(30));
130 
131  EXPECT_CALL(epoxy, glBlitFramebuffer);
132 
133  compositor = fl_compositor_opengl_new(opengl_manager);
134 
135  g_autoptr(FlFramebuffer) target =
136  fl_framebuffer_new(GL_RGBA, width, height, FALSE);
137  g_autoptr(FlFramebuffer) framebuffer =
138  fl_framebuffer_new(GL_RGB, width, height, FALSE);
139  FlutterBackingStore backing_store = {
140  .type = kFlutterBackingStoreTypeOpenGL,
141  .open_gl = {.framebuffer = {.user_data = framebuffer}}};
142  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
143  .backing_store = &backing_store,
144  .offset = {0, 0},
145  .size = {width, height}};
146  const FlutterLayer* layers[1] = {&layer};
147 
148  std::thread([&]() {
149  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fl_framebuffer_get_id(target));
151  }).join();
152 }
153 
154 TEST_F(FlCompositorOpenGLTest, BlitFramebufferExtension) {
155  constexpr size_t width = 100;
156  constexpr size_t height = 100;
157 
158  // OpenGL 2.0 with GL_EXT_framebuffer_blit extension
159  ON_CALL(epoxy, glGetString(GL_VENDOR))
160  .WillByDefault(
161  ::testing::Return(reinterpret_cast<const GLubyte*>("Intel")));
162  ON_CALL(epoxy, epoxy_is_desktop_gl).WillByDefault(::testing::Return(true));
163  EXPECT_CALL(epoxy, epoxy_gl_version).WillRepeatedly(::testing::Return(20));
164  EXPECT_CALL(epoxy, epoxy_has_gl_extension(::testing::_))
165  .WillRepeatedly(::testing::Return(false));
166  EXPECT_CALL(epoxy, epoxy_has_gl_extension(
167  ::testing::StrEq("GL_EXT_framebuffer_blit")))
168  .WillRepeatedly(::testing::Return(true));
169 
170  EXPECT_CALL(epoxy, glBlitFramebuffer);
171 
172  compositor = fl_compositor_opengl_new(opengl_manager);
173 
174  g_autoptr(FlFramebuffer) target =
175  fl_framebuffer_new(GL_RGBA, width, height, FALSE);
176  g_autoptr(FlFramebuffer) framebuffer =
177  fl_framebuffer_new(GL_RGB, width, height, FALSE);
178  FlutterBackingStore backing_store = {
179  .type = kFlutterBackingStoreTypeOpenGL,
180  .open_gl = {.framebuffer = {.user_data = framebuffer}}};
181  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
182  .backing_store = &backing_store,
183  .offset = {0, 0},
184  .size = {width, height}};
185  const FlutterLayer* layers[1] = {&layer};
186 
187  std::thread([&]() {
188  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fl_framebuffer_get_id(target));
190  }).join();
191 }
192 
193 TEST_F(FlCompositorOpenGLTest, NoBlitFramebuffer) {
194  constexpr size_t width = 100;
195  constexpr size_t height = 100;
196 
197  // OpenGL 2.0
198  ON_CALL(epoxy, glGetString(GL_VENDOR))
199  .WillByDefault(
200  ::testing::Return(reinterpret_cast<const GLubyte*>("Intel")));
201  ON_CALL(epoxy, epoxy_is_desktop_gl).WillByDefault(::testing::Return(true));
202  EXPECT_CALL(epoxy, epoxy_gl_version).WillRepeatedly(::testing::Return(20));
203 
204  EXPECT_CALL(epoxy, glBlitFramebuffer).Times(0);
205 
206  compositor = fl_compositor_opengl_new(opengl_manager);
207 
208  g_autoptr(FlFramebuffer) target =
209  fl_framebuffer_new(GL_RGBA, width, height, FALSE);
210  g_autoptr(FlFramebuffer) framebuffer =
211  fl_framebuffer_new(GL_RGB, width, height, FALSE);
212  FlutterBackingStore backing_store = {
213  .type = kFlutterBackingStoreTypeOpenGL,
214  .open_gl = {.framebuffer = {.user_data = framebuffer}}};
215  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
216  .backing_store = &backing_store,
217  .offset = {0, 0},
218  .size = {width, height}};
219  const FlutterLayer* layers[1] = {&layer};
220 
221  std::thread([&]() {
222  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fl_framebuffer_get_id(target));
224  }).join();
225 }
226 
227 TEST_F(FlCompositorOpenGLTest, BlitFramebufferNvidia) {
228  constexpr size_t width = 100;
229  constexpr size_t height = 100;
230 
231  // OpenGL 3.0, but on NVIDIA driver so temporarily disabled due to
232  // https://github.com/flutter/flutter/issues/152099
233  ON_CALL(epoxy, glGetString(GL_VENDOR))
234  .WillByDefault(
235  ::testing::Return(reinterpret_cast<const GLubyte*>("NVIDIA")));
236  ON_CALL(epoxy, epoxy_is_desktop_gl).WillByDefault(::testing::Return(true));
237  EXPECT_CALL(epoxy, epoxy_gl_version).WillRepeatedly(::testing::Return(30));
238 
239  EXPECT_CALL(epoxy, glBlitFramebuffer).Times(0);
240 
241  compositor = fl_compositor_opengl_new(opengl_manager);
242 
243  g_autoptr(FlFramebuffer) target =
244  fl_framebuffer_new(GL_RGBA, width, height, FALSE);
245  g_autoptr(FlFramebuffer) framebuffer =
246  fl_framebuffer_new(GL_RGB, width, height, FALSE);
247  FlutterBackingStore backing_store = {
248  .type = kFlutterBackingStoreTypeOpenGL,
249  .open_gl = {.framebuffer = {.user_data = framebuffer}}};
250  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
251  .backing_store = &backing_store,
252  .offset = {0, 0},
253  .size = {width, height}};
254  const FlutterLayer* layers[1] = {&layer};
255 
256  std::thread([&]() {
257  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fl_framebuffer_get_id(target));
259  }).join();
260 }
261 
262 // The frame must be composited into the format the engine rendered the layers
263 // with. Deriving it from anything else (e.g. an extension check) produces an
264 // empty frame, which showed up as a black window in the subsurface renderer.
265 TEST_F(FlCompositorOpenGLTest, FrameFormatMatchesBackingStore) {
266  FlutterBackingStore bgra_backing_store = {
267  .type = kFlutterBackingStoreTypeOpenGL,
268  .open_gl = {.type = kFlutterOpenGLTargetTypeFramebuffer,
269  .framebuffer = {.target = GL_BGRA8_EXT}}};
270  FlutterLayer bgra_layer = {.type = kFlutterLayerContentTypeBackingStore,
271  .backing_store = &bgra_backing_store};
272  const FlutterLayer* bgra_layers[1] = {&bgra_layer};
273  EXPECT_EQ(fl_compositor_opengl_get_frame_format(bgra_layers, 1), GL_BGRA_EXT);
274 
275  FlutterBackingStore rgba_backing_store = {
276  .type = kFlutterBackingStoreTypeOpenGL,
277  .open_gl = {.type = kFlutterOpenGLTargetTypeFramebuffer,
278  .framebuffer = {.target = GL_RGBA8}}};
279  FlutterLayer rgba_layer = {.type = kFlutterLayerContentTypeBackingStore,
280  .backing_store = &rgba_backing_store};
281  const FlutterLayer* rgba_layers[1] = {&rgba_layer};
282  EXPECT_EQ(fl_compositor_opengl_get_frame_format(rgba_layers, 1), GL_RGBA);
283 }
284 
285 // Frames with nothing to match the format of fall back to RGBA.
286 TEST_F(FlCompositorOpenGLTest, FrameFormatDefaultsToRGBA) {
287  EXPECT_EQ(fl_compositor_opengl_get_frame_format(nullptr, 0), GL_RGBA);
288 
289  FlutterLayer no_backing_store = {.type = kFlutterLayerContentTypeBackingStore,
290  .backing_store = nullptr};
291  const FlutterLayer* no_backing_store_layers[1] = {&no_backing_store};
292  EXPECT_EQ(fl_compositor_opengl_get_frame_format(no_backing_store_layers, 1),
293  GL_RGBA);
294 
295  FlutterBackingStore software_backing_store = {
296  .type = kFlutterBackingStoreTypeSoftware};
297  FlutterLayer software_layer = {.type = kFlutterLayerContentTypeBackingStore,
298  .backing_store = &software_backing_store};
299  const FlutterLayer* software_layers[1] = {&software_layer};
300  EXPECT_EQ(fl_compositor_opengl_get_frame_format(software_layers, 1), GL_RGBA);
301 
302  // fl_engine.cc only ever creates framebuffer backing stores. A texture
303  // backing store keeps its format in a different member of the same union, so
304  // it must not be read as if it were a framebuffer.
305  FlutterBackingStore texture_backing_store = {
306  .type = kFlutterBackingStoreTypeOpenGL,
307  .open_gl = {.type = kFlutterOpenGLTargetTypeTexture,
308  .texture = {.target = GL_BGRA8_EXT}}};
309  FlutterLayer texture_layer = {.type = kFlutterLayerContentTypeBackingStore,
310  .backing_store = &texture_backing_store};
311  const FlutterLayer* texture_layers[1] = {&texture_layer};
312  EXPECT_EQ(fl_compositor_opengl_get_frame_format(texture_layers, 1), GL_RGBA);
313 }
314 
315 // Platform views have no format of their own, so the format must be taken from
316 // the backing stores around them rather than from whichever layer comes first.
317 TEST_F(FlCompositorOpenGLTest, FrameFormatSkipsPlatformViews) {
318  FlutterPlatformView platform_view = {.identifier = 1};
319  FlutterLayer platform_view_layer = {
320  .type = kFlutterLayerContentTypePlatformView,
321  .platform_view = &platform_view};
322 
323  FlutterBackingStore backing_store = {
324  .type = kFlutterBackingStoreTypeOpenGL,
325  .open_gl = {.type = kFlutterOpenGLTargetTypeFramebuffer,
326  .framebuffer = {.target = GL_BGRA8_EXT}}};
327  FlutterLayer backing_store_layer = {
328  .type = kFlutterLayerContentTypeBackingStore,
329  .backing_store = &backing_store};
330 
331  const FlutterLayer* layers[2] = {&platform_view_layer, &backing_store_layer};
332  EXPECT_EQ(fl_compositor_opengl_get_frame_format(layers, 2), GL_BGRA_EXT);
333 }
334 
335 // Regression test: the format must come from the layers, never from what the
336 // driver is capable of. Mesa advertises GL_EXT_texture_format_BGRA8888 while
337 // the engine still renders RGBA, so choosing BGRA from the extension gives a
338 // framebuffer that doesn't match the frame and composites to nothing.
339 TEST_F(FlCompositorOpenGLTest, FrameFormatIgnoresTextureFormatExtension) {
340  ON_CALL(epoxy, epoxy_has_gl_extension(::testing::_))
341  .WillByDefault(::testing::Return(true));
342 
343  FlutterBackingStore backing_store = {
344  .type = kFlutterBackingStoreTypeOpenGL,
345  .open_gl = {.type = kFlutterOpenGLTargetTypeFramebuffer,
346  .framebuffer = {.target = GL_RGBA8}}};
347  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
348  .backing_store = &backing_store};
349  const FlutterLayer* layers[1] = {&layer};
350  EXPECT_EQ(fl_compositor_opengl_get_frame_format(layers, 1), GL_RGBA);
351 }
::testing::NiceMock< flutter::testing::MockEpoxy > epoxy
g_autoptr(FlEngine) engine
void fl_compositor_opengl_composite_layers(FlCompositorOpenGL *self, const FlutterLayer **layers, size_t layers_count)
FlCompositorOpenGL * fl_compositor_opengl_new(FlOpenGLManager *opengl_manager)
GLint fl_compositor_opengl_get_frame_format(const FlutterLayer **layers, size_t layers_count)
TEST_F(FlCompositorOpenGLTest, CompositeNoLayers)
void fl_engine_set_implicit_view(FlEngine *self, FlRenderable *renderable)
Definition: fl_engine.cc:959
GLuint fl_framebuffer_get_id(FlFramebuffer *self)
FlFramebuffer * fl_framebuffer_new(GLint format, size_t width, size_t height, gboolean depth_stencil)
FlOpenGLManager * fl_opengl_manager_new()
const uint8_t uint32_t uint32_t * height
const uint8_t uint32_t * width
uint32_t * target
const FlutterLayer ** layers