Flutter Linux Embedder
fl_opengl_frame_test.cc File Reference
#include "flutter/shell/platform/linux/fl_opengl_frame.h"
#include <epoxy/gl.h>
#include "flutter/shell/platform/linux/fl_compositor_opengl.h"
#include "flutter/shell/platform/linux/fl_framebuffer.h"
#include "flutter/shell/platform/linux/fl_opengl_manager.h"
#include "flutter/shell/platform/linux/testing/linux_test.h"
#include "flutter/shell/platform/linux/testing/mock_epoxy.h"
#include "gtest/gtest.h"

Go to the source code of this file.

Classes

class  FlOpenGLFrameTest
 

Functions

 TEST_F (FlOpenGLFrameTest, GetSizeInitiallyZero)
 
 TEST_F (FlOpenGLFrameTest, CompositeRGBA)
 
 TEST_F (FlOpenGLFrameTest, CompositeBGRA)
 
 TEST_F (FlOpenGLFrameTest, ZeroSizeClearsFrame)
 
 TEST_F (FlOpenGLFrameTest, NoLayersClearsFrame)
 
 TEST_F (FlOpenGLFrameTest, NoLayersWithoutFrame)
 
 TEST_F (FlOpenGLFrameTest, CompositeReadsBackPixels)
 
 TEST_F (FlOpenGLFrameTest, CompositeNotSynchronizedTwice)
 
 TEST_F (FlOpenGLFrameTest, DrawWithoutFrame)
 
 TEST_F (FlOpenGLFrameTest, DrawUploadsPixels)
 

Function Documentation

◆ TEST_F() [1/10]

TEST_F ( FlOpenGLFrameTest  ,
CompositeBGRA   
)

Definition at line 72 of file fl_opengl_frame_test.cc.

72  {
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 }
g_autoptr(FlEngine) engine
FlFramebuffer * fl_framebuffer_new(GLint format, size_t width, size_t height, gboolean depth_stencil)
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()
const uint8_t uint32_t uint32_t * height
const uint8_t uint32_t * width
const FlutterLayer ** layers

References fl_framebuffer_new(), fl_opengl_frame_composite(), fl_opengl_frame_get_size(), fl_opengl_frame_new(), g_autoptr(), height, layers, and width.

◆ TEST_F() [2/10]

TEST_F ( FlOpenGLFrameTest  ,
CompositeNotSynchronizedTwice   
)

Definition at line 219 of file fl_opengl_frame_test.cc.

219  {
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 }

References fl_framebuffer_new(), fl_opengl_frame_composite(), fl_opengl_frame_new(), g_autoptr(), height, layers, and width.

◆ TEST_F() [3/10]

TEST_F ( FlOpenGLFrameTest  ,
CompositeReadsBackPixels   
)

Definition at line 193 of file fl_opengl_frame_test.cc.

193  {
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 }

References fl_framebuffer_new(), fl_opengl_frame_composite(), fl_opengl_frame_new(), g_autoptr(), height, layers, and width.

◆ TEST_F() [4/10]

TEST_F ( FlOpenGLFrameTest  ,
CompositeRGBA   
)

Definition at line 42 of file fl_opengl_frame_test.cc.

42  {
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 }

References fl_framebuffer_new(), fl_opengl_frame_composite(), fl_opengl_frame_get_size(), fl_opengl_frame_new(), g_autoptr(), height, layers, and width.

◆ TEST_F() [5/10]

TEST_F ( FlOpenGLFrameTest  ,
DrawUploadsPixels   
)

Definition at line 257 of file fl_opengl_frame_test.cc.

257  {
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 }
gboolean fl_opengl_frame_draw(FlOpenGLFrame *self, cairo_t *cr, GdkWindow *window, gint scale_factor, size_t width, size_t height)

References fl_framebuffer_new(), fl_opengl_frame_composite(), fl_opengl_frame_draw(), fl_opengl_frame_new(), g_autoptr(), height, layers, and width.

◆ TEST_F() [6/10]

TEST_F ( FlOpenGLFrameTest  ,
DrawWithoutFrame   
)

Definition at line 242 of file fl_opengl_frame_test.cc.

242  {
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 }

References fl_opengl_frame_draw(), fl_opengl_frame_new(), and g_autoptr().

◆ TEST_F() [7/10]

TEST_F ( FlOpenGLFrameTest  ,
GetSizeInitiallyZero   
)

Definition at line 33 of file fl_opengl_frame_test.cc.

33  {
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 }

References fl_opengl_frame_get_size(), fl_opengl_frame_new(), and g_autoptr().

◆ TEST_F() [8/10]

TEST_F ( FlOpenGLFrameTest  ,
NoLayersClearsFrame   
)

Definition at line 142 of file fl_opengl_frame_test.cc.

142  {
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 }

References fl_framebuffer_new(), fl_opengl_frame_composite(), fl_opengl_frame_get_size(), fl_opengl_frame_new(), g_autoptr(), height, layers, and width.

◆ TEST_F() [9/10]

TEST_F ( FlOpenGLFrameTest  ,
NoLayersWithoutFrame   
)

Definition at line 177 of file fl_opengl_frame_test.cc.

177  {
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 }

References fl_opengl_frame_composite(), fl_opengl_frame_get_size(), fl_opengl_frame_new(), and g_autoptr().

◆ TEST_F() [10/10]

TEST_F ( FlOpenGLFrameTest  ,
ZeroSizeClearsFrame   
)

Definition at line 102 of file fl_opengl_frame_test.cc.

102  {
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 }

References fl_framebuffer_new(), fl_opengl_frame_composite(), fl_opengl_frame_get_size(), fl_opengl_frame_new(), g_autoptr(), height, layers, and width.