Flutter Linux Embedder
fl_opengl_frame_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 
6 
7 #include <epoxy/gl.h>
8 
12 #include "flutter/shell/platform/linux/testing/linux_test.h"
13 #include "flutter/shell/platform/linux/testing/mock_epoxy.h"
14 #include "gtest/gtest.h"
15 
16 class FlOpenGLFrameTest : public flutter::testing::LinuxTest {
17  protected:
18  void SetUp() override {
21  }
22 
23  ~FlOpenGLFrameTest() override {
24  g_clear_object(&compositor);
25  g_clear_object(&opengl_manager);
26  }
27 
28  ::testing::NiceMock<flutter::testing::MockEpoxy> epoxy;
29  FlOpenGLManager* opengl_manager = nullptr;
30  FlCompositorOpenGL* compositor = nullptr;
31 };
32 
33 TEST_F(FlOpenGLFrameTest, GetSizeInitiallyZero) {
34  g_autoptr(FlOpenGLFrame) frame = fl_opengl_frame_new();
35  size_t frame_width = 123;
36  size_t frame_height = 456;
37  fl_opengl_frame_get_size(frame, &frame_width, &frame_height);
38  EXPECT_EQ(frame_width, 0u);
39  EXPECT_EQ(frame_height, 0u);
40 }
41 
42 TEST_F(FlOpenGLFrameTest, CompositeRGBA) {
43  constexpr size_t width = 100;
44  constexpr size_t height = 100;
45 
46  g_autoptr(FlOpenGLFrame) frame = fl_opengl_frame_new();
47  g_autoptr(FlFramebuffer) framebuffer =
48  fl_framebuffer_new(GL_RGBA, width, height, FALSE);
49  FlutterBackingStore backing_store = {
50  .type = kFlutterBackingStoreTypeOpenGL,
51  .open_gl = {
52  .type = kFlutterOpenGLTargetTypeFramebuffer,
53  .framebuffer = {.target = GL_RGBA8, .user_data = framebuffer}}};
54  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
55  .backing_store = &backing_store,
56  .offset = {0, 0},
57  .size = {width, height}};
58  const FlutterLayer* layers[1] = {&layer};
59 
60  EXPECT_CALL(epoxy, glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
61  GL_RGBA, GL_UNSIGNED_BYTE, nullptr));
62 
63  fl_opengl_frame_composite(frame, compositor, layers, 1);
64 
65  size_t frame_width = 0;
66  size_t frame_height = 0;
67  fl_opengl_frame_get_size(frame, &frame_width, &frame_height);
68  EXPECT_EQ(frame_width, width);
69  EXPECT_EQ(frame_height, height);
70 }
71 
72 TEST_F(FlOpenGLFrameTest, CompositeBGRA) {
73  constexpr size_t width = 100;
74  constexpr size_t height = 100;
75 
76  g_autoptr(FlOpenGLFrame) frame = fl_opengl_frame_new();
77  g_autoptr(FlFramebuffer) framebuffer =
78  fl_framebuffer_new(GL_BGRA_EXT, width, height, FALSE);
79  FlutterBackingStore backing_store = {
80  .type = kFlutterBackingStoreTypeOpenGL,
81  .open_gl = {
82  .type = kFlutterOpenGLTargetTypeFramebuffer,
83  .framebuffer = {.target = GL_BGRA8_EXT, .user_data = framebuffer}}};
84  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
85  .backing_store = &backing_store,
86  .offset = {0, 0},
87  .size = {width, height}};
88  const FlutterLayer* layers[1] = {&layer};
89 
90  EXPECT_CALL(epoxy, glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, width, height,
91  0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, nullptr));
92 
93  fl_opengl_frame_composite(frame, compositor, layers, 1);
94 
95  size_t frame_width = 0;
96  size_t frame_height = 0;
97  fl_opengl_frame_get_size(frame, &frame_width, &frame_height);
98  EXPECT_EQ(frame_width, width);
99  EXPECT_EQ(frame_height, height);
100 }
101 
102 TEST_F(FlOpenGLFrameTest, ZeroSizeClearsFrame) {
103  constexpr size_t width = 100;
104  constexpr size_t height = 100;
105 
106  g_autoptr(FlOpenGLFrame) frame = fl_opengl_frame_new();
107  g_autoptr(FlFramebuffer) framebuffer =
108  fl_framebuffer_new(GL_RGBA, width, height, FALSE);
109  FlutterBackingStore backing_store = {
110  .type = kFlutterBackingStoreTypeOpenGL,
111  .open_gl = {
112  .type = kFlutterOpenGLTargetTypeFramebuffer,
113  .framebuffer = {.target = GL_RGBA8, .user_data = framebuffer}}};
114  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
115  .backing_store = &backing_store,
116  .offset = {0, 0},
117  .size = {width, height}};
118  const FlutterLayer* layers[1] = {&layer};
119 
120  fl_opengl_frame_composite(frame, compositor, layers, 1);
121 
122  size_t frame_width = 0;
123  size_t frame_height = 0;
124  fl_opengl_frame_get_size(frame, &frame_width, &frame_height);
125  EXPECT_EQ(frame_width, width);
126  EXPECT_EQ(frame_height, height);
127 
128  FlutterLayer zero_layer = {.type = kFlutterLayerContentTypeBackingStore,
129  .backing_store = &backing_store,
130  .offset = {0, 0},
131  .size = {0, 0}};
132  const FlutterLayer* zero_layers[1] = {&zero_layer};
133  fl_opengl_frame_composite(frame, compositor, zero_layers, 1);
134 
135  fl_opengl_frame_get_size(frame, &frame_width, &frame_height);
136  EXPECT_EQ(frame_width, 0u);
137  EXPECT_EQ(frame_height, 0u);
138 }
139 
140 // A frame with nothing to rasterize (e.g. everything painted is fully
141 // transparent) has no layers. The previous frame must not be shown again.
142 TEST_F(FlOpenGLFrameTest, NoLayersClearsFrame) {
143  constexpr size_t width = 100;
144  constexpr size_t height = 100;
145 
146  g_autoptr(FlOpenGLFrame) frame = fl_opengl_frame_new();
147  g_autoptr(FlFramebuffer) framebuffer =
148  fl_framebuffer_new(GL_RGBA, width, height, FALSE);
149  FlutterBackingStore backing_store = {
150  .type = kFlutterBackingStoreTypeOpenGL,
151  .open_gl = {
152  .type = kFlutterOpenGLTargetTypeFramebuffer,
153  .framebuffer = {.target = GL_RGBA8, .user_data = framebuffer}}};
154  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
155  .backing_store = &backing_store,
156  .offset = {0, 0},
157  .size = {width, height}};
158  const FlutterLayer* layers[1] = {&layer};
159 
160  fl_opengl_frame_composite(frame, compositor, layers, 1);
161 
162  EXPECT_CALL(epoxy, glClear(GL_COLOR_BUFFER_BIT));
163 
164  fl_opengl_frame_composite(frame, compositor, nullptr, 0);
165 
166  // The frame is kept at the same size so it still matches the window and is
167  // drawn, showing the view background rather than the previous frame.
168  size_t frame_width = 0;
169  size_t frame_height = 0;
170  fl_opengl_frame_get_size(frame, &frame_width, &frame_height);
171  EXPECT_EQ(frame_width, width);
172  EXPECT_EQ(frame_height, height);
173 }
174 
175 // A frame with no layers received before any content has been rendered has
176 // nothing to clear.
177 TEST_F(FlOpenGLFrameTest, NoLayersWithoutFrame) {
178  g_autoptr(FlOpenGLFrame) frame = fl_opengl_frame_new();
179 
180  EXPECT_CALL(epoxy, glClear).Times(0);
181 
182  fl_opengl_frame_composite(frame, compositor, nullptr, 0);
183 
184  size_t frame_width = 123;
185  size_t frame_height = 456;
186  fl_opengl_frame_get_size(frame, &frame_width, &frame_height);
187  EXPECT_EQ(frame_width, 0u);
188  EXPECT_EQ(frame_height, 0u);
189 }
190 
191 // Frames are copied into CPU memory so they can be used in the OpenGL context
192 // GTK draws with, which doesn't share objects with the Flutter context.
193 TEST_F(FlOpenGLFrameTest, CompositeReadsBackPixels) {
194  constexpr size_t width = 100;
195  constexpr size_t height = 100;
196 
197  g_autoptr(FlOpenGLFrame) frame = fl_opengl_frame_new();
198  g_autoptr(FlFramebuffer) framebuffer =
199  fl_framebuffer_new(GL_RGBA, width, height, FALSE);
200  FlutterBackingStore backing_store = {
201  .type = kFlutterBackingStoreTypeOpenGL,
202  .open_gl = {
203  .type = kFlutterOpenGLTargetTypeFramebuffer,
204  .framebuffer = {.target = GL_RGBA8, .user_data = framebuffer}}};
205  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
206  .backing_store = &backing_store,
207  .offset = {0, 0},
208  .size = {width, height}};
209  const FlutterLayer* layers[1] = {&layer};
210 
211  EXPECT_CALL(epoxy, glReadPixels(0, 0, width, height, GL_RGBA,
212  GL_UNSIGNED_BYTE, ::testing::NotNull()));
213 
214  fl_opengl_frame_composite(frame, compositor, layers, 1);
215 }
216 
217 // Checks a frame does not pay for a second synchronization - glReadPixels()
218 // already waits for the frame to be rendered.
219 TEST_F(FlOpenGLFrameTest, CompositeNotSynchronizedTwice) {
220  constexpr size_t width = 100;
221  constexpr size_t height = 100;
222 
223  g_autoptr(FlOpenGLFrame) frame = fl_opengl_frame_new();
224  g_autoptr(FlFramebuffer) framebuffer =
225  fl_framebuffer_new(GL_RGBA, width, height, FALSE);
226  FlutterBackingStore backing_store = {
227  .type = kFlutterBackingStoreTypeOpenGL,
228  .open_gl = {
229  .type = kFlutterOpenGLTargetTypeFramebuffer,
230  .framebuffer = {.target = GL_RGBA8, .user_data = framebuffer}}};
231  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
232  .backing_store = &backing_store,
233  .offset = {0, 0},
234  .size = {width, height}};
235  const FlutterLayer* layers[1] = {&layer};
236 
237  EXPECT_CALL(epoxy, glFinish()).Times(0);
238 
239  fl_opengl_frame_composite(frame, compositor, layers, 1);
240 }
241 
242 TEST_F(FlOpenGLFrameTest, DrawWithoutFrame) {
243  g_autoptr(FlOpenGLFrame) frame = fl_opengl_frame_new();
244 
245  cairo_surface_t* surface =
246  cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 100, 100);
247  cairo_t* cr = cairo_create(surface);
248 
249  EXPECT_FALSE(fl_opengl_frame_draw(frame, cr, nullptr, 1, 100, 100));
250 
251  cairo_destroy(cr);
252  cairo_surface_destroy(surface);
253 }
254 
255 // The composited frame is uploaded from CPU memory into a texture in the
256 // context being drawn with, then discarded once drawn.
257 TEST_F(FlOpenGLFrameTest, DrawUploadsPixels) {
258  constexpr size_t width = 100;
259  constexpr size_t height = 100;
260 
261  g_autoptr(FlOpenGLFrame) frame = fl_opengl_frame_new();
262  g_autoptr(FlFramebuffer) framebuffer =
263  fl_framebuffer_new(GL_RGBA, width, height, FALSE);
264  FlutterBackingStore backing_store = {
265  .type = kFlutterBackingStoreTypeOpenGL,
266  .open_gl = {
267  .type = kFlutterOpenGLTargetTypeFramebuffer,
268  .framebuffer = {.target = GL_RGBA8, .user_data = framebuffer}}};
269  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
270  .backing_store = &backing_store,
271  .offset = {0, 0},
272  .size = {width, height}};
273  const FlutterLayer* layers[1] = {&layer};
274 
275  fl_opengl_frame_composite(frame, compositor, layers, 1);
276 
277  cairo_surface_t* surface =
278  cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
279  cairo_t* cr = cairo_create(surface);
280 
281  EXPECT_CALL(epoxy,
282  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
283  GL_UNSIGNED_BYTE, ::testing::NotNull()));
284  EXPECT_CALL(epoxy, glDeleteTextures(1, ::testing::NotNull()));
285 
286  EXPECT_TRUE(fl_opengl_frame_draw(frame, cr, nullptr, 1, width, height));
287 
288  // Check the texture was deleted by the draw, not by the later teardown of
289  // the frame and framebuffer.
290  ::testing::Mock::VerifyAndClearExpectations(&epoxy);
291 
292  cairo_destroy(cr);
293  cairo_surface_destroy(surface);
294 }
::testing::NiceMock< flutter::testing::MockEpoxy > epoxy
FlOpenGLManager * opengl_manager
FlCompositorOpenGL * compositor
g_autoptr(FlEngine) engine
FlCompositorOpenGL * fl_compositor_opengl_new(FlOpenGLManager *opengl_manager)
FlFramebuffer * fl_framebuffer_new(GLint format, size_t width, size_t height, gboolean depth_stencil)
gboolean fl_opengl_frame_draw(FlOpenGLFrame *self, cairo_t *cr, GdkWindow *window, gint scale_factor, size_t width, size_t height)
void fl_opengl_frame_get_size(FlOpenGLFrame *self, size_t *width, size_t *height)
void fl_opengl_frame_composite(FlOpenGLFrame *self, FlCompositorOpenGL *compositor, const FlutterLayer **layers, size_t layers_count)
FlOpenGLFrame * fl_opengl_frame_new()
TEST_F(FlOpenGLFrameTest, GetSizeInitiallyZero)
FlOpenGLManager * fl_opengl_manager_new()
const uint8_t uint32_t uint32_t * height
const uint8_t uint32_t * width
const FlutterLayer ** layers