|
7 | 7 | #include <memory> |
8 | 8 | #include <vector> |
9 | 9 |
|
| 10 | +#include "flutter/lib/gpu/render_pass.h" |
| 11 | +#include "flutter/lib/gpu/texture.h" |
| 12 | +#include "fml/memory/ref_ptr.h" |
10 | 13 | #include "fml/status.h" |
11 | 14 | #include "gmock/gmock.h" |
12 | 15 | #include "gtest/gtest.h" |
|
15 | 18 | namespace flutter::gpu { |
16 | 19 | namespace { |
17 | 20 |
|
| 21 | +using ::impeller::testing::MockBlitPass; |
18 | 22 | using ::impeller::testing::MockCommandBuffer; |
19 | 23 | using ::impeller::testing::MockCommandQueue; |
20 | 24 | using ::impeller::testing::MockImpellerContext; |
| 25 | +using ::impeller::testing::MockRenderPass; |
| 26 | +using ::impeller::testing::MockTexture; |
21 | 27 | using ::testing::_; |
22 | 28 | using ::testing::DoAll; |
| 29 | +using ::testing::InSequence; |
| 30 | +using ::testing::NiceMock; |
23 | 31 | using ::testing::Return; |
24 | 32 |
|
25 | 33 | TEST(FlutterGpuCommandBufferTest, |
@@ -106,5 +114,182 @@ TEST(FlutterGpuCommandBufferTest, |
106 | 114 | EXPECT_EQ(statuses[0], impeller::CommandBuffer::Status::kError); |
107 | 115 | } |
108 | 116 |
|
| 117 | +// The pass lifecycle tests heap-allocate the command buffer, since it is |
| 118 | +// ref-counted and asserts in debug builds when destroyed without a reference. |
| 119 | +class FlutterGpuPassLifecycleTest : public ::testing::Test { |
| 120 | + protected: |
| 121 | + void SetUp() override { |
| 122 | + context_ = std::make_shared<NiceMock<MockImpellerContext>>(); |
| 123 | + impeller_command_buffer_ = |
| 124 | + std::make_shared<NiceMock<MockCommandBuffer>>(context_); |
| 125 | + command_queue_ = std::make_shared<NiceMock<MockCommandQueue>>(); |
| 126 | + ON_CALL(*context_, GetBackendType) |
| 127 | + .WillByDefault(Return(impeller::Context::BackendType::kMetal)); |
| 128 | + ON_CALL(*context_, GetCommandQueue).WillByDefault(Return(command_queue_)); |
| 129 | + command_buffer_ = |
| 130 | + fml::MakeRefCounted<CommandBuffer>(context_, impeller_command_buffer_); |
| 131 | + |
| 132 | + impeller::TextureDescriptor texture_desc; |
| 133 | + texture_desc.format = impeller::PixelFormat::kR8G8B8A8UNormInt; |
| 134 | + texture_desc.size = impeller::ISize(4, 4); |
| 135 | + auto texture = std::make_shared<NiceMock<MockTexture>>(texture_desc); |
| 136 | + ON_CALL(*texture, GetSize).WillByDefault(Return(impeller::ISize(4, 4))); |
| 137 | + texture_ = fml::MakeRefCounted<Texture>(texture); |
| 138 | + } |
| 139 | + |
| 140 | + std::shared_ptr<MockRenderPass> MakeRenderPass() { |
| 141 | + auto pass = std::make_shared<NiceMock<MockRenderPass>>( |
| 142 | + context_, impeller::RenderTarget()); |
| 143 | + ON_CALL(*pass, IsValid).WillByDefault(Return(true)); |
| 144 | + return pass; |
| 145 | + } |
| 146 | + |
| 147 | + std::shared_ptr<MockBlitPass> MakeBlitPass() { |
| 148 | + auto pass = std::make_shared<NiceMock<MockBlitPass>>(); |
| 149 | + ON_CALL(*pass, IsValid).WillByDefault(Return(true)); |
| 150 | + ON_CALL(*pass, OnCopyTextureToTextureCommand).WillByDefault(Return(true)); |
| 151 | + return pass; |
| 152 | + } |
| 153 | + |
| 154 | + bool Copy() { |
| 155 | + return command_buffer_->CopyTextureToTexture( |
| 156 | + *texture_, *texture_, impeller::IRect::MakeXYWH(0, 0, 1, 1), |
| 157 | + impeller::IPoint(1, 1)); |
| 158 | + } |
| 159 | + |
| 160 | + std::shared_ptr<NiceMock<MockImpellerContext>> context_; |
| 161 | + std::shared_ptr<NiceMock<MockCommandBuffer>> impeller_command_buffer_; |
| 162 | + std::shared_ptr<NiceMock<MockCommandQueue>> command_queue_; |
| 163 | + fml::RefPtr<CommandBuffer> command_buffer_; |
| 164 | + fml::RefPtr<Texture> texture_; |
| 165 | +}; |
| 166 | + |
| 167 | +TEST_F(FlutterGpuPassLifecycleTest, |
| 168 | + EachCommandEndsTheOpenPassBeforeTheNextPassIsCreated) { |
| 169 | + auto blit_a = MakeBlitPass(); |
| 170 | + auto render_a = MakeRenderPass(); |
| 171 | + auto render_b = MakeRenderPass(); |
| 172 | + auto blit_b = MakeBlitPass(); |
| 173 | + { |
| 174 | + InSequence sequence; |
| 175 | + EXPECT_CALL(*impeller_command_buffer_, OnCreateBlitPass) |
| 176 | + .WillOnce(Return(blit_a)); |
| 177 | + EXPECT_CALL(*blit_a, OnCopyTextureToTextureCommand); |
| 178 | + // A render pass ends the copies before it. |
| 179 | + EXPECT_CALL(*blit_a, EncodeCommands).WillOnce(Return(true)); |
| 180 | + EXPECT_CALL(*impeller_command_buffer_, OnCreateRenderPass) |
| 181 | + .WillOnce(Return(render_a)); |
| 182 | + // A render pass ends the render pass before it. |
| 183 | + EXPECT_CALL(*render_a, OnEncodeCommands).WillOnce(Return(true)); |
| 184 | + EXPECT_CALL(*impeller_command_buffer_, OnCreateRenderPass) |
| 185 | + .WillOnce(Return(render_b)); |
| 186 | + // A copy ends the render pass before it, and consecutive copies share |
| 187 | + // one blit pass. |
| 188 | + EXPECT_CALL(*render_b, OnEncodeCommands).WillOnce(Return(true)); |
| 189 | + EXPECT_CALL(*impeller_command_buffer_, OnCreateBlitPass) |
| 190 | + .WillOnce(Return(blit_b)); |
| 191 | + EXPECT_CALL(*blit_b, OnCopyTextureToTextureCommand).Times(2); |
| 192 | + // Submit ends the last pass only. |
| 193 | + EXPECT_CALL(*blit_b, EncodeCommands).WillOnce(Return(true)); |
| 194 | + EXPECT_CALL(*command_queue_, Submit).WillOnce(Return(fml::Status())); |
| 195 | + } |
| 196 | + |
| 197 | + EXPECT_TRUE(Copy()); |
| 198 | + EXPECT_EQ(command_buffer_->CreateRenderPass(impeller::RenderTarget()), |
| 199 | + render_a); |
| 200 | + EXPECT_EQ(command_buffer_->CreateRenderPass(impeller::RenderTarget()), |
| 201 | + render_b); |
| 202 | + EXPECT_TRUE(Copy()); |
| 203 | + EXPECT_TRUE(Copy()); |
| 204 | + EXPECT_TRUE(command_buffer_->Submit()); |
| 205 | +} |
| 206 | + |
| 207 | +TEST_F(FlutterGpuPassLifecycleTest, EndEncodesThePassOnce) { |
| 208 | + auto render_a = MakeRenderPass(); |
| 209 | + { |
| 210 | + InSequence sequence; |
| 211 | + EXPECT_CALL(*impeller_command_buffer_, OnCreateRenderPass) |
| 212 | + .WillOnce(Return(render_a)); |
| 213 | + EXPECT_CALL(*render_a, OnEncodeCommands).WillOnce(Return(true)); |
| 214 | + EXPECT_CALL(*command_queue_, Submit).WillOnce(Return(fml::Status())); |
| 215 | + } |
| 216 | + |
| 217 | + auto pass = fml::MakeRefCounted<RenderPass>(); |
| 218 | + ASSERT_TRUE(pass->Begin(*command_buffer_)); |
| 219 | + EXPECT_TRUE(pass->End()); |
| 220 | + EXPECT_TRUE(pass->End()); |
| 221 | + EXPECT_TRUE(command_buffer_->Submit()); |
| 222 | +} |
| 223 | + |
| 224 | +TEST_F(FlutterGpuPassLifecycleTest, |
| 225 | + EndingAPassEndedByALaterCommandDoesNothing) { |
| 226 | + auto render_a = MakeRenderPass(); |
| 227 | + auto render_b = MakeRenderPass(); |
| 228 | + { |
| 229 | + InSequence sequence; |
| 230 | + EXPECT_CALL(*impeller_command_buffer_, OnCreateRenderPass) |
| 231 | + .WillOnce(Return(render_a)); |
| 232 | + EXPECT_CALL(*render_a, OnEncodeCommands).WillOnce(Return(true)); |
| 233 | + EXPECT_CALL(*impeller_command_buffer_, OnCreateRenderPass) |
| 234 | + .WillOnce(Return(render_b)); |
| 235 | + EXPECT_CALL(*render_b, OnEncodeCommands).WillOnce(Return(true)); |
| 236 | + EXPECT_CALL(*command_queue_, Submit).WillOnce(Return(fml::Status())); |
| 237 | + } |
| 238 | + |
| 239 | + auto pass_a = fml::MakeRefCounted<RenderPass>(); |
| 240 | + auto pass_b = fml::MakeRefCounted<RenderPass>(); |
| 241 | + ASSERT_TRUE(pass_a->Begin(*command_buffer_)); |
| 242 | + ASSERT_TRUE(pass_b->Begin(*command_buffer_)); |
| 243 | + // pass_b is still open, so this must not end it. |
| 244 | + EXPECT_TRUE(pass_a->End()); |
| 245 | + EXPECT_TRUE(command_buffer_->Submit()); |
| 246 | +} |
| 247 | + |
| 248 | +TEST_F(FlutterGpuPassLifecycleTest, OpenGLESDefersEncodingToSubmit) { |
| 249 | + ON_CALL(*context_, GetBackendType) |
| 250 | + .WillByDefault(Return(impeller::Context::BackendType::kOpenGLES)); |
| 251 | + auto render_a = MakeRenderPass(); |
| 252 | + auto blit_a = MakeBlitPass(); |
| 253 | + auto render_b = MakeRenderPass(); |
| 254 | + EXPECT_CALL(*impeller_command_buffer_, OnCreateRenderPass) |
| 255 | + .WillOnce(Return(render_a)) |
| 256 | + .WillOnce(Return(render_b)); |
| 257 | + EXPECT_CALL(*impeller_command_buffer_, OnCreateBlitPass) |
| 258 | + .WillOnce(Return(blit_a)); |
| 259 | + EXPECT_CALL(*render_a, OnEncodeCommands).Times(0); |
| 260 | + EXPECT_CALL(*blit_a, EncodeCommands).Times(0); |
| 261 | + EXPECT_CALL(*render_b, OnEncodeCommands).Times(0); |
| 262 | + |
| 263 | + // Submit posts to the raster thread, which needs a running isolate, so |
| 264 | + // this only checks that ending passes does not encode them on GLES. |
| 265 | + auto pass = fml::MakeRefCounted<RenderPass>(); |
| 266 | + ASSERT_TRUE(pass->Begin(*command_buffer_)); |
| 267 | + EXPECT_TRUE(Copy()); |
| 268 | + EXPECT_TRUE(Copy()); |
| 269 | + EXPECT_EQ(command_buffer_->CreateRenderPass(impeller::RenderTarget()), |
| 270 | + render_b); |
| 271 | + EXPECT_TRUE(pass->End()); |
| 272 | +} |
| 273 | + |
| 274 | +TEST_F(FlutterGpuPassLifecycleTest, FailingToEncodeAnEndedPassFailsSubmit) { |
| 275 | + auto render_a = MakeRenderPass(); |
| 276 | + EXPECT_CALL(*impeller_command_buffer_, OnCreateRenderPass) |
| 277 | + .WillOnce(Return(render_a)); |
| 278 | + EXPECT_CALL(*render_a, OnEncodeCommands).WillOnce(Return(false)); |
| 279 | + EXPECT_CALL(*command_queue_, Submit).Times(0); |
| 280 | + |
| 281 | + EXPECT_EQ(command_buffer_->CreateRenderPass(impeller::RenderTarget()), |
| 282 | + render_a); |
| 283 | + EXPECT_FALSE(Copy()); |
| 284 | + |
| 285 | + std::vector<impeller::CommandBuffer::Status> statuses; |
| 286 | + EXPECT_FALSE(command_buffer_->Submit( |
| 287 | + [&statuses](impeller::CommandBuffer::Status status) { |
| 288 | + statuses.push_back(status); |
| 289 | + })); |
| 290 | + ASSERT_EQ(statuses.size(), 1u); |
| 291 | + EXPECT_EQ(statuses[0], impeller::CommandBuffer::Status::kError); |
| 292 | +} |
| 293 | + |
109 | 294 | } // namespace |
110 | 295 | } // namespace flutter::gpu |
0 commit comments