Flutter Linux Embedder
fl_compositor_opengl_test.cc File Reference
#include <thread>
#include "flutter/shell/platform/linux/testing/linux_test.h"
#include "gtest/gtest.h"
#include "flutter/common/constants.h"
#include "flutter/fml/logging.h"
#include "flutter/shell/platform/linux/fl_compositor_opengl.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/fl_framebuffer.h"
#include "flutter/shell/platform/linux/fl_opengl_manager.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_dart_project.h"
#include "flutter/shell/platform/linux/testing/mock_epoxy.h"
#include "flutter/shell/platform/linux/testing/mock_gtk.h"
#include "flutter/shell/platform/linux/testing/mock_renderable.h"
#include <epoxy/egl.h>

Go to the source code of this file.

Classes

class  FlCompositorOpenGLTest
 

Functions

 TEST_F (FlCompositorOpenGLTest, CompositeNoLayers)
 
 TEST_F (FlCompositorOpenGLTest, Composite)
 
 TEST_F (FlCompositorOpenGLTest, RestoresGLState)
 
 TEST_F (FlCompositorOpenGLTest, BlitFramebuffer)
 
 TEST_F (FlCompositorOpenGLTest, BlitFramebufferExtension)
 
 TEST_F (FlCompositorOpenGLTest, NoBlitFramebuffer)
 
 TEST_F (FlCompositorOpenGLTest, BlitFramebufferNvidia)
 
 TEST_F (FlCompositorOpenGLTest, FrameFormatMatchesBackingStore)
 
 TEST_F (FlCompositorOpenGLTest, FrameFormatDefaultsToRGBA)
 
 TEST_F (FlCompositorOpenGLTest, FrameFormatSkipsPlatformViews)
 
 TEST_F (FlCompositorOpenGLTest, FrameFormatIgnoresTextureFormatExtension)
 

Function Documentation

◆ TEST_F() [1/11]

TEST_F ( FlCompositorOpenGLTest  ,
BlitFramebuffer   
)

Definition at line 120 of file fl_compositor_opengl_test.cc.

120  {
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 }
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)
GLuint fl_framebuffer_get_id(FlFramebuffer *self)
FlFramebuffer * fl_framebuffer_new(GLint format, size_t width, size_t height, gboolean depth_stencil)
const uint8_t uint32_t uint32_t * height
const uint8_t uint32_t * width
uint32_t * target
const FlutterLayer ** layers

References fl_compositor_opengl_composite_layers(), fl_compositor_opengl_new(), fl_framebuffer_get_id(), fl_framebuffer_new(), g_autoptr(), height, layers, target, and width.

◆ TEST_F() [2/11]

TEST_F ( FlCompositorOpenGLTest  ,
BlitFramebufferExtension   
)

Definition at line 154 of file fl_compositor_opengl_test.cc.

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

References fl_compositor_opengl_composite_layers(), fl_compositor_opengl_new(), fl_framebuffer_get_id(), fl_framebuffer_new(), g_autoptr(), height, layers, target, and width.

◆ TEST_F() [3/11]

TEST_F ( FlCompositorOpenGLTest  ,
BlitFramebufferNvidia   
)

Definition at line 227 of file fl_compositor_opengl_test.cc.

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

References fl_compositor_opengl_composite_layers(), fl_compositor_opengl_new(), fl_framebuffer_get_id(), fl_framebuffer_new(), g_autoptr(), height, layers, target, and width.

◆ TEST_F() [4/11]

TEST_F ( FlCompositorOpenGLTest  ,
Composite   
)

Definition at line 52 of file fl_compositor_opengl_test.cc.

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

References fl_compositor_opengl_composite_layers(), fl_compositor_opengl_new(), fl_framebuffer_get_id(), fl_framebuffer_new(), g_autoptr(), height, layers, target, and width.

◆ TEST_F() [5/11]

TEST_F ( FlCompositorOpenGLTest  ,
CompositeNoLayers   
)

Definition at line 44 of file fl_compositor_opengl_test.cc.

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

References fl_compositor_opengl_composite_layers(), and fl_compositor_opengl_new().

◆ TEST_F() [6/11]

TEST_F ( FlCompositorOpenGLTest  ,
FrameFormatDefaultsToRGBA   
)

Definition at line 286 of file fl_compositor_opengl_test.cc.

286  {
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 }
GLint fl_compositor_opengl_get_frame_format(const FlutterLayer **layers, size_t layers_count)

References fl_compositor_opengl_get_frame_format().

◆ TEST_F() [7/11]

TEST_F ( FlCompositorOpenGLTest  ,
FrameFormatIgnoresTextureFormatExtension   
)

Definition at line 339 of file fl_compositor_opengl_test.cc.

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

References fl_compositor_opengl_get_frame_format(), and layers.

◆ TEST_F() [8/11]

TEST_F ( FlCompositorOpenGLTest  ,
FrameFormatMatchesBackingStore   
)

Definition at line 265 of file fl_compositor_opengl_test.cc.

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

References fl_compositor_opengl_get_frame_format().

◆ TEST_F() [9/11]

TEST_F ( FlCompositorOpenGLTest  ,
FrameFormatSkipsPlatformViews   
)

Definition at line 317 of file fl_compositor_opengl_test.cc.

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

References fl_compositor_opengl_get_frame_format(), and layers.

◆ TEST_F() [10/11]

TEST_F ( FlCompositorOpenGLTest  ,
NoBlitFramebuffer   
)

Definition at line 193 of file fl_compositor_opengl_test.cc.

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

References fl_compositor_opengl_composite_layers(), fl_compositor_opengl_new(), fl_framebuffer_get_id(), fl_framebuffer_new(), g_autoptr(), height, layers, target, and width.

◆ TEST_F() [11/11]

TEST_F ( FlCompositorOpenGLTest  ,
RestoresGLState   
)

Definition at line 75 of file fl_compositor_opengl_test.cc.

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

References fl_compositor_opengl_composite_layers(), fl_compositor_opengl_new(), fl_framebuffer_get_id(), fl_framebuffer_new(), g_autoptr(), height, layers, target, and width.