Flutter Linux Embedder
Functions
fl_compositor_opengl_test.cc File Reference
#include <thread>
#include "gtest/gtest.h"
#include "flutter/common/constants.h"
#include "flutter/fml/logging.h"
#include "flutter/fml/synchronization/waitable_event.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_renderable.h"
#include <epoxy/egl.h>

Go to the source code of this file.

Functions

 TEST (FlCompositorOpenGLTest, Render)
 
 TEST (FlCompositorOpenGLTest, Resize)
 
 TEST (FlCompositorOpenGLTest, RestoresGLState)
 
 TEST (FlCompositorOpenGLTest, BlitFramebuffer)
 
 TEST (FlCompositorOpenGLTest, BlitFramebufferExtension)
 
 TEST (FlCompositorOpenGLTest, NoBlitFramebuffer)
 
 TEST (FlCompositorOpenGLTest, BlitFramebufferNvidia)
 

Function Documentation

◆ TEST() [1/7]

TEST ( FlCompositorOpenGLTest  ,
BlitFramebuffer   
)

Definition at line 184 of file fl_compositor_opengl_test.cc.

184  {
185  ::testing::NiceMock<flutter::testing::MockEpoxy> epoxy;
186  g_autoptr(FlDartProject) project = fl_dart_project_new();
187  g_autoptr(FlEngine) engine = fl_engine_new(project);
188  g_autoptr(FlTaskRunner) task_runner = fl_task_runner_new(engine);
189  g_autoptr(FlOpenGLManager) opengl_manager = fl_opengl_manager_new();
190 
191  constexpr size_t width = 100;
192  constexpr size_t height = 100;
193 
194  // OpenGL 3.0
195  ON_CALL(epoxy, glGetString(GL_VENDOR))
196  .WillByDefault(
197  ::testing::Return(reinterpret_cast<const GLubyte*>("Intel")));
198  ON_CALL(epoxy, epoxy_is_desktop_gl).WillByDefault(::testing::Return(true));
199  EXPECT_CALL(epoxy, epoxy_gl_version).WillRepeatedly(::testing::Return(30));
200 
201  EXPECT_CALL(epoxy, glBlitFramebuffer);
202 
203  g_autoptr(FlMockRenderable) renderable = fl_mock_renderable_new();
204  g_autoptr(FlCompositorOpenGL) compositor =
205  fl_compositor_opengl_new(task_runner, opengl_manager, FALSE);
206  fl_engine_set_implicit_view(engine, FL_RENDERABLE(renderable));
207 
208  g_autoptr(FlFramebuffer) framebuffer =
209  fl_framebuffer_new(GL_RGB, width, height, FALSE);
210  FlutterBackingStore backing_store = {
211  .type = kFlutterBackingStoreTypeOpenGL,
212  .open_gl = {.framebuffer = {.user_data = framebuffer}}};
213  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
214  .backing_store = &backing_store,
215  .offset = {0, 0},
216  .size = {width, height}};
217  const FlutterLayer* layers[1] = {&layer};
218 
219  // Present layer and render.
220  std::thread([&]() {
221  fl_compositor_present_layers(FL_COMPOSITOR(compositor), layers, 1);
222  }).join();
223  int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
224  g_autofree unsigned char* image_data =
225  static_cast<unsigned char*>(malloc(height * stride));
226  cairo_surface_t* surface = cairo_image_surface_create_for_data(
227  image_data, CAIRO_FORMAT_ARGB32, width, height, stride);
228  cairo_t* cr = cairo_create(surface);
229  fl_compositor_render(FL_COMPOSITOR(compositor), cr, nullptr);
230  cairo_surface_destroy(surface);
231  cairo_destroy(cr);
232 }
fl_compositor_render
gboolean fl_compositor_render(FlCompositor *self, cairo_t *cr, GdkWindow *window)
Definition: fl_compositor.cc:23
fl_compositor_present_layers
gboolean fl_compositor_present_layers(FlCompositor *self, const FlutterLayer **layers, size_t layers_count)
Definition: fl_compositor.cc:15
fl_compositor_opengl_new
FlCompositorOpenGL * fl_compositor_opengl_new(FlTaskRunner *task_runner, FlOpenGLManager *opengl_manager, gboolean shareable)
Definition: fl_compositor_opengl.cc:442
opengl_manager
G_BEGIN_DECLS FlOpenGLManager * opengl_manager
Definition: fl_compositor_opengl.h:42
layers
const FlutterLayer ** layers
Definition: fl_compositor_software.cc:32
height
self height
Definition: fl_compositor_software.cc:43
g_autoptr
g_autoptr(GMutexLocker) locker
width
self width
Definition: fl_compositor_software.cc:42
fl_dart_project_new
G_MODULE_EXPORT FlDartProject * fl_dart_project_new()
Definition: fl_dart_project.cc:52
fl_engine_set_implicit_view
void fl_engine_set_implicit_view(FlEngine *self, FlRenderable *renderable)
Definition: fl_engine.cc:881
fl_engine_new
G_MODULE_EXPORT FlEngine * fl_engine_new(FlDartProject *project)
Definition: fl_engine.cc:697
fl_framebuffer_new
FlFramebuffer * fl_framebuffer_new(GLint format, size_t width, size_t height, gboolean shareable)
Definition: fl_framebuffer.cc:69
fl_opengl_manager_new
FlOpenGLManager * fl_opengl_manager_new()
Definition: fl_opengl_manager.cc:70
fl_task_runner_new
FlTaskRunner * fl_task_runner_new(FlEngine *engine)
Definition: fl_task_runner.cc:147

References fl_compositor_opengl_new(), fl_compositor_present_layers(), fl_compositor_render(), fl_dart_project_new(), fl_engine_new(), fl_engine_set_implicit_view(), fl_framebuffer_new(), fl_opengl_manager_new(), fl_task_runner_new(), g_autoptr(), height, layers, opengl_manager, and width.

◆ TEST() [2/7]

TEST ( FlCompositorOpenGLTest  ,
BlitFramebufferExtension   
)

Definition at line 234 of file fl_compositor_opengl_test.cc.

234  {
235  ::testing::NiceMock<flutter::testing::MockEpoxy> epoxy;
236  g_autoptr(FlDartProject) project = fl_dart_project_new();
237  g_autoptr(FlEngine) engine = fl_engine_new(project);
238  g_autoptr(FlTaskRunner) task_runner = fl_task_runner_new(engine);
239  g_autoptr(FlOpenGLManager) opengl_manager = fl_opengl_manager_new();
240 
241  constexpr size_t width = 100;
242  constexpr size_t height = 100;
243 
244  // OpenGL 2.0 with GL_EXT_framebuffer_blit extension
245  ON_CALL(epoxy, glGetString(GL_VENDOR))
246  .WillByDefault(
247  ::testing::Return(reinterpret_cast<const GLubyte*>("Intel")));
248  ON_CALL(epoxy, epoxy_is_desktop_gl).WillByDefault(::testing::Return(true));
249  EXPECT_CALL(epoxy, epoxy_gl_version).WillRepeatedly(::testing::Return(20));
250  EXPECT_CALL(epoxy, epoxy_has_gl_extension(::testing::_))
251  .WillRepeatedly(::testing::Return(false));
252  EXPECT_CALL(epoxy, epoxy_has_gl_extension(
253  ::testing::StrEq("GL_EXT_framebuffer_blit")))
254  .WillRepeatedly(::testing::Return(true));
255 
256  EXPECT_CALL(epoxy, glBlitFramebuffer);
257 
258  g_autoptr(FlMockRenderable) renderable = fl_mock_renderable_new();
259  g_autoptr(FlCompositorOpenGL) compositor =
260  fl_compositor_opengl_new(task_runner, opengl_manager, FALSE);
261  fl_engine_set_implicit_view(engine, FL_RENDERABLE(renderable));
262 
263  g_autoptr(FlFramebuffer) framebuffer =
264  fl_framebuffer_new(GL_RGB, width, height, FALSE);
265  FlutterBackingStore backing_store = {
266  .type = kFlutterBackingStoreTypeOpenGL,
267  .open_gl = {.framebuffer = {.user_data = framebuffer}}};
268  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
269  .backing_store = &backing_store,
270  .offset = {0, 0},
271  .size = {width, height}};
272  const FlutterLayer* layers[1] = {&layer};
273 
274  // Present layer and render.
275  std::thread([&]() {
276  fl_compositor_present_layers(FL_COMPOSITOR(compositor), layers, 1);
277  }).join();
278  int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
279  g_autofree unsigned char* image_data =
280  static_cast<unsigned char*>(malloc(height * stride));
281  cairo_surface_t* surface = cairo_image_surface_create_for_data(
282  image_data, CAIRO_FORMAT_ARGB32, width, height, stride);
283  cairo_t* cr = cairo_create(surface);
284  fl_compositor_render(FL_COMPOSITOR(compositor), cr, nullptr);
285  cairo_surface_destroy(surface);
286  cairo_destroy(cr);
287 }

References fl_compositor_opengl_new(), fl_compositor_present_layers(), fl_compositor_render(), fl_dart_project_new(), fl_engine_new(), fl_engine_set_implicit_view(), fl_framebuffer_new(), fl_opengl_manager_new(), fl_task_runner_new(), g_autoptr(), height, layers, opengl_manager, and width.

◆ TEST() [3/7]

TEST ( FlCompositorOpenGLTest  ,
BlitFramebufferNvidia   
)

Definition at line 337 of file fl_compositor_opengl_test.cc.

337  {
338  ::testing::NiceMock<flutter::testing::MockEpoxy> epoxy;
339  g_autoptr(FlDartProject) project = fl_dart_project_new();
340  g_autoptr(FlEngine) engine = fl_engine_new(project);
341  g_autoptr(FlTaskRunner) task_runner = fl_task_runner_new(engine);
342  g_autoptr(FlOpenGLManager) opengl_manager = fl_opengl_manager_new();
343 
344  constexpr size_t width = 100;
345  constexpr size_t height = 100;
346 
347  // OpenGL 3.0, but on NVIDIA driver so temporarily disabled due to
348  // https://github.com/flutter/flutter/issues/152099
349  ON_CALL(epoxy, glGetString(GL_VENDOR))
350  .WillByDefault(
351  ::testing::Return(reinterpret_cast<const GLubyte*>("NVIDIA")));
352  ON_CALL(epoxy, epoxy_is_desktop_gl).WillByDefault(::testing::Return(true));
353  EXPECT_CALL(epoxy, epoxy_gl_version).WillRepeatedly(::testing::Return(30));
354 
355  g_autoptr(FlMockRenderable) renderable = fl_mock_renderable_new();
356  g_autoptr(FlCompositorOpenGL) compositor =
357  fl_compositor_opengl_new(task_runner, opengl_manager, FALSE);
358  fl_engine_set_implicit_view(engine, FL_RENDERABLE(renderable));
359 
360  g_autoptr(FlFramebuffer) framebuffer =
361  fl_framebuffer_new(GL_RGB, width, height, FALSE);
362  FlutterBackingStore backing_store = {
363  .type = kFlutterBackingStoreTypeOpenGL,
364  .open_gl = {.framebuffer = {.user_data = framebuffer}}};
365  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
366  .backing_store = &backing_store,
367  .offset = {0, 0},
368  .size = {width, height}};
369  const FlutterLayer* layers[1] = {&layer};
370 
371  // Present layer and render.
372  std::thread([&]() {
373  fl_compositor_present_layers(FL_COMPOSITOR(compositor), layers, 1);
374  }).join();
375  int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
376  g_autofree unsigned char* image_data =
377  static_cast<unsigned char*>(malloc(height * stride));
378  cairo_surface_t* surface = cairo_image_surface_create_for_data(
379  image_data, CAIRO_FORMAT_ARGB32, width, height, stride);
380  cairo_t* cr = cairo_create(surface);
381  fl_compositor_render(FL_COMPOSITOR(compositor), cr, nullptr);
382  cairo_surface_destroy(surface);
383  cairo_destroy(cr);
384 }

References fl_compositor_opengl_new(), fl_compositor_present_layers(), fl_compositor_render(), fl_dart_project_new(), fl_engine_new(), fl_engine_set_implicit_view(), fl_framebuffer_new(), fl_opengl_manager_new(), fl_task_runner_new(), g_autoptr(), height, layers, opengl_manager, and width.

◆ TEST() [4/7]

TEST ( FlCompositorOpenGLTest  ,
NoBlitFramebuffer   
)

Definition at line 289 of file fl_compositor_opengl_test.cc.

289  {
290  ::testing::NiceMock<flutter::testing::MockEpoxy> epoxy;
291  g_autoptr(FlDartProject) project = fl_dart_project_new();
292  g_autoptr(FlEngine) engine = fl_engine_new(project);
293  g_autoptr(FlTaskRunner) task_runner = fl_task_runner_new(engine);
294  g_autoptr(FlOpenGLManager) opengl_manager = fl_opengl_manager_new();
295 
296  constexpr size_t width = 100;
297  constexpr size_t height = 100;
298 
299  // OpenGL 2.0
300  ON_CALL(epoxy, glGetString(GL_VENDOR))
301  .WillByDefault(
302  ::testing::Return(reinterpret_cast<const GLubyte*>("Intel")));
303  ON_CALL(epoxy, epoxy_is_desktop_gl).WillByDefault(::testing::Return(true));
304  EXPECT_CALL(epoxy, epoxy_gl_version).WillRepeatedly(::testing::Return(20));
305 
306  g_autoptr(FlMockRenderable) renderable = fl_mock_renderable_new();
307  g_autoptr(FlCompositorOpenGL) compositor =
308  fl_compositor_opengl_new(task_runner, opengl_manager, FALSE);
309  fl_engine_set_implicit_view(engine, FL_RENDERABLE(renderable));
310 
311  g_autoptr(FlFramebuffer) framebuffer =
312  fl_framebuffer_new(GL_RGB, width, height, FALSE);
313  FlutterBackingStore backing_store = {
314  .type = kFlutterBackingStoreTypeOpenGL,
315  .open_gl = {.framebuffer = {.user_data = framebuffer}}};
316  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
317  .backing_store = &backing_store,
318  .offset = {0, 0},
319  .size = {width, height}};
320  const FlutterLayer* layers[1] = {&layer};
321 
322  // Present layer and render.
323  std::thread([&]() {
324  fl_compositor_present_layers(FL_COMPOSITOR(compositor), layers, 1);
325  }).join();
326  int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
327  g_autofree unsigned char* image_data =
328  static_cast<unsigned char*>(malloc(height * stride));
329  cairo_surface_t* surface = cairo_image_surface_create_for_data(
330  image_data, CAIRO_FORMAT_ARGB32, width, height, stride);
331  cairo_t* cr = cairo_create(surface);
332  fl_compositor_render(FL_COMPOSITOR(compositor), cr, nullptr);
333  cairo_surface_destroy(surface);
334  cairo_destroy(cr);
335 }

References fl_compositor_opengl_new(), fl_compositor_present_layers(), fl_compositor_render(), fl_dart_project_new(), fl_engine_new(), fl_engine_set_implicit_view(), fl_framebuffer_new(), fl_opengl_manager_new(), fl_task_runner_new(), g_autoptr(), height, layers, opengl_manager, and width.

◆ TEST() [5/7]

TEST ( FlCompositorOpenGLTest  ,
Render   
)

Definition at line 21 of file fl_compositor_opengl_test.cc.

21  {
22  ::testing::NiceMock<flutter::testing::MockEpoxy> epoxy;
23  g_autoptr(FlDartProject) project = fl_dart_project_new();
24  g_autoptr(FlEngine) engine = fl_engine_new(project);
25  g_autoptr(FlTaskRunner) task_runner = fl_task_runner_new(engine);
26  g_autoptr(FlOpenGLManager) opengl_manager = fl_opengl_manager_new();
27 
28  g_autoptr(FlMockRenderable) renderable = fl_mock_renderable_new();
29  g_autoptr(FlCompositorOpenGL) compositor =
30  fl_compositor_opengl_new(task_runner, opengl_manager, FALSE);
31  fl_engine_set_implicit_view(engine, FL_RENDERABLE(renderable));
32 
33  // Present layer from a thread.
34  constexpr size_t width = 100;
35  constexpr size_t height = 100;
36  g_autoptr(FlFramebuffer) framebuffer =
37  fl_framebuffer_new(GL_RGB, width, height, FALSE);
38  FlutterBackingStore backing_store = {
39  .type = kFlutterBackingStoreTypeOpenGL,
40  .open_gl = {.framebuffer = {.user_data = framebuffer}}};
41  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
42  .backing_store = &backing_store,
43  .offset = {0, 0},
44  .size = {width, height}};
45  const FlutterLayer* layers[1] = {&layer};
46  std::thread([&]() {
47  fl_compositor_present_layers(FL_COMPOSITOR(compositor), layers, 1);
48  }).join();
49 
50  // Render presented layer.
51  int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
52  g_autofree unsigned char* image_data =
53  static_cast<unsigned char*>(malloc(height * stride));
54  cairo_surface_t* surface = cairo_image_surface_create_for_data(
55  image_data, CAIRO_FORMAT_ARGB32, width, height, stride);
56  cairo_t* cr = cairo_create(surface);
57  fl_compositor_render(FL_COMPOSITOR(compositor), cr, nullptr);
58  cairo_surface_destroy(surface);
59  cairo_destroy(cr);
60 }

References fl_compositor_opengl_new(), fl_compositor_present_layers(), fl_compositor_render(), fl_dart_project_new(), fl_engine_new(), fl_engine_set_implicit_view(), fl_framebuffer_new(), fl_opengl_manager_new(), fl_task_runner_new(), g_autoptr(), height, layers, opengl_manager, and width.

◆ TEST() [6/7]

TEST ( FlCompositorOpenGLTest  ,
Resize   
)

Definition at line 62 of file fl_compositor_opengl_test.cc.

62  {
63  ::testing::NiceMock<flutter::testing::MockEpoxy> epoxy;
64  g_autoptr(FlDartProject) project = fl_dart_project_new();
65  g_autoptr(FlEngine) engine = fl_engine_new(project);
66  g_autoptr(FlTaskRunner) task_runner = fl_task_runner_new(engine);
67  g_autoptr(FlOpenGLManager) opengl_manager = fl_opengl_manager_new();
68 
69  g_autoptr(FlMockRenderable) renderable = fl_mock_renderable_new();
70  g_autoptr(FlCompositorOpenGL) compositor =
71  fl_compositor_opengl_new(task_runner, opengl_manager, FALSE);
72  fl_engine_set_implicit_view(engine, FL_RENDERABLE(renderable));
73 
74  // Present a layer that is the old size.
75  constexpr size_t width1 = 90;
76  constexpr size_t height1 = 90;
77  g_autoptr(FlFramebuffer) framebuffer1 =
78  fl_framebuffer_new(GL_RGB, width1, height1, FALSE);
79  FlutterBackingStore backing_store1 = {
80  .type = kFlutterBackingStoreTypeOpenGL,
81  .open_gl = {.framebuffer = {.user_data = framebuffer1}}};
82  FlutterLayer layer1 = {.type = kFlutterLayerContentTypeBackingStore,
83  .backing_store = &backing_store1,
84  .offset = {0, 0},
85  .size = {width1, height1}};
86  const FlutterLayer* layers1[1] = {&layer1};
87  std::thread([&]() {
88  fl_compositor_present_layers(FL_COMPOSITOR(compositor), layers1, 1);
89  }).join();
90 
91  // Present layer in current size.
92  constexpr size_t width2 = 100;
93  constexpr size_t height2 = 100;
94  g_autoptr(FlFramebuffer) framebuffer2 =
95  fl_framebuffer_new(GL_RGB, width2, height2, FALSE);
96  FlutterBackingStore backing_store2 = {
97  .type = kFlutterBackingStoreTypeOpenGL,
98  .open_gl = {.framebuffer = {.user_data = framebuffer2}}};
99  FlutterLayer layer2 = {.type = kFlutterLayerContentTypeBackingStore,
100  .backing_store = &backing_store2,
101  .offset = {0, 0},
102  .size = {width2, height2}};
103  const FlutterLayer* layers2[1] = {&layer2};
104  fml::AutoResetWaitableEvent latch;
105  std::thread([&]() {
106  fl_compositor_present_layers(FL_COMPOSITOR(compositor), layers2, 1);
107  latch.Signal();
108  }).detach();
109 
110  // Render, will wait for the second layer if necessary.
111  int stride2 = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width2);
112  g_autofree unsigned char* image_data =
113  static_cast<unsigned char*>(malloc(height2 * stride2));
114  cairo_surface_t* surface = cairo_image_surface_create_for_data(
115  image_data, CAIRO_FORMAT_ARGB32, width2, height2, stride2);
116  cairo_t* cr = cairo_create(surface);
117  fl_compositor_render(FL_COMPOSITOR(compositor), cr, nullptr);
118  cairo_surface_destroy(surface);
119  cairo_destroy(cr);
120 
121  latch.Wait();
122 }

References fl_compositor_opengl_new(), fl_compositor_present_layers(), fl_compositor_render(), fl_dart_project_new(), fl_engine_new(), fl_engine_set_implicit_view(), fl_framebuffer_new(), fl_opengl_manager_new(), fl_task_runner_new(), g_autoptr(), and opengl_manager.

◆ TEST() [7/7]

TEST ( FlCompositorOpenGLTest  ,
RestoresGLState   
)

Definition at line 124 of file fl_compositor_opengl_test.cc.

124  {
125  ::testing::NiceMock<flutter::testing::MockEpoxy> epoxy;
126  g_autoptr(FlDartProject) project = fl_dart_project_new();
127  g_autoptr(FlEngine) engine = fl_engine_new(project);
128  g_autoptr(FlTaskRunner) task_runner = fl_task_runner_new(engine);
129  g_autoptr(FlOpenGLManager) opengl_manager = fl_opengl_manager_new();
130 
131  constexpr size_t width = 100;
132  constexpr size_t height = 100;
133 
134  // OpenGL 3.0
135  ON_CALL(epoxy, glGetString(GL_VENDOR))
136  .WillByDefault(
137  ::testing::Return(reinterpret_cast<const GLubyte*>("Intel")));
138  ON_CALL(epoxy, epoxy_is_desktop_gl).WillByDefault(::testing::Return(true));
139  ON_CALL(epoxy, epoxy_gl_version).WillByDefault(::testing::Return(30));
140 
141  g_autoptr(FlMockRenderable) renderable = fl_mock_renderable_new();
142  g_autoptr(FlCompositorOpenGL) compositor =
143  fl_compositor_opengl_new(task_runner, opengl_manager, FALSE);
144  fl_engine_set_implicit_view(engine, FL_RENDERABLE(renderable));
145 
146  g_autoptr(FlFramebuffer) framebuffer =
147  fl_framebuffer_new(GL_RGB, width, height, FALSE);
148  FlutterBackingStore backing_store = {
149  .type = kFlutterBackingStoreTypeOpenGL,
150  .open_gl = {.framebuffer = {.user_data = framebuffer}}};
151  FlutterLayer layer = {.type = kFlutterLayerContentTypeBackingStore,
152  .backing_store = &backing_store,
153  .offset = {0, 0},
154  .size = {width, height}};
155  const FlutterLayer* layers[1] = {&layer};
156 
157  constexpr GLuint kFakeTextureName = 123;
158  glBindTexture(GL_TEXTURE_2D, kFakeTextureName);
159  glDisable(GL_BLEND);
160  glEnable(GL_SCISSOR_TEST);
161 
162  // Present layer and render.
163  std::thread([&]() {
164  fl_compositor_present_layers(FL_COMPOSITOR(compositor), layers, 1);
165  }).join();
166  int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
167  g_autofree unsigned char* image_data =
168  static_cast<unsigned char*>(malloc(height * stride));
169  cairo_surface_t* surface = cairo_image_surface_create_for_data(
170  image_data, CAIRO_FORMAT_ARGB32, width, height, stride);
171  cairo_t* cr = cairo_create(surface);
172  fl_compositor_render(FL_COMPOSITOR(compositor), cr, nullptr);
173  cairo_surface_destroy(surface);
174  cairo_destroy(cr);
175 
176  GLuint texture_2d_binding;
177  glGetIntegerv(GL_TEXTURE_BINDING_2D,
178  reinterpret_cast<GLint*>(&texture_2d_binding));
179  EXPECT_EQ(texture_2d_binding, kFakeTextureName);
180  EXPECT_EQ(glIsEnabled(GL_BLEND), GL_FALSE);
181  EXPECT_EQ(glIsEnabled(GL_SCISSOR_TEST), GL_TRUE);
182 }

References fl_compositor_opengl_new(), fl_compositor_present_layers(), fl_compositor_render(), fl_dart_project_new(), fl_engine_new(), fl_engine_set_implicit_view(), fl_framebuffer_new(), fl_opengl_manager_new(), fl_task_runner_new(), g_autoptr(), height, layers, opengl_manager, and width.