Flutter Engine Uber Docs
Docs for the entire Flutter Engine repo.
 
Loading...
Searching...
No Matches
rasterizer_unittests.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#define FML_USED_ON_EMBEDDER
6
7#include "flow/surface_frame.h"
8#include "flutter/shell/common/rasterizer.h"
9
10#include <memory>
11#include <optional>
12
13#include "flutter/flow/frame_timings.h"
14#include "flutter/fml/synchronization/count_down_latch.h"
15#include "flutter/fml/time/time_point.h"
16#include "flutter/shell/common/thread_host.h"
17#include "flutter/testing/testing.h"
18
19#include "third_party/skia/include/core/SkColorSpace.h"
20#include "third_party/skia/include/core/SkSurface.h"
21#include "third_party/skia/include/gpu/ganesh/GrTypes.h"
22#include "third_party/skia/include/gpu/ganesh/SkSurfaceGanesh.h"
23
24#include "gmock/gmock.h"
25
26using testing::_;
27using testing::ByMove;
28using testing::NiceMock;
29using testing::Return;
30using testing::ReturnRef;
31
32namespace flutter {
33namespace {
34
35constexpr float kDevicePixelRatio = 2.0f;
36constexpr int64_t kImplicitViewId = 0;
37
38std::vector<std::unique_ptr<LayerTreeTask>> SingleLayerTreeList(
39 int64_t view_id,
40 std::unique_ptr<LayerTree> layer_tree,
41 float pixel_ratio) {
42 std::vector<std::unique_ptr<LayerTreeTask>> tasks;
43 tasks.push_back(std::make_unique<LayerTreeTask>(
44 view_id, std::move(layer_tree), pixel_ratio));
45 return tasks;
46}
47
48class MockDelegate : public Rasterizer::Delegate {
49 public:
50 MOCK_METHOD(void,
51 OnFrameRasterized,
52 (const FrameTiming& frame_timing),
53 (override));
54 MOCK_METHOD(fml::Milliseconds, GetFrameBudget, (), (override));
55 MOCK_METHOD(fml::TimePoint, GetLatestFrameTargetTime, (), (const, override));
56 MOCK_METHOD(const TaskRunners&, GetTaskRunners, (), (const, override));
57 MOCK_METHOD(const fml::RefPtr<fml::RasterThreadMerger>,
58 GetParentRasterThreadMerger,
59 (),
60 (const, override));
61 MOCK_METHOD(std::shared_ptr<const fml::SyncSwitch>,
62 GetIsGpuDisabledSyncSwitch,
63 (),
64 (const, override));
65 MOCK_METHOD(const Settings&, GetSettings, (), (const, override));
66 MOCK_METHOD(bool,
67 ShouldDiscardLayerTree,
68 (int64_t, const flutter::LayerTree&),
69 (override));
70};
71
72class MockSurface : public Surface {
73 public:
74 MOCK_METHOD(bool, IsValid, (), (override));
75 MOCK_METHOD(std::unique_ptr<SurfaceFrame>,
76 AcquireFrame,
77 (const DlISize& size),
78 (override));
79 MOCK_METHOD(DlMatrix, GetRootTransformation, (), (const, override));
80 MOCK_METHOD(GrDirectContext*, GetContext, (), (override));
81 MOCK_METHOD(std::unique_ptr<GLContextResult>,
82 MakeRenderContextCurrent,
83 (),
84 (override));
85 MOCK_METHOD(bool, ClearRenderContext, (), (override));
86 MOCK_METHOD(bool, AllowsDrawingWhenGpuDisabled, (), (const, override));
87};
88
89class MockExternalViewEmbedder : public ExternalViewEmbedder {
90 public:
91 MOCK_METHOD(DlCanvas*, GetRootCanvas, (), (override));
92 MOCK_METHOD(void, CancelFrame, (), (override));
93 MOCK_METHOD(
94 void,
95 BeginFrame,
96 (GrDirectContext * context,
97 const fml::RefPtr<fml::RasterThreadMerger>& raster_thread_merger),
98 (override));
99 MOCK_METHOD(void,
100 PrepareFlutterView,
101 (DlISize frame_size, double device_pixel_ratio),
102 (override));
103 MOCK_METHOD(void,
104 PrerollCompositeEmbeddedView,
105 (int64_t view_id, std::unique_ptr<EmbeddedViewParams> params),
106 (override));
107 MOCK_METHOD(
108 PostPrerollResult,
109 PostPrerollAction,
110 (const fml::RefPtr<fml::RasterThreadMerger>& raster_thread_merger),
111 (override));
112 MOCK_METHOD(DlCanvas*, CompositeEmbeddedView, (int64_t view_id), (override));
113 MOCK_METHOD(void,
114 SubmitFlutterView,
115 (int64_t flutter_view_id,
116 GrDirectContext* context,
117 const std::shared_ptr<impeller::AiksContext>& aiks_context,
118 std::unique_ptr<SurfaceFrame> frame),
119 (override));
120 MOCK_METHOD(
121 void,
122 EndFrame,
123 (bool should_resubmit_frame,
124 const fml::RefPtr<fml::RasterThreadMerger>& raster_thread_merger),
125 (override));
126 MOCK_METHOD(bool, SupportsDynamicThreadMerging, (), (override));
127};
128} // namespace
129
130TEST(RasterizerTest, create) {
131 NiceMock<MockDelegate> delegate;
132 Settings settings;
133 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
134 auto rasterizer = std::make_unique<Rasterizer>(delegate);
135 EXPECT_TRUE(rasterizer != nullptr);
136}
137
138TEST(RasterizerTest, isAiksContextInitialized) {
139 NiceMock<MockDelegate> delegate;
140 Settings settings;
141 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
142 auto rasterizer = std::make_shared<Rasterizer>(delegate);
143
144 EXPECT_TRUE(rasterizer != nullptr);
145 std::shared_ptr<SnapshotController::Delegate> snapshot_delegate = rasterizer;
146
147 EXPECT_FALSE(snapshot_delegate->IsAiksContextInitialized());
148}
149
150static std::unique_ptr<FrameTimingsRecorder> CreateFinishedBuildRecorder(
151 fml::TimePoint timestamp) {
152 std::unique_ptr<FrameTimingsRecorder> recorder =
153 std::make_unique<FrameTimingsRecorder>();
154 recorder->RecordVsync(timestamp, timestamp);
155 recorder->RecordBuildStart(timestamp);
156 recorder->RecordBuildEnd(timestamp);
157 return recorder;
158}
159
160static std::unique_ptr<FrameTimingsRecorder> CreateFinishedBuildRecorder() {
161 return CreateFinishedBuildRecorder(fml::TimePoint::Now());
162}
163
164TEST(RasterizerTest, drawEmptyPipeline) {
165 std::string test_name =
166 ::testing::UnitTest::GetInstance()->current_test_info()->name();
167 ThreadHost thread_host("io.flutter.test." + test_name + ".",
168 ThreadHost::Type::kPlatform |
169 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
170 ThreadHost::Type::kUi);
171 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
172 thread_host.raster_thread->GetTaskRunner(),
173 thread_host.ui_thread->GetTaskRunner(),
174 thread_host.io_thread->GetTaskRunner());
175 NiceMock<MockDelegate> delegate;
176 Settings settings;
177 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
178 ON_CALL(delegate, GetTaskRunners()).WillByDefault(ReturnRef(task_runners));
179 auto rasterizer = std::make_unique<Rasterizer>(delegate);
180 auto surface = std::make_unique<NiceMock<MockSurface>>();
181 EXPECT_CALL(*surface, MakeRenderContextCurrent())
182 .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
183 rasterizer->Setup(std::move(surface));
184 fml::AutoResetWaitableEvent latch;
185 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
186 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
187 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
188 rasterizer->Draw(pipeline);
189 latch.Signal();
190 });
191 latch.Wait();
192}
193
194TEST(RasterizerTest,
195 drawWithExternalViewEmbedderExternalViewEmbedderSubmitFrameCalled) {
196 std::string test_name =
197 ::testing::UnitTest::GetInstance()->current_test_info()->name();
198 ThreadHost thread_host("io.flutter.test." + test_name + ".",
199 ThreadHost::Type::kPlatform |
200 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
201 ThreadHost::Type::kUi);
202 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
203 thread_host.raster_thread->GetTaskRunner(),
204 thread_host.ui_thread->GetTaskRunner(),
205 thread_host.io_thread->GetTaskRunner());
206 NiceMock<MockDelegate> delegate;
207 Settings settings;
208 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
209 EXPECT_CALL(delegate, GetTaskRunners())
210 .WillRepeatedly(ReturnRef(task_runners));
211 EXPECT_CALL(delegate, OnFrameRasterized(_));
212 auto rasterizer = std::make_unique<Rasterizer>(delegate);
213 auto surface = std::make_unique<NiceMock<MockSurface>>();
214
215 std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
216 std::make_shared<NiceMock<MockExternalViewEmbedder>>();
217 rasterizer->SetExternalViewEmbedder(external_view_embedder);
218
219 SurfaceFrame::FramebufferInfo framebuffer_info;
220 framebuffer_info.supports_readback = true;
221
222 auto surface_frame = std::make_unique<SurfaceFrame>(
223 /*surface=*/
224 nullptr, framebuffer_info,
225 /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
226 /*submit_callback=*/[](const SurfaceFrame&) { return true; },
227 /*frame_size=*/DlISize(800, 600));
228 EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(true));
229 EXPECT_CALL(*surface, AcquireFrame(DlISize()))
230 .WillOnce(Return(ByMove(std::move(surface_frame))));
231 EXPECT_CALL(*surface, MakeRenderContextCurrent())
232 .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
233
234 EXPECT_CALL(*external_view_embedder,
235 BeginFrame(/*context=*/nullptr,
236 /*raster_thread_merger=*/
237 fml::RefPtr<fml::RasterThreadMerger>(nullptr)))
238 .Times(1);
239 EXPECT_CALL(*external_view_embedder, PrepareFlutterView(
240 /*frame_size=*/DlISize(),
241 /*device_pixel_ratio=*/2.0))
242 .Times(1);
243 EXPECT_CALL(*external_view_embedder,
244 SubmitFlutterView(/*flutter_view_id=*/kImplicitViewId, _, _, _))
245 .Times(1);
246 EXPECT_CALL(
247 *external_view_embedder,
248 EndFrame(/*should_resubmit_frame=*/false,
249 /*raster_thread_merger=*/fml::RefPtr<fml::RasterThreadMerger>(
250 nullptr)))
251 .Times(1);
252
253 rasterizer->Setup(std::move(surface));
254 fml::AutoResetWaitableEvent latch;
255 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
256 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
257 auto layer_tree = std::make_unique<LayerTree>(/*root_layer=*/nullptr,
258 /*frame_size=*/DlISize());
259 auto layer_tree_item = std::make_unique<FrameItem>(
260 SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
261 kDevicePixelRatio),
262 CreateFinishedBuildRecorder());
263 PipelineProduceResult result =
264 pipeline->Produce().Complete(std::move(layer_tree_item));
265 EXPECT_TRUE(result.success);
266 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
267 rasterizer->Draw(pipeline);
268 latch.Signal();
269 });
270 latch.Wait();
271}
272
273TEST(
274 RasterizerTest,
275 drawWithExternalViewEmbedderAndThreadMergerNotMergedExternalViewEmbedderSubmitFrameNotCalled) {
276 std::string test_name =
277 ::testing::UnitTest::GetInstance()->current_test_info()->name();
278 ThreadHost thread_host("io.flutter.test." + test_name + ".",
279 ThreadHost::Type::kPlatform |
280 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
281 ThreadHost::Type::kUi);
282 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
283 thread_host.raster_thread->GetTaskRunner(),
284 thread_host.ui_thread->GetTaskRunner(),
285 thread_host.io_thread->GetTaskRunner());
286 NiceMock<MockDelegate> delegate;
287 Settings settings;
288 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
289 EXPECT_CALL(delegate, GetTaskRunners())
290 .WillRepeatedly(ReturnRef(task_runners));
291 EXPECT_CALL(delegate, OnFrameRasterized(_));
292 auto rasterizer = std::make_unique<Rasterizer>(delegate);
293 auto surface = std::make_unique<NiceMock<MockSurface>>();
294 std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
295 std::make_shared<NiceMock<MockExternalViewEmbedder>>();
296 rasterizer->SetExternalViewEmbedder(external_view_embedder);
297 EXPECT_CALL(*external_view_embedder, SupportsDynamicThreadMerging)
298 .WillRepeatedly(Return(true));
299 SurfaceFrame::FramebufferInfo framebuffer_info;
300 framebuffer_info.supports_readback = true;
301 auto surface_frame = std::make_unique<SurfaceFrame>(
302 /*surface=*/
303 nullptr, framebuffer_info,
304 /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
305 /*submit_callback=*/[](const SurfaceFrame&) { return true; },
306 /*frame_size=*/DlISize(800, 600));
307 EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(true));
308 EXPECT_CALL(*surface, AcquireFrame(DlISize()))
309 .WillOnce(Return(ByMove(std::move(surface_frame))));
310 EXPECT_CALL(*surface, MakeRenderContextCurrent())
311 .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
312
313 EXPECT_CALL(*external_view_embedder, BeginFrame(/*context=*/nullptr,
314 /*raster_thread_merger=*/_))
315 .Times(1);
316 EXPECT_CALL(*external_view_embedder, PrepareFlutterView(
317 /*frame_size=*/DlISize(),
318 /*device_pixel_ratio=*/2.0))
319 .Times(1);
320 EXPECT_CALL(*external_view_embedder,
321 SubmitFlutterView(/*flutter_view_id=*/kImplicitViewId, _, _, _))
322 .Times(0);
323 EXPECT_CALL(*external_view_embedder, EndFrame(/*should_resubmit_frame=*/false,
324 /*raster_thread_merger=*/_))
325 .Times(1);
326
327 rasterizer->Setup(std::move(surface));
328 fml::AutoResetWaitableEvent latch;
329 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
330 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
331 auto layer_tree = std::make_unique<LayerTree>(
332 /*root_layer=*/nullptr, /*frame_size=*/DlISize());
333 auto layer_tree_item = std::make_unique<FrameItem>(
334 SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
335 kDevicePixelRatio),
336 CreateFinishedBuildRecorder());
337 PipelineProduceResult result =
338 pipeline->Produce().Complete(std::move(layer_tree_item));
339 EXPECT_TRUE(result.success);
340 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
341 rasterizer->Draw(pipeline);
342 latch.Signal();
343 });
344 latch.Wait();
345}
346
347TEST(
348 RasterizerTest,
349 drawWithExternalViewEmbedderAndThreadsMergedExternalViewEmbedderSubmitFrameCalled) {
350 std::string test_name =
351 ::testing::UnitTest::GetInstance()->current_test_info()->name();
352 ThreadHost thread_host("io.flutter.test." + test_name + ".",
353 ThreadHost::Type::kPlatform |
354 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
355 ThreadHost::Type::kUi);
356 fml::MessageLoop::EnsureInitializedForCurrentThread();
357 TaskRunners task_runners("test",
358 fml::MessageLoop::GetCurrent().GetTaskRunner(),
359 fml::MessageLoop::GetCurrent().GetTaskRunner(),
360 thread_host.ui_thread->GetTaskRunner(),
361 thread_host.io_thread->GetTaskRunner());
362
363 NiceMock<MockDelegate> delegate;
364 Settings settings;
365 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
366 EXPECT_CALL(delegate, GetTaskRunners())
367 .WillRepeatedly(ReturnRef(task_runners));
368 EXPECT_CALL(delegate, OnFrameRasterized(_));
369
370 auto rasterizer = std::make_unique<Rasterizer>(delegate);
371 auto surface = std::make_unique<NiceMock<MockSurface>>();
372
373 std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
374 std::make_shared<NiceMock<MockExternalViewEmbedder>>();
375 rasterizer->SetExternalViewEmbedder(external_view_embedder);
376
377 SurfaceFrame::FramebufferInfo framebuffer_info;
378 framebuffer_info.supports_readback = true;
379
380 auto surface_frame = std::make_unique<SurfaceFrame>(
381 /*surface=*/
382 nullptr, framebuffer_info,
383 /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
384 /*submit_callback=*/[](const SurfaceFrame&) { return true; },
385 /*frame_size=*/DlISize(800, 600));
386 EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(true));
387 EXPECT_CALL(*surface, AcquireFrame(DlISize()))
388 .WillOnce(Return(ByMove(std::move(surface_frame))));
389 EXPECT_CALL(*surface, MakeRenderContextCurrent())
390 .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
391 EXPECT_CALL(*external_view_embedder, SupportsDynamicThreadMerging)
392 .WillRepeatedly(Return(true));
393
394 EXPECT_CALL(*external_view_embedder, BeginFrame(/*context=*/nullptr,
395 /*raster_thread_merger=*/_))
396 .Times(1);
397 EXPECT_CALL(*external_view_embedder, PrepareFlutterView(
398 /*frame_size=*/DlISize(),
399 /*device_pixel_ratio=*/2.0))
400 .Times(1);
401 EXPECT_CALL(*external_view_embedder,
402 SubmitFlutterView(/*flutter_view_id=*/kImplicitViewId, _, _, _))
403 .Times(1);
404 EXPECT_CALL(*external_view_embedder, EndFrame(/*should_resubmit_frame=*/false,
405 /*raster_thread_merger=*/_))
406 .Times(1);
407
408 rasterizer->Setup(std::move(surface));
409
410 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
411 auto layer_tree = std::make_unique<LayerTree>(/*root_layer=*/nullptr,
412 /*frame_size=*/DlISize());
413 auto layer_tree_item = std::make_unique<FrameItem>(
414 SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
415 kDevicePixelRatio),
416 CreateFinishedBuildRecorder());
417 PipelineProduceResult result =
418 pipeline->Produce().Complete(std::move(layer_tree_item));
419 EXPECT_TRUE(result.success);
420 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
421 rasterizer->Draw(pipeline);
422}
423
424TEST(RasterizerTest,
425 drawLastLayerTreeWithThreadsMergedExternalViewEmbedderAndEndFrameCalled) {
426 std::string test_name =
427 ::testing::UnitTest::GetInstance()->current_test_info()->name();
428 ThreadHost thread_host("io.flutter.test." + test_name + ".",
429 ThreadHost::Type::kPlatform |
430 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
431 ThreadHost::Type::kUi);
432 fml::MessageLoop::EnsureInitializedForCurrentThread();
433 TaskRunners task_runners("test",
434 fml::MessageLoop::GetCurrent().GetTaskRunner(),
435 fml::MessageLoop::GetCurrent().GetTaskRunner(),
436 thread_host.ui_thread->GetTaskRunner(),
437 thread_host.io_thread->GetTaskRunner());
438
439 NiceMock<MockDelegate> delegate;
440 Settings settings;
441 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
442 EXPECT_CALL(delegate, GetTaskRunners())
443 .WillRepeatedly(ReturnRef(task_runners));
444 EXPECT_CALL(delegate, OnFrameRasterized(_));
445
446 auto rasterizer = std::make_unique<Rasterizer>(delegate);
447 auto surface = std::make_unique<NiceMock<MockSurface>>();
448
449 std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
450 std::make_shared<NiceMock<MockExternalViewEmbedder>>();
451 rasterizer->SetExternalViewEmbedder(external_view_embedder);
452
453 SurfaceFrame::FramebufferInfo framebuffer_info;
454 framebuffer_info.supports_readback = true;
455
456 auto surface_frame1 = std::make_unique<SurfaceFrame>(
457 /*surface=*/
458 nullptr, framebuffer_info,
459 /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
460 /*submit_callback=*/[](const SurfaceFrame&) { return true; },
461 /*frame_size=*/DlISize(800, 600));
462 auto surface_frame2 = std::make_unique<SurfaceFrame>(
463 /*surface=*/
464 nullptr, framebuffer_info,
465 /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
466 /*submit_callback=*/[](const SurfaceFrame&) { return true; },
467 /*frame_size=*/DlISize(800, 600));
468 EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled())
469 .WillRepeatedly(Return(true));
470 // Prepare two frames for Draw() and DrawLastLayerTrees().
471 EXPECT_CALL(*surface, AcquireFrame(DlISize()))
472 .WillOnce(Return(ByMove(std::move(surface_frame1))))
473 .WillOnce(Return(ByMove(std::move(surface_frame2))));
474 EXPECT_CALL(*surface, MakeRenderContextCurrent())
475 .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
476 EXPECT_CALL(*external_view_embedder, SupportsDynamicThreadMerging)
477 .WillRepeatedly(Return(true));
478
479 EXPECT_CALL(*external_view_embedder, BeginFrame(/*context=*/nullptr,
480 /*raster_thread_merger=*/_))
481 .Times(2);
482 EXPECT_CALL(*external_view_embedder, PrepareFlutterView(
483 /*frame_size=*/DlISize(),
484 /*device_pixel_ratio=*/2.0))
485 .Times(2);
486 EXPECT_CALL(*external_view_embedder,
487 SubmitFlutterView(/*flutter_view_id=*/kImplicitViewId, _, _, _))
488 .Times(2);
489 EXPECT_CALL(*external_view_embedder, EndFrame(/*should_resubmit_frame=*/false,
490 /*raster_thread_merger=*/_))
491 .Times(2);
492
493 rasterizer->Setup(std::move(surface));
494
495 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
496 auto layer_tree = std::make_unique<LayerTree>(/*root_layer=*/nullptr,
497 /*frame_size=*/DlISize());
498 auto layer_tree_item = std::make_unique<FrameItem>(
499 SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
500 kDevicePixelRatio),
501 CreateFinishedBuildRecorder());
502 PipelineProduceResult result =
503 pipeline->Produce().Complete(std::move(layer_tree_item));
504 EXPECT_TRUE(result.success);
505
506 // The Draw() will respectively call BeginFrame(), SubmitFlutterView() and
507 // EndFrame() one time.
508 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
509 rasterizer->Draw(pipeline);
510
511 // The DrawLastLayerTrees() will respectively call BeginFrame(),
512 // SubmitFlutterView() and EndFrame() one more time, totally 2 times.
513 rasterizer->DrawLastLayerTrees(CreateFinishedBuildRecorder());
514}
515
516TEST(RasterizerTest, externalViewEmbedderDoesntEndFrameWhenNoSurfaceIsSet) {
517 std::string test_name =
518 ::testing::UnitTest::GetInstance()->current_test_info()->name();
519 ThreadHost thread_host("io.flutter.test." + test_name + ".",
520 ThreadHost::Type::kPlatform |
521 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
522 ThreadHost::Type::kUi);
523 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
524 thread_host.raster_thread->GetTaskRunner(),
525 thread_host.ui_thread->GetTaskRunner(),
526 thread_host.io_thread->GetTaskRunner());
527 NiceMock<MockDelegate> delegate;
528 Settings settings;
529 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
530 EXPECT_CALL(delegate, GetTaskRunners())
531 .WillRepeatedly(ReturnRef(task_runners));
532 auto rasterizer = std::make_unique<Rasterizer>(delegate);
533
534 std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
535 std::make_shared<NiceMock<MockExternalViewEmbedder>>();
536 rasterizer->SetExternalViewEmbedder(external_view_embedder);
537
538 EXPECT_CALL(
539 *external_view_embedder,
540 EndFrame(/*should_resubmit_frame=*/false,
541 /*raster_thread_merger=*/fml::RefPtr<fml::RasterThreadMerger>(
542 nullptr)))
543 .Times(0);
544
545 fml::AutoResetWaitableEvent latch;
546 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
547 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
548 auto layer_tree = std::make_unique<LayerTree>(
549 /*root_layer=*/nullptr, /*frame_size=*/DlISize());
550 auto layer_tree_item = std::make_unique<FrameItem>(
551 SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
552 kDevicePixelRatio),
553 CreateFinishedBuildRecorder());
554 PipelineProduceResult result =
555 pipeline->Produce().Complete(std::move(layer_tree_item));
556 EXPECT_TRUE(result.success);
557 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
558 rasterizer->Draw(pipeline);
559 latch.Signal();
560 });
561 latch.Wait();
562}
563
564TEST(RasterizerTest, externalViewEmbedderDoesntEndFrameWhenNotUsedThisFrame) {
565 std::string test_name =
566 ::testing::UnitTest::GetInstance()->current_test_info()->name();
567 ThreadHost thread_host("io.flutter.test." + test_name + ".",
568 ThreadHost::Type::kPlatform |
569 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
570 ThreadHost::Type::kUi);
571 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
572 thread_host.raster_thread->GetTaskRunner(),
573 thread_host.ui_thread->GetTaskRunner(),
574 thread_host.io_thread->GetTaskRunner());
575 NiceMock<MockDelegate> delegate;
576 Settings settings;
577 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
578 EXPECT_CALL(delegate, GetTaskRunners())
579 .WillRepeatedly(ReturnRef(task_runners));
580 auto is_gpu_disabled_sync_switch =
581 std::make_shared<const fml::SyncSwitch>(false);
582 ON_CALL(delegate, GetIsGpuDisabledSyncSwitch())
583 .WillByDefault(Return(is_gpu_disabled_sync_switch));
584
585 auto rasterizer = std::make_unique<Rasterizer>(delegate);
586 auto surface = std::make_unique<NiceMock<MockSurface>>();
587 EXPECT_CALL(*surface, MakeRenderContextCurrent())
588 .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
589
590 std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
591 std::make_shared<NiceMock<MockExternalViewEmbedder>>();
592 rasterizer->SetExternalViewEmbedder(external_view_embedder);
593 rasterizer->Setup(std::move(surface));
594
595 EXPECT_CALL(*external_view_embedder, BeginFrame(/*context=*/nullptr,
596 /*raster_thread_merger=*/_))
597 .Times(0);
598 EXPECT_CALL(*external_view_embedder, PrepareFlutterView(
599 /*frame_size=*/DlISize(),
600 /*device_pixel_ratio=*/2.0))
601 .Times(0);
602 EXPECT_CALL(
603 *external_view_embedder,
604 EndFrame(/*should_resubmit_frame=*/false,
605 /*raster_thread_merger=*/fml::RefPtr<fml::RasterThreadMerger>(
606 nullptr)))
607 .Times(0);
608
609 fml::AutoResetWaitableEvent latch;
610 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
611 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
612 auto layer_tree = std::make_unique<LayerTree>(
613 /*root_layer=*/nullptr, /*frame_size=*/DlISize());
614 auto layer_tree_item = std::make_unique<FrameItem>(
615 SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
616 kDevicePixelRatio),
617 CreateFinishedBuildRecorder());
618 PipelineProduceResult result =
619 pipeline->Produce().Complete(std::move(layer_tree_item));
620 EXPECT_TRUE(result.success);
621 // Always discard the layer tree.
622 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(true));
623 DrawStatus status = rasterizer->Draw(pipeline);
624 EXPECT_EQ(status, DrawStatus::kDone);
625 EXPECT_EQ(rasterizer->GetLastDrawStatus(kImplicitViewId),
626 DrawSurfaceStatus::kDiscarded);
627 latch.Signal();
628 });
629 latch.Wait();
630}
631
632TEST(RasterizerTest, externalViewEmbedderDoesntEndFrameWhenPipelineIsEmpty) {
633 std::string test_name =
634 ::testing::UnitTest::GetInstance()->current_test_info()->name();
635 ThreadHost thread_host("io.flutter.test." + test_name + ".",
636 ThreadHost::Type::kPlatform |
637 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
638 ThreadHost::Type::kUi);
639 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
640 thread_host.raster_thread->GetTaskRunner(),
641 thread_host.ui_thread->GetTaskRunner(),
642 thread_host.io_thread->GetTaskRunner());
643 NiceMock<MockDelegate> delegate;
644 Settings settings;
645 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
646 EXPECT_CALL(delegate, GetTaskRunners())
647 .WillRepeatedly(ReturnRef(task_runners));
648
649 auto rasterizer = std::make_unique<Rasterizer>(delegate);
650 auto surface = std::make_unique<NiceMock<MockSurface>>();
651 EXPECT_CALL(*surface, MakeRenderContextCurrent())
652 .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
653
654 std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
655 std::make_shared<NiceMock<MockExternalViewEmbedder>>();
656 rasterizer->SetExternalViewEmbedder(external_view_embedder);
657 rasterizer->Setup(std::move(surface));
658
659 EXPECT_CALL(
660 *external_view_embedder,
661 EndFrame(/*should_resubmit_frame=*/false,
662 /*raster_thread_merger=*/fml::RefPtr<fml::RasterThreadMerger>(
663 nullptr)))
664 .Times(0);
665
666 fml::AutoResetWaitableEvent latch;
667 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
668 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
669 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
670 DrawStatus status = rasterizer->Draw(pipeline);
671 EXPECT_EQ(status, DrawStatus::kPipelineEmpty);
672 latch.Signal();
673 });
674 latch.Wait();
675}
676
677TEST(RasterizerTest, drawMultipleViewsWithExternalViewEmbedder) {
678 std::string test_name =
679 ::testing::UnitTest::GetInstance()->current_test_info()->name();
680 ThreadHost thread_host("io.flutter.test." + test_name + ".",
681 ThreadHost::Type::kPlatform |
682 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
683 ThreadHost::Type::kUi);
684 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
685 thread_host.raster_thread->GetTaskRunner(),
686 thread_host.ui_thread->GetTaskRunner(),
687 thread_host.io_thread->GetTaskRunner());
688 NiceMock<MockDelegate> delegate;
689 Settings settings;
690 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
691 EXPECT_CALL(delegate, GetTaskRunners())
692 .WillRepeatedly(ReturnRef(task_runners));
693 EXPECT_CALL(delegate, OnFrameRasterized(_));
694 auto rasterizer = std::make_unique<Rasterizer>(delegate);
695 auto surface = std::make_unique<NiceMock<MockSurface>>();
696 std::shared_ptr<NiceMock<MockExternalViewEmbedder>> external_view_embedder =
697 std::make_shared<NiceMock<MockExternalViewEmbedder>>();
698 rasterizer->SetExternalViewEmbedder(external_view_embedder);
699 EXPECT_CALL(*external_view_embedder, SupportsDynamicThreadMerging)
700 .WillRepeatedly(Return(false));
701 EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(true));
702 EXPECT_CALL(*surface, AcquireFrame(DlISize())).Times(2);
703 ON_CALL(*surface, AcquireFrame).WillByDefault([](const DlISize& size) {
704 SurfaceFrame::FramebufferInfo framebuffer_info;
705 framebuffer_info.supports_readback = true;
706 return std::make_unique<SurfaceFrame>(
707 /*surface=*/
708 nullptr, framebuffer_info,
709 /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
710 /*submit_callback=*/[](const SurfaceFrame&) { return true; },
711 /*frame_size=*/DlISize(800, 600));
712 });
713 EXPECT_CALL(*surface, MakeRenderContextCurrent())
714 .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
715
716 EXPECT_CALL(*external_view_embedder, BeginFrame(/*context=*/nullptr,
717 /*raster_thread_merger=*/_))
718 .Times(1);
719 EXPECT_CALL(*external_view_embedder,
720 PrepareFlutterView(/*frame_size=*/DlISize(),
721 /*device_pixel_ratio=*/1.5))
722 .Times(1);
723 EXPECT_CALL(*external_view_embedder,
724 SubmitFlutterView(/*flutter_view_id=*/0, _, _, _))
725 .Times(1);
726 EXPECT_CALL(*external_view_embedder,
727 PrepareFlutterView(/*frame_size=*/DlISize(),
728 /*device_pixel_ratio=*/2.0))
729 .Times(1);
730 EXPECT_CALL(*external_view_embedder,
731 SubmitFlutterView(/*flutter_view_id=*/1, _, _, _))
732 .Times(1);
733 EXPECT_CALL(*external_view_embedder, EndFrame(/*should_resubmit_frame=*/false,
734 /*raster_thread_merger=*/_))
735 .Times(1);
736
737 rasterizer->Setup(std::move(surface));
738 fml::AutoResetWaitableEvent latch;
739 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
740 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
741 std::vector<std::unique_ptr<LayerTreeTask>> tasks;
742 tasks.push_back(std::make_unique<LayerTreeTask>(
743 0, std::make_unique<LayerTree>(nullptr, DlISize()), 1.5));
744 tasks.push_back(std::make_unique<LayerTreeTask>(
745 1, std::make_unique<LayerTree>(nullptr, DlISize()), 2.0));
746 auto layer_tree_item = std::make_unique<FrameItem>(
747 std::move(tasks), CreateFinishedBuildRecorder());
748 PipelineProduceResult result =
749 pipeline->Produce().Complete(std::move(layer_tree_item));
750 EXPECT_TRUE(result.success);
751 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
752 rasterizer->Draw(pipeline);
753 latch.Signal();
754 });
755 latch.Wait();
756}
757
758TEST(RasterizerTest,
759 drawWithGpuEnabledAndSurfaceAllowsDrawingWhenGpuDisabledDoesAcquireFrame) {
760 std::string test_name =
761 ::testing::UnitTest::GetInstance()->current_test_info()->name();
762 ThreadHost thread_host("io.flutter.test." + test_name + ".",
763 ThreadHost::Type::kPlatform |
764 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
765 ThreadHost::Type::kUi);
766 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
767 thread_host.raster_thread->GetTaskRunner(),
768 thread_host.ui_thread->GetTaskRunner(),
769 thread_host.io_thread->GetTaskRunner());
770 NiceMock<MockDelegate> delegate;
771 Settings settings;
772 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
773 EXPECT_CALL(delegate, GetTaskRunners())
774 .WillRepeatedly(ReturnRef(task_runners));
775 EXPECT_CALL(delegate, OnFrameRasterized(_));
776
777 auto rasterizer = std::make_unique<Rasterizer>(delegate);
778 auto surface = std::make_unique<NiceMock<MockSurface>>();
779 auto is_gpu_disabled_sync_switch =
780 std::make_shared<const fml::SyncSwitch>(false);
781
782 SurfaceFrame::FramebufferInfo framebuffer_info;
783 framebuffer_info.supports_readback = true;
784 auto surface_frame = std::make_unique<SurfaceFrame>(
785 /*surface=*/
786 nullptr, /*framebuffer_info=*/framebuffer_info,
787 /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
788 /*submit_callback=*/[](const SurfaceFrame&) { return true; },
789 /*frame_size=*/DlISize(800, 600));
790 EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(true));
791 ON_CALL(delegate, GetIsGpuDisabledSyncSwitch())
792 .WillByDefault(Return(is_gpu_disabled_sync_switch));
793 EXPECT_CALL(delegate, GetIsGpuDisabledSyncSwitch()).Times(0);
794 EXPECT_CALL(*surface, AcquireFrame(DlISize()))
795 .WillOnce(Return(ByMove(std::move(surface_frame))));
796 EXPECT_CALL(*surface, MakeRenderContextCurrent())
797 .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
798
799 rasterizer->Setup(std::move(surface));
800 fml::AutoResetWaitableEvent latch;
801 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
802 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
803 auto layer_tree = std::make_unique<LayerTree>(
804 /*root_layer=*/nullptr, /*frame_size=*/DlISize());
805 auto layer_tree_item = std::make_unique<FrameItem>(
806 SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
807 kDevicePixelRatio),
808 CreateFinishedBuildRecorder());
809 PipelineProduceResult result =
810 pipeline->Produce().Complete(std::move(layer_tree_item));
811 EXPECT_TRUE(result.success);
812 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
813 rasterizer->Draw(pipeline);
814 latch.Signal();
815 });
816 latch.Wait();
817}
818
819TEST(
820 RasterizerTest,
821 drawWithGpuDisabledAndSurfaceAllowsDrawingWhenGpuDisabledDoesAcquireFrame) {
822 std::string test_name =
823 ::testing::UnitTest::GetInstance()->current_test_info()->name();
824 ThreadHost thread_host("io.flutter.test." + test_name + ".",
825 ThreadHost::Type::kPlatform |
826 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
827 ThreadHost::Type::kUi);
828 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
829 thread_host.raster_thread->GetTaskRunner(),
830 thread_host.ui_thread->GetTaskRunner(),
831 thread_host.io_thread->GetTaskRunner());
832 NiceMock<MockDelegate> delegate;
833 Settings settings;
834 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
835 EXPECT_CALL(delegate, GetTaskRunners())
836 .WillRepeatedly(ReturnRef(task_runners));
837 EXPECT_CALL(delegate, OnFrameRasterized(_));
838 auto rasterizer = std::make_unique<Rasterizer>(delegate);
839 auto surface = std::make_unique<NiceMock<MockSurface>>();
840 auto is_gpu_disabled_sync_switch =
841 std::make_shared<const fml::SyncSwitch>(true);
842
843 SurfaceFrame::FramebufferInfo framebuffer_info;
844 framebuffer_info.supports_readback = true;
845
846 auto surface_frame = std::make_unique<SurfaceFrame>(
847 /*surface=*/
848 nullptr, /*framebuffer_info=*/framebuffer_info,
849 /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
850 /*submit_callback=*/[](const SurfaceFrame&) { return true; },
851 /*frame_size=*/DlISize(800, 600));
852 EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(true));
853 ON_CALL(delegate, GetIsGpuDisabledSyncSwitch())
854 .WillByDefault(Return(is_gpu_disabled_sync_switch));
855 EXPECT_CALL(delegate, GetIsGpuDisabledSyncSwitch()).Times(0);
856 EXPECT_CALL(*surface, AcquireFrame(DlISize()))
857 .WillOnce(Return(ByMove(std::move(surface_frame))));
858 EXPECT_CALL(*surface, MakeRenderContextCurrent())
859 .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
860
861 rasterizer->Setup(std::move(surface));
862 fml::AutoResetWaitableEvent latch;
863 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
864 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
865 auto layer_tree = std::make_unique<LayerTree>(
866 /*root_layer=*/nullptr, /*frame_size=*/DlISize());
867 auto layer_tree_item = std::make_unique<FrameItem>(
868 SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
869 kDevicePixelRatio),
870 CreateFinishedBuildRecorder());
871 PipelineProduceResult result =
872 pipeline->Produce().Complete(std::move(layer_tree_item));
873 EXPECT_TRUE(result.success);
874 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
875 DrawStatus status = rasterizer->Draw(pipeline);
876 EXPECT_EQ(status, DrawStatus::kDone);
877 latch.Signal();
878 });
879 latch.Wait();
880}
881
882TEST(
883 RasterizerTest,
884 drawWithGpuEnabledAndSurfaceDisallowsDrawingWhenGpuDisabledDoesAcquireFrame) {
885 std::string test_name =
886 ::testing::UnitTest::GetInstance()->current_test_info()->name();
887 ThreadHost thread_host("io.flutter.test." + test_name + ".",
888 ThreadHost::Type::kPlatform |
889 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
890 ThreadHost::Type::kUi);
891 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
892 thread_host.raster_thread->GetTaskRunner(),
893 thread_host.ui_thread->GetTaskRunner(),
894 thread_host.io_thread->GetTaskRunner());
895 NiceMock<MockDelegate> delegate;
896 Settings settings;
897 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
898 EXPECT_CALL(delegate, GetTaskRunners())
899 .WillRepeatedly(ReturnRef(task_runners));
900 EXPECT_CALL(delegate, OnFrameRasterized(_));
901 auto rasterizer = std::make_unique<Rasterizer>(delegate);
902 auto surface = std::make_unique<NiceMock<MockSurface>>();
903 auto is_gpu_disabled_sync_switch =
904 std::make_shared<const fml::SyncSwitch>(false);
905
906 SurfaceFrame::FramebufferInfo framebuffer_info;
907 framebuffer_info.supports_readback = true;
908
909 auto surface_frame = std::make_unique<SurfaceFrame>(
910 /*surface=*/
911 nullptr, /*framebuffer_info=*/framebuffer_info,
912 /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
913 /*submit_callback=*/[](const SurfaceFrame&) { return true; },
914 /*frame_size=*/DlISize(800, 600));
915 EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(false));
916 EXPECT_CALL(delegate, GetIsGpuDisabledSyncSwitch())
917 .WillOnce(Return(is_gpu_disabled_sync_switch));
918 EXPECT_CALL(*surface, AcquireFrame(DlISize()))
919 .WillOnce(Return(ByMove(std::move(surface_frame))));
920 EXPECT_CALL(*surface, MakeRenderContextCurrent())
921 .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
922
923 rasterizer->Setup(std::move(surface));
924 fml::AutoResetWaitableEvent latch;
925 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
926 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
927 auto layer_tree = std::make_unique<LayerTree>(
928 /*root_layer=*/nullptr, /*frame_size=*/DlISize());
929 auto layer_tree_item = std::make_unique<FrameItem>(
930 SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
931 kDevicePixelRatio),
932 CreateFinishedBuildRecorder());
933 PipelineProduceResult result =
934 pipeline->Produce().Complete(std::move(layer_tree_item));
935 EXPECT_TRUE(result.success);
936 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
937 DrawStatus status = rasterizer->Draw(pipeline);
938 EXPECT_EQ(status, DrawStatus::kDone);
939 latch.Signal();
940 });
941 latch.Wait();
942}
943
944TEST(
945 RasterizerTest,
946 drawWithGpuDisabledAndSurfaceDisallowsDrawingWhenGpuDisabledDoesntAcquireFrame) {
947 std::string test_name =
948 ::testing::UnitTest::GetInstance()->current_test_info()->name();
949 ThreadHost thread_host("io.flutter.test." + test_name + ".",
950 ThreadHost::Type::kPlatform |
951 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
952 ThreadHost::Type::kUi);
953 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
954 thread_host.raster_thread->GetTaskRunner(),
955 thread_host.ui_thread->GetTaskRunner(),
956 thread_host.io_thread->GetTaskRunner());
957 NiceMock<MockDelegate> delegate;
958 Settings settings;
959 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
960 EXPECT_CALL(delegate, GetTaskRunners())
961 .WillRepeatedly(ReturnRef(task_runners));
962 EXPECT_CALL(delegate, OnFrameRasterized(_)).Times(0);
963 auto rasterizer = std::make_unique<Rasterizer>(delegate);
964 auto surface = std::make_unique<NiceMock<MockSurface>>();
965 auto is_gpu_disabled_sync_switch =
966 std::make_shared<const fml::SyncSwitch>(true);
967
968 SurfaceFrame::FramebufferInfo framebuffer_info;
969 framebuffer_info.supports_readback = true;
970
971 auto surface_frame = std::make_unique<SurfaceFrame>(
972 /*surface=*/
973 nullptr, /*framebuffer_info=*/framebuffer_info,
974 /*encode_callback=*/[](const SurfaceFrame&, DlCanvas*) { return true; },
975 /*submit_callback=*/[](const SurfaceFrame&) { return true; },
976 /*frame_size=*/DlISize(800, 600));
977 EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillOnce(Return(false));
978 EXPECT_CALL(delegate, GetIsGpuDisabledSyncSwitch())
979 .WillOnce(Return(is_gpu_disabled_sync_switch));
980 EXPECT_CALL(*surface, AcquireFrame(DlISize())).Times(0);
981 EXPECT_CALL(*surface, MakeRenderContextCurrent())
982 .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
983
984 rasterizer->Setup(std::move(surface));
985 fml::AutoResetWaitableEvent latch;
986 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
987 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
988 auto layer_tree = std::make_unique<LayerTree>(
989 /*root_layer=*/nullptr, /*frame_size=*/DlISize());
990 auto layer_tree_item = std::make_unique<FrameItem>(
991 SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
992 kDevicePixelRatio),
993 CreateFinishedBuildRecorder());
994 PipelineProduceResult result =
995 pipeline->Produce().Complete(std::move(layer_tree_item));
996 EXPECT_TRUE(result.success);
997 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
998 DrawStatus status = rasterizer->Draw(pipeline);
999 EXPECT_EQ(status, DrawStatus::kGpuUnavailable);
1000 latch.Signal();
1001 });
1002 latch.Wait();
1003}
1004
1005TEST(
1006 RasterizerTest,
1007 FrameTimingRecorderShouldStartRecordingRasterTimeBeforeSurfaceAcquireFrame) {
1008 std::string test_name =
1009 ::testing::UnitTest::GetInstance()->current_test_info()->name();
1010 ThreadHost thread_host("io.flutter.test." + test_name + ".",
1011 ThreadHost::Type::kPlatform |
1012 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
1013 ThreadHost::Type::kUi);
1014 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
1015 thread_host.raster_thread->GetTaskRunner(),
1016 thread_host.ui_thread->GetTaskRunner(),
1017 thread_host.io_thread->GetTaskRunner());
1018 NiceMock<MockDelegate> delegate;
1019 Settings settings;
1020 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
1021 EXPECT_CALL(delegate, GetTaskRunners())
1022 .WillRepeatedly(ReturnRef(task_runners));
1023 EXPECT_CALL(delegate, OnFrameRasterized(_))
1024 .WillOnce([&](const FrameTiming& frame_timing) {
1025 fml::TimePoint now = fml::TimePoint::Now();
1026 fml::TimePoint raster_start =
1027 frame_timing.Get(FrameTiming::kRasterStart);
1028 EXPECT_TRUE(now - raster_start < fml::TimeDelta::FromSecondsF(1));
1029 });
1030
1031 auto rasterizer = std::make_unique<Rasterizer>(delegate);
1032 auto surface = std::make_unique<NiceMock<MockSurface>>();
1033 auto is_gpu_disabled_sync_switch =
1034 std::make_shared<const fml::SyncSwitch>(false);
1035 ON_CALL(delegate, GetIsGpuDisabledSyncSwitch())
1036 .WillByDefault(Return(is_gpu_disabled_sync_switch));
1037 ON_CALL(*surface, AcquireFrame(DlISize())).WillByDefault([] {
1038 return nullptr;
1039 });
1040 EXPECT_CALL(*surface, AcquireFrame(DlISize()));
1041 EXPECT_CALL(*surface, MakeRenderContextCurrent())
1042 .WillOnce(Return(ByMove(std::make_unique<GLContextDefaultResult>(true))));
1043 rasterizer->Setup(std::move(surface));
1044 fml::AutoResetWaitableEvent latch;
1045 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
1046 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
1047 auto layer_tree = std::make_unique<LayerTree>(
1048 /*root_layer=*/nullptr, /*frame_size=*/DlISize());
1049 auto layer_tree_item = std::make_unique<FrameItem>(
1050 SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
1051 kDevicePixelRatio),
1052 CreateFinishedBuildRecorder());
1053 PipelineProduceResult result =
1054 pipeline->Produce().Complete(std::move(layer_tree_item));
1055 EXPECT_TRUE(result.success);
1056 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
1057 DrawStatus status = rasterizer->Draw(pipeline);
1058 EXPECT_EQ(status, DrawStatus::kDone);
1059 EXPECT_EQ(rasterizer->GetLastDrawStatus(kImplicitViewId),
1060 DrawSurfaceStatus::kFailed);
1061 latch.Signal();
1062 });
1063 latch.Wait();
1064}
1065
1066TEST(RasterizerTest,
1067 drawLayerTreeWithCorrectFrameTimingWhenPipelineIsMoreAvailable) {
1068 std::string test_name =
1069 ::testing::UnitTest::GetInstance()->current_test_info()->name();
1070 ThreadHost thread_host("io.flutter.test." + test_name + ".",
1071 ThreadHost::Type::kPlatform |
1072 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
1073 ThreadHost::Type::kUi);
1074 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
1075 thread_host.raster_thread->GetTaskRunner(),
1076 thread_host.ui_thread->GetTaskRunner(),
1077 thread_host.io_thread->GetTaskRunner());
1078 NiceMock<MockDelegate> delegate;
1079 Settings settings;
1080 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
1081 ON_CALL(delegate, GetTaskRunners()).WillByDefault(ReturnRef(task_runners));
1082
1083 fml::AutoResetWaitableEvent latch;
1084 std::unique_ptr<Rasterizer> rasterizer;
1085 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
1086 rasterizer = std::make_unique<Rasterizer>(delegate);
1087 latch.Signal();
1088 });
1089 latch.Wait();
1090
1091 auto surface = std::make_unique<NiceMock<MockSurface>>();
1092 EXPECT_CALL(*surface, AllowsDrawingWhenGpuDisabled())
1093 .WillRepeatedly(Return(true));
1094 ON_CALL(*surface, AcquireFrame(DlISize())).WillByDefault([] {
1095 SurfaceFrame::FramebufferInfo framebuffer_info;
1096 framebuffer_info.supports_readback = true;
1097 return std::make_unique<SurfaceFrame>(
1098 /*surface=*/
1099 nullptr, framebuffer_info,
1100 /*encode_callback=*/
1101 [](const SurfaceFrame&, DlCanvas*) { return true; },
1102 /*submit_callback=*/[](const SurfaceFrame& frame) { return true; },
1103 /*frame_size=*/DlISize(800, 600));
1104 });
1105 ON_CALL(*surface, MakeRenderContextCurrent()).WillByDefault([] {
1106 return std::make_unique<GLContextDefaultResult>(true);
1107 });
1108
1109 fml::CountDownLatch count_down_latch(2);
1110 auto first_timestamp = fml::TimePoint::Now();
1111 auto second_timestamp = first_timestamp + fml::TimeDelta::FromMilliseconds(8);
1112 std::vector<fml::TimePoint> timestamps = {first_timestamp, second_timestamp};
1113 int frame_rasterized_count = 0;
1114 EXPECT_CALL(delegate, OnFrameRasterized(_))
1115 .Times(2)
1116 .WillRepeatedly([&](const FrameTiming& frame_timing) {
1117 EXPECT_EQ(timestamps[frame_rasterized_count],
1118 frame_timing.Get(FrameTiming::kVsyncStart));
1119 EXPECT_EQ(timestamps[frame_rasterized_count],
1120 frame_timing.Get(FrameTiming::kBuildStart));
1121 EXPECT_EQ(timestamps[frame_rasterized_count],
1122 frame_timing.Get(FrameTiming::kBuildFinish));
1123 frame_rasterized_count++;
1124 count_down_latch.CountDown();
1125 });
1126
1127 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
1128 rasterizer->Setup(std::move(surface));
1129 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
1130 for (int i = 0; i < 2; i++) {
1131 auto layer_tree = std::make_unique<LayerTree>(
1132 /*root_layer=*/nullptr, /*frame_size=*/DlISize());
1133 auto layer_tree_item = std::make_unique<FrameItem>(
1134 SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
1135 kDevicePixelRatio),
1136 CreateFinishedBuildRecorder(timestamps[i]));
1137 PipelineProduceResult result =
1138 pipeline->Produce().Complete(std::move(layer_tree_item));
1139 EXPECT_TRUE(result.success);
1140 EXPECT_EQ(result.is_first_item, i == 0);
1141 }
1142 // Although we only call 'Rasterizer::Draw' once, it will be called twice
1143 // finally because there are two items in the pipeline.
1144 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
1145 rasterizer->Draw(pipeline);
1146 });
1147 count_down_latch.Wait();
1148 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
1149 rasterizer.reset();
1150 latch.Signal();
1151 });
1152 latch.Wait();
1153}
1154
1155TEST(RasterizerTest, TeardownFreesResourceCache) {
1156 std::string test_name =
1157 ::testing::UnitTest::GetInstance()->current_test_info()->name();
1158 ThreadHost thread_host("io.flutter.test." + test_name + ".",
1159 ThreadHost::Type::kPlatform |
1160 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
1161 ThreadHost::Type::kUi);
1162 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
1163 thread_host.raster_thread->GetTaskRunner(),
1164 thread_host.ui_thread->GetTaskRunner(),
1165 thread_host.io_thread->GetTaskRunner());
1166
1167 NiceMock<MockDelegate> delegate;
1168 Settings settings;
1169 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
1170 EXPECT_CALL(delegate, GetTaskRunners())
1171 .WillRepeatedly(ReturnRef(task_runners));
1172
1173 auto rasterizer = std::make_unique<Rasterizer>(delegate);
1174 auto surface = std::make_unique<NiceMock<MockSurface>>();
1175 auto context = GrDirectContext::MakeMock(nullptr);
1176 context->setResourceCacheLimit(0);
1177
1178 EXPECT_CALL(*surface, MakeRenderContextCurrent())
1179 .WillRepeatedly([]() -> std::unique_ptr<GLContextResult> {
1180 return std::make_unique<GLContextDefaultResult>(true);
1181 });
1182 EXPECT_CALL(*surface, GetContext()).WillRepeatedly(Return(context.get()));
1183
1184 rasterizer->Setup(std::move(surface));
1185 EXPECT_EQ(context->getResourceCacheLimit(), 0ul);
1186
1187 rasterizer->SetResourceCacheMaxBytes(10000000, false);
1188 EXPECT_EQ(context->getResourceCacheLimit(), 10000000ul);
1189 EXPECT_EQ(context->getResourceCachePurgeableBytes(), 0ul);
1190
1191 int count = 0;
1192 size_t bytes = 0;
1193 context->getResourceCacheUsage(&count, &bytes);
1194 EXPECT_EQ(bytes, 0ul);
1195
1196 auto image_info =
1197 SkImageInfo::MakeN32Premul(500, 500, SkColorSpace::MakeSRGB());
1198 auto sk_surface = SkSurfaces::RenderTarget(context.get(),
1199 skgpu::Budgeted::kYes, image_info);
1200 EXPECT_TRUE(sk_surface);
1201
1202 SkPaint paint;
1203 sk_surface->getCanvas()->drawPaint(paint);
1204 context->flushAndSubmit(GrSyncCpu::kYes);
1205
1206 EXPECT_EQ(context->getResourceCachePurgeableBytes(), 0ul);
1207
1208 sk_surface.reset();
1209
1210 context->getResourceCacheUsage(&count, &bytes);
1211 EXPECT_GT(bytes, 0ul);
1212 EXPECT_GT(context->getResourceCachePurgeableBytes(), 0ul);
1213
1214 rasterizer->Teardown();
1215 EXPECT_EQ(context->getResourceCachePurgeableBytes(), 0ul);
1216}
1217
1218TEST(RasterizerTest, TeardownClearsRenderContext) {
1219 std::string test_name =
1220 ::testing::UnitTest::GetInstance()->current_test_info()->name();
1221 ThreadHost thread_host("io.flutter.test." + test_name + ".",
1222 ThreadHost::Type::kPlatform |
1223 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
1224 ThreadHost::Type::kUi);
1225 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
1226 thread_host.raster_thread->GetTaskRunner(),
1227 thread_host.ui_thread->GetTaskRunner(),
1228 thread_host.io_thread->GetTaskRunner());
1229 NiceMock<MockDelegate> delegate;
1230 Settings settings;
1231 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
1232 ON_CALL(delegate, GetTaskRunners()).WillByDefault(ReturnRef(task_runners));
1233 auto rasterizer = std::make_unique<Rasterizer>(delegate);
1234 auto surface = std::make_unique<NiceMock<MockSurface>>();
1235 bool render_context_is_current = false;
1236 EXPECT_CALL(*surface, MakeRenderContextCurrent()).WillRepeatedly([&]() {
1237 render_context_is_current = true;
1238 return std::make_unique<GLContextDefaultResult>(true);
1239 });
1240 EXPECT_CALL(*surface, ClearRenderContext()).WillRepeatedly([&]() {
1241 render_context_is_current = false;
1242 return true;
1243 });
1244
1245 rasterizer->Setup(std::move(surface));
1246 EXPECT_TRUE(render_context_is_current);
1247
1248 rasterizer->Teardown();
1249 EXPECT_FALSE(render_context_is_current);
1250}
1251
1252TEST(RasterizerTest, TeardownNoSurface) {
1253 std::string test_name =
1254 ::testing::UnitTest::GetInstance()->current_test_info()->name();
1255 ThreadHost thread_host("io.flutter.test." + test_name + ".",
1256 ThreadHost::Type::kPlatform |
1257 ThreadHost::Type::kRaster | ThreadHost::Type::kIo |
1258 ThreadHost::Type::kUi);
1259 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
1260 thread_host.raster_thread->GetTaskRunner(),
1261 thread_host.ui_thread->GetTaskRunner(),
1262 thread_host.io_thread->GetTaskRunner());
1263
1264 NiceMock<MockDelegate> delegate;
1265 Settings settings;
1266 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
1267 EXPECT_CALL(delegate, GetTaskRunners())
1268 .WillRepeatedly(ReturnRef(task_runners));
1269
1270 auto rasterizer = std::make_unique<Rasterizer>(delegate);
1271
1272 EXPECT_TRUE(rasterizer);
1273 rasterizer->Teardown();
1274}
1275
1276TEST(RasterizerTest, presentationTimeSetWhenVsyncTargetInFuture) {
1277 GTEST_SKIP() << "eglPresentationTime is disabled due to "
1278 "https://github.com/flutter/flutter/issues/112503";
1279#if false
1280 std::string test_name =
1281 ::testing::UnitTest::GetInstance()->current_test_info()->name();
1282 ThreadHost thread_host("io.flutter.test." + test_name + ".",
1283 ThreadHost::Type::kPlatform | ThreadHost::Type::kRaster |
1284 ThreadHost::Type::kIo | ThreadHost::Type::kUi);
1285 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
1286 thread_host.raster_thread->GetTaskRunner(),
1287 thread_host.ui_thread->GetTaskRunner(),
1288 thread_host.io_thread->GetTaskRunner());
1289
1290 NiceMock<MockDelegate> delegate;
1291 Settings settings;
1292 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
1293 ON_CALL(delegate, GetTaskRunners()).WillByDefault(ReturnRef(task_runners));
1294
1295 fml::AutoResetWaitableEvent latch;
1296 std::unique_ptr<Rasterizer> rasterizer;
1297 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
1298 rasterizer = std::make_unique<Rasterizer>(delegate);
1299 latch.Signal();
1300 });
1301 latch.Wait();
1302
1303 const auto millis_16 = fml::TimeDelta::FromMilliseconds(16);
1304 const auto first_timestamp = fml::TimePoint::Now() + millis_16;
1305 auto second_timestamp = first_timestamp + millis_16;
1306 std::vector<fml::TimePoint> timestamps = {first_timestamp, second_timestamp};
1307
1308 int frames_submitted = 0;
1309 fml::CountDownLatch submit_latch(2);
1310 auto surface = std::make_unique<MockSurface>();
1311 ON_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillByDefault(Return(true));
1312 ON_CALL(*surface, AcquireFrame(DlISize()))
1313 .WillByDefault([&] {
1314 SurfaceFrame::FramebufferInfo framebuffer_info;
1315 framebuffer_info.supports_readback = true;
1316 return std::make_unique<SurfaceFrame>(
1317 /*surface=*/nullptr, framebuffer_info,
1318 /*submit_callback=*/
1319 [&](const SurfaceFrame& frame, DlCanvas*) {
1320 const auto pres_time = *frame.submit_info().presentation_time;
1321 const auto diff = pres_time - first_timestamp;
1322 int num_frames_submitted = frames_submitted++;
1323 EXPECT_EQ(diff.ToMilliseconds(),
1324 num_frames_submitted * millis_16.ToMilliseconds());
1325 submit_latch.CountDown();
1326 return true;
1327 },
1328 /*frame_size=*/DlISize(800, 600));
1329 });
1330
1331 ON_CALL(*surface, MakeRenderContextCurrent())
1332 .WillByDefault(
1333 [] { return std::make_unique<GLContextDefaultResult>(true); });
1334
1335 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
1336 rasterizer->Setup(std::move(surface));
1337 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
1338 for (int i = 0; i < 2; i++) {
1339 auto layer_tree = std::make_unique<LayerTree>(
1340 /*root_layer=*/nullptr, /*frame_size=*/DlISize());
1341 auto layer_tree_item = std::make_unique<FrameItem>(
1342 SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
1343 kDevicePixelRatio),
1344 CreateFinishedBuildRecorder(timestamps[i]));
1345 PipelineProduceResult result =
1346 pipeline->Produce().Complete(std::move(layer_tree_item));
1347 EXPECT_TRUE(result.success);
1348 EXPECT_EQ(result.is_first_item, i == 0);
1349 }
1350 // Although we only call 'Rasterizer::Draw' once, it will be called twice
1351 // finally because there are two items in the pipeline.
1352 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
1353 rasterizer->Draw(pipeline);
1354 });
1355
1356 submit_latch.Wait();
1357 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
1358 rasterizer.reset();
1359 latch.Signal();
1360 });
1361 latch.Wait();
1362#endif // false
1363}
1364
1365TEST(RasterizerTest, presentationTimeNotSetWhenVsyncTargetInPast) {
1366 GTEST_SKIP() << "eglPresentationTime is disabled due to "
1367 "https://github.com/flutter/flutter/issues/112503";
1368#if false
1369 std::string test_name =
1370 ::testing::UnitTest::GetInstance()->current_test_info()->name();
1371 ThreadHost thread_host("io.flutter.test." + test_name + ".",
1372 ThreadHost::Type::kPlatform | ThreadHost::Type::kRaster |
1373 ThreadHost::Type::kIo | ThreadHost::Type::kUi);
1374 TaskRunners task_runners("test", thread_host.platform_thread->GetTaskRunner(),
1375 thread_host.raster_thread->GetTaskRunner(),
1376 thread_host.ui_thread->GetTaskRunner(),
1377 thread_host.io_thread->GetTaskRunner());
1378
1379 NiceMock<MockDelegate> delegate;
1380 Settings settings;
1381 ON_CALL(delegate, GetSettings()).WillByDefault(ReturnRef(settings));
1382 ON_CALL(delegate, GetTaskRunners()).WillByDefault(ReturnRef(task_runners));
1383
1384 fml::AutoResetWaitableEvent latch;
1385 std::unique_ptr<Rasterizer> rasterizer;
1386 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
1387 rasterizer = std::make_unique<Rasterizer>(delegate);
1388 latch.Signal();
1389 });
1390 latch.Wait();
1391
1392 const auto millis_16 = fml::TimeDelta::FromMilliseconds(16);
1393 const auto first_timestamp = fml::TimePoint::Now() - millis_16;
1394
1395 fml::CountDownLatch submit_latch(1);
1396 auto surface = std::make_unique<MockSurface>();
1397 ON_CALL(*surface, AllowsDrawingWhenGpuDisabled()).WillByDefault(Return(true));
1398 ON_CALL(*surface, AcquireFrame(DlISize()))
1399 .WillByDefault([&] {
1400 SurfaceFrame::FramebufferInfo framebuffer_info;
1401 framebuffer_info.supports_readback = true;
1402 return std::make_unique<SurfaceFrame>(
1403 /*surface=*/nullptr, framebuffer_info,
1404 /*submit_callback=*/
1405 [&](const SurfaceFrame& frame, DlCanvas*) {
1406 const std::optional<fml::TimePoint> pres_time =
1407 frame.submit_info().presentation_time;
1408 EXPECT_EQ(pres_time, std::nullopt);
1409 submit_latch.CountDown();
1410 return true;
1411 },
1412 /*frame_size=*/DlISize(800, 600));
1413 });
1414
1415 ON_CALL(*surface, MakeRenderContextCurrent())
1416 .WillByDefault(
1417 [] { return std::make_unique<GLContextDefaultResult>(true); });
1418
1419 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
1420 rasterizer->Setup(std::move(surface));
1421 auto pipeline = std::make_shared<FramePipeline>(/*depth=*/10);
1422 auto layer_tree = std::make_unique<LayerTree>(
1423 /*root_layer=*/nullptr, /*frame_size=*/DlISize());
1424 auto layer_tree_item = std::make_unique<FrameItem>(
1425 SingleLayerTreeList(kImplicitViewId, std::move(layer_tree),
1426 kDevicePixelRatio),
1427 CreateFinishedBuildRecorder(first_timestamp));
1428 PipelineProduceResult result =
1429 pipeline->Produce().Complete(std::move(layer_tree_item));
1430 EXPECT_TRUE(result.success);
1431 EXPECT_EQ(result.is_first_item, true);
1432 ON_CALL(delegate, ShouldDiscardLayerTree).WillByDefault(Return(false));
1433 rasterizer->Draw(pipeline);
1434 });
1435
1436 submit_latch.Wait();
1437 thread_host.raster_thread->GetTaskRunner()->PostTask([&] {
1438 rasterizer.reset();
1439 latch.Signal();
1440 });
1441 latch.Wait();
1442#endif // false
1443}
1444
1445} // namespace flutter
flutter::DlCanvas
Developer-facing API for rendering anything within the engine.
Definition dl_canvas.h:32
flutter::FrameTiming::Get
fml::TimePoint Get(Phase phase) const
Definition settings.h:43
flutter::SurfaceFrame::submit_info
const SubmitInfo & submit_info() const
Definition surface_frame.h:125
fml::MessageLoop::EnsureInitializedForCurrentThread
static void EnsureInitializedForCurrentThread()
Definition message_loop.cc:27
fml::MessageLoop::GetCurrent
static FML_EMBEDDER_ONLY MessageLoop & GetCurrent()
Definition message_loop.cc:19
fml::TimeDelta::FromSecondsF
static constexpr TimeDelta FromSecondsF(double seconds)
Definition time_delta.h:53
fml::TimeDelta::FromMilliseconds
static constexpr TimeDelta FromMilliseconds(int64_t millis)
Definition time_delta.h:46
fml::TimePoint::Now
static TimePoint Now()
Definition time_point.cc:49
count_down_latch.h
params
const EmbeddedViewParams * params
Definition embedder_external_view_embedder.cc:142
surface
VkSurfaceKHR surface
Definition main.cc:65
i
int i
Definition fl_socket_accessible.cc:18
view_id
G_BEGIN_DECLS FlutterViewId view_id
Definition fl_view_accessible.h:49
frame_timings.h
flutter::CreateFinishedBuildRecorder
static std::unique_ptr< FrameTimingsRecorder > CreateFinishedBuildRecorder()
Definition rasterizer_unittests.cc:160
flutter::TEST
TEST(FrameTimingsRecorderTest, RecordVsync)
Definition frame_timings_recorder_unittests.cc:22
flutter::DlMatrix
impeller::Matrix DlMatrix
Definition dl_geometry_types.h:32
flutter::DlISize
impeller::ISize32 DlISize
Definition dl_geometry_types.h:26
flutter::size
it will be possible to load the file into Perfetto s trace viewer use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level old gen heap size
Definition switch_defs.h:244
flutter::kImplicitViewId
constexpr FlutterViewId kImplicitViewId
Definition flutter_windows_engine.h:56
fml::Milliseconds
std::chrono::duration< double, std::milli > Milliseconds
Definition time_delta.h:18
context
std::shared_ptr< ContextGLES > context
Definition render_pass_gles_unittests.cc:74
pipeline
std::shared_ptr< PipelineGLES > pipeline
Definition render_pass_gles_unittests.cc:79
flutter::ThreadHost
The collection of all the threads used by the engine.
Definition thread_host.h:21
flutter::ThreadHost::io_thread
std::unique_ptr< fml::Thread > io_thread
Definition thread_host.h:86
flutter::ThreadHost::platform_thread
std::unique_ptr< fml::Thread > platform_thread
Definition thread_host.h:83
flutter::ThreadHost::raster_thread
std::unique_ptr< fml::Thread > raster_thread
Definition thread_host.h:85
flutter::ThreadHost::ui_thread
std::unique_ptr< fml::Thread > ui_thread
Definition thread_host.h:84
surface_frame.h
create
int_closure create
Definition texture_unittests.cc:28
thread_host.h
time_point.h