| // Copyright 2015 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifdef UNSAFE_BUFFERS_BUILD |
| // TODO(crbug.com/40285824): Remove this and convert code to safer constructs. |
| #pragma allow_unsafe_buffers |
| #endif |
| |
| #include "components/exo/surface.h" |
| |
| #include <optional> |
| #include <tuple> |
| |
| #include "base/command_line.h" |
| #include "base/feature_list.h" |
| #include "base/functional/bind.h" |
| #include "base/memory/raw_ref.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/test/bind.h" |
| #include "base/test/scoped_chromeos_version_info.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "base/time/time.h" |
| #include "components/exo/buffer.h" |
| #include "components/exo/shell_surface.h" |
| #include "components/exo/sub_surface.h" |
| #include "components/exo/surface_test_util.h" |
| #include "components/exo/test/exo_test_base.h" |
| #include "components/exo/test/exo_test_helper.h" |
| #include "components/exo/test/shell_surface_builder.h" |
| #include "components/exo/test/surface_tree_host_test_util.h" |
| #include "components/viz/common/quads/compositor_frame.h" |
| #include "components/viz/common/quads/solid_color_draw_quad.h" |
| #include "components/viz/common/quads/texture_draw_quad.h" |
| #include "components/viz/service/surfaces/surface.h" |
| #include "components/viz/service/surfaces/surface_manager.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/khronos/GLES2/gl2.h" |
| #include "ui/aura/test/window_occlusion_tracker_test_api.h" |
| #include "ui/compositor/layer.h" |
| #include "ui/compositor/layer_tree_owner.h" |
| #include "ui/display/display.h" |
| #include "ui/display/display_switches.h" |
| #include "ui/gfx/geometry/dip_util.h" |
| #include "ui/gfx/geometry/point_conversions.h" |
| #include "ui/gfx/geometry/point_f.h" |
| #include "ui/gfx/geometry/rect.h" |
| #include "ui/gfx/geometry/rect_conversions.h" |
| #include "ui/gfx/geometry/size_f.h" |
| #include "ui/gfx/geometry/test/geometry_util.h" |
| #include "ui/gfx/gpu_fence.h" |
| #include "ui/gfx/gpu_fence_handle.h" |
| #include "ui/gfx/gpu_memory_buffer.h" |
| #include "ui/wm/core/window_util.h" |
| |
| namespace exo { |
| namespace { |
| |
| std::unique_ptr<std::vector<gfx::Rect>> GetHitTestShapeRects(Surface* surface) { |
| if (surface->hit_test_region().IsEmpty()) |
| return nullptr; |
| |
| auto rects = std::make_unique<std::vector<gfx::Rect>>(); |
| for (gfx::Rect rect : surface->hit_test_region()) |
| rects->push_back(rect); |
| return rects; |
| } |
| |
| std::string TransformToString(Transform transform) { |
| std::string prefix = "Transform::"; |
| std::string name; |
| switch (transform) { |
| case Transform::NORMAL: |
| name = "NORMAL"; |
| break; |
| case Transform::ROTATE_90: |
| name = "ROTATE_90"; |
| break; |
| case Transform::ROTATE_180: |
| name = "ROTATE_180"; |
| break; |
| case Transform::ROTATE_270: |
| name = "ROTATE_270"; |
| break; |
| case Transform::FLIPPED: |
| name = "FLIPPED"; |
| break; |
| case Transform::FLIPPED_ROTATE_90: |
| name = "FLIPPED_ROTATE_90"; |
| break; |
| case Transform::FLIPPED_ROTATE_180: |
| name = "FLIPPED_ROTATE_180"; |
| break; |
| case Transform::FLIPPED_ROTATE_270: |
| name = "FLIPPED_ROTATE_270"; |
| break; |
| default: |
| return "[UNKNOWN_TRANSFORM]"; |
| } |
| return prefix + name; |
| } |
| |
| class SurfaceTest : public test::ExoTestBase, |
| public ::testing::WithParamInterface< |
| std::tuple<test::FrameSubmissionType, float>> { |
| public: |
| SurfaceTest() { |
| test::SetFrameSubmissionFeatureFlags(&feature_list_, |
| GetFrameSubmissionType()); |
| } |
| |
| SurfaceTest(const SurfaceTest&) = delete; |
| SurfaceTest& operator=(const SurfaceTest&) = delete; |
| |
| ~SurfaceTest() override = default; |
| void SetUp() override { |
| base::CommandLine* command_line = base::CommandLine::ForCurrentProcess(); |
| // Set the device scale factor. |
| command_line->AppendSwitchASCII( |
| switches::kForceDeviceScaleFactor, |
| base::StringPrintf("%f", device_scale_factor())); |
| test::ExoTestBase::SetUp(); |
| } |
| |
| void TearDown() override { |
| test::ExoTestBase::TearDown(); |
| display::Display::ResetForceDeviceScaleFactorForTesting(); |
| } |
| |
| test::FrameSubmissionType GetFrameSubmissionType() const { |
| return std::get<0>(GetParam()); |
| } |
| float device_scale_factor() const { return std::get<1>(GetParam()); } |
| |
| gfx::Rect ToPixel(const gfx::Rect rect) { |
| return gfx::ToEnclosingRect( |
| gfx::ConvertRectToPixels(rect, device_scale_factor())); |
| } |
| |
| gfx::Rect GetCompleteDamage(const viz::CompositorFrame& frame) { |
| auto& root_pass = frame.render_pass_list.back(); |
| gfx::Rect complete_damage = root_pass->damage_rect; |
| |
| for (auto* quad : root_pass->quad_list) { |
| if (quad->material == viz::DrawQuad::Material::kTextureContent) { |
| auto* texture_quad = viz::TextureDrawQuad::MaterialCast(quad); |
| if (texture_quad->damage_rect.has_value()) { |
| complete_damage.Union(texture_quad->damage_rect.value()); |
| } |
| } |
| } |
| return complete_damage; |
| } |
| |
| gfx::Rect ToTargetSpaceDamage(const viz::CompositorFrame& frame) { |
| // Map a frame's damage back to the coordinate space of its buffer. |
| return gfx::ScaleToEnclosingRect(GetCompleteDamage(frame), |
| 1 / device_scale_factor()); |
| } |
| |
| const viz::CompositorFrame& GetFrameFromSurface(ShellSurface* shell_surface) { |
| viz::SurfaceId surface_id = |
| *shell_surface->host_window()->layer()->GetSurfaceId(); |
| const viz::CompositorFrame& frame = |
| GetSurfaceManager()->GetSurfaceForId(surface_id)->GetActiveFrame(); |
| return frame; |
| } |
| |
| void SetBufferTransformHelperTransformAndTest(Surface* surface, |
| ShellSurface* shell_surface, |
| Transform transform, |
| const gfx::Size& expected_size); |
| |
| void SetCropAndBufferTransformHelperTransformAndTest( |
| Surface* surface, |
| ShellSurface* shell_surface, |
| Transform transform, |
| const gfx::RectF& expected_rect, |
| bool has_viewport); |
| |
| private: |
| base::test::ScopedFeatureList feature_list_; |
| }; |
| |
| // Instantiate the values of frame submission types and device scale factor in |
| // the parameterized tests. |
| INSTANTIATE_TEST_SUITE_P( |
| All, |
| SurfaceTest, |
| testing::Combine(testing::Values(test::FrameSubmissionType::kNoReactive, |
| test::FrameSubmissionType::kReactive), |
| testing::Values(1.0f, 1.25f, 2.0f))); |
| |
| TEST_P(SurfaceTest, AttachOffset) { |
| gfx::Size buffer_size(256, 256); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| surface->Attach(buffer.get(), gfx::Vector2d(0, 0)); |
| surface->Commit(); |
| EXPECT_EQ(surface->GetBufferOffset(), gfx::Vector2d(0, 0)); |
| |
| surface->Attach(buffer.get(), gfx::Vector2d(1, 2)); |
| surface->Commit(); |
| EXPECT_EQ(surface->GetBufferOffset(), gfx::Vector2d(1, 2)); |
| |
| surface->Attach(buffer.get(), gfx::Vector2d(1, 2)); |
| surface->Commit(); |
| EXPECT_EQ(surface->GetBufferOffset(), gfx::Vector2d(2, 4)); |
| |
| surface->Attach(buffer.get(), gfx::Vector2d(-2, -4)); |
| surface->Commit(); |
| EXPECT_EQ(surface->GetBufferOffset(), gfx::Vector2d(0, 0)); |
| |
| // Pending updates for the offset should not be accumulated. |
| surface->Attach(buffer.get(), gfx::Vector2d(1, 2)); |
| surface->Attach(buffer.get(), gfx::Vector2d(3, 4)); |
| surface->Attach(buffer.get(), gfx::Vector2d(5, 6)); |
| surface->Commit(); |
| EXPECT_EQ(surface->GetBufferOffset(), gfx::Vector2d(5, 6)); |
| } |
| |
| TEST_P(SurfaceTest, AttachOffsetSynchronizedSubsurface) { |
| gfx::Size buffer_size(256, 256); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| gfx::Size child_buffer_size(128, 128); |
| auto child_buffer = test::ExoTestHelper::CreateBuffer(child_buffer_size); |
| auto child_surface = std::make_unique<Surface>(); |
| auto sub = std::make_unique<SubSurface>(child_surface.get(), surface.get()); |
| sub->surface()->Attach(child_buffer.get(), gfx::Vector2d(0, 0)); |
| sub->SetCommitBehavior(/*synchronized=*/true); |
| EXPECT_EQ(sub->surface()->GetBufferOffset(), gfx::Vector2d(0, 0)); |
| |
| sub->surface()->Attach(child_buffer.get(), gfx::Vector2d(1, 2)); |
| sub->surface()->Commit(); |
| sub->surface()->Attach(child_buffer.get(), gfx::Vector2d(1, 2)); |
| sub->surface()->Commit(); |
| |
| // The offset should not be updated by subsurface commits since this |
| // subsurface is in the synchronized mode. |
| EXPECT_EQ(sub->surface()->GetBufferOffset(), gfx::Vector2d(0, 0)); |
| |
| // Once parent surface is committed, the offset should be updated. The cached |
| // offset should be accumulated. |
| surface->Commit(); |
| EXPECT_EQ(sub->surface()->GetBufferOffset(), gfx::Vector2d(2, 4)); |
| |
| // Try again. |
| sub->surface()->Attach(child_buffer.get(), gfx::Vector2d(1, 2)); |
| sub->surface()->Commit(); |
| surface->Commit(); |
| EXPECT_EQ(sub->surface()->GetBufferOffset(), gfx::Vector2d(3, 6)); |
| } |
| |
| TEST_P(SurfaceTest, AttachOffsetDesynchronizedSubsurface) { |
| gfx::Size buffer_size(256, 256); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| gfx::Size child_buffer_size(128, 128); |
| auto child_buffer = test::ExoTestHelper::CreateBuffer(child_buffer_size); |
| auto child_surface = std::make_unique<Surface>(); |
| auto sub = std::make_unique<SubSurface>(child_surface.get(), surface.get()); |
| sub->surface()->Attach(child_buffer.get(), gfx::Vector2d(0, 0)); |
| sub->SetCommitBehavior(/*synchronized=*/false); |
| EXPECT_EQ(sub->surface()->GetBufferOffset(), gfx::Vector2d(0, 0)); |
| |
| sub->surface()->Attach(child_buffer.get(), gfx::Vector2d(1, 2)); |
| |
| // Parent's commit does not take affect for the subsurface. |
| surface->Commit(); |
| EXPECT_EQ(sub->surface()->GetBufferOffset(), gfx::Vector2d(0, 0)); |
| |
| // This should replace the pending offset because the previous one is not |
| // committed. |
| sub->surface()->Attach(child_buffer.get(), gfx::Vector2d(10, 20)); |
| |
| // The offset should be updated by subsurface commit. |
| sub->surface()->Commit(); |
| EXPECT_EQ(sub->surface()->GetBufferOffset(), gfx::Vector2d(10, 20)); |
| } |
| |
| TEST_P(SurfaceTest, Damage) { |
| gfx::Size buffer_size(256, 256); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| std::unique_ptr<Surface> surface(new Surface); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| // Attach the buffer to the surface. This will update the pending bounds of |
| // the surface to the buffer size. |
| surface->Attach(buffer.get()); |
| |
| // Mark areas inside the bounds of the surface as damaged. This should result |
| // in pending damage. |
| surface->Damage(gfx::Rect(0, 0, 10, 10)); |
| surface->Damage(gfx::Rect(10, 10, 10, 10)); |
| EXPECT_TRUE(surface->HasPendingDamageForTesting(gfx::Rect(0, 0, 10, 10))); |
| EXPECT_TRUE(surface->HasPendingDamageForTesting(gfx::Rect(10, 10, 10, 10))); |
| EXPECT_FALSE(surface->HasPendingDamageForTesting(gfx::Rect(5, 5, 10, 10))); |
| |
| // Check that damage larger than contents is handled correctly at commit. |
| surface->Damage(gfx::Rect(gfx::ScaleToCeiledSize(buffer_size, 2.0f))); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| EXPECT_EQ(ToPixel(gfx::Rect(buffer_size)), GetCompleteDamage(frame)); |
| } |
| |
| gfx::RectF buffer_damage(32, 64, 16, 32); |
| gfx::Rect surface_damage = gfx::ToNearestRect(buffer_damage); |
| |
| // Check that damage is correct for a non-square rectangle not at the origin. |
| surface->Damage(surface_damage); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| // Adjust damage for DSF filtering and verify it below. |
| if (device_scale_factor() > 1.f) |
| buffer_damage.Inset(-1.f); |
| |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| EXPECT_TRUE( |
| ToTargetSpaceDamage(frame).Contains(gfx::ToNearestRect(buffer_damage))); |
| } |
| } |
| |
| TEST_P(SurfaceTest, SubsurfaceDamageAggregation) { |
| gfx::Size buffer_size(256, 512); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| surface->Attach(buffer.get()); |
| |
| gfx::Size child_buffer_size(64, 128); |
| auto child_buffer = test::ExoTestHelper::CreateBuffer(child_buffer_size); |
| auto child_surface = std::make_unique<Surface>(); |
| auto sub_surface = |
| std::make_unique<SubSurface>(child_surface.get(), surface.get()); |
| child_surface->Attach(child_buffer.get()); |
| child_surface->Commit(); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| { |
| // Initial frame has full damage. |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| const gfx::Rect scaled_damage = gfx::ToNearestRect(gfx::ScaleRect( |
| gfx::RectF(gfx::Rect(buffer_size)), device_scale_factor())); |
| EXPECT_EQ(scaled_damage, GetCompleteDamage(frame)); |
| } |
| |
| const gfx::RectF surface_damage(16, 16); |
| const gfx::RectF subsurface_damage(32, 32, 16, 16); |
| int margin = ceil(device_scale_factor()); |
| |
| child_surface->Damage(gfx::ToNearestRect(subsurface_damage)); |
| child_surface->Commit(); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| { |
| // Subsurface damage should be propagated. |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| const gfx::Rect scaled_damage = gfx::ToNearestRect( |
| gfx::ScaleRect(subsurface_damage, device_scale_factor())); |
| EXPECT_TRUE( |
| scaled_damage.ApproximatelyEqual(GetCompleteDamage(frame), margin)); |
| } |
| |
| surface->Damage(gfx::ToNearestRect(surface_damage)); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| { |
| // When commit is called on the root with no call on the child, the damage |
| // from the previous frame shouldn't persist. |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| const gfx::Rect scaled_damage = gfx::ToNearestRect( |
| gfx::ScaleRect(surface_damage, device_scale_factor())); |
| EXPECT_TRUE( |
| scaled_damage.ApproximatelyEqual(GetCompleteDamage(frame), margin)); |
| } |
| } |
| |
| TEST_P(SurfaceTest, SubsurfaceDamageSynchronizedCommitBehavior) { |
| gfx::Size buffer_size(256, 512); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| surface->Attach(buffer.get()); |
| gfx::Size child_buffer_size(64, 128); |
| auto child_buffer = test::ExoTestHelper::CreateBuffer(child_buffer_size); |
| auto child_surface = std::make_unique<Surface>(); |
| auto sub_surface = |
| std::make_unique<SubSurface>(child_surface.get(), surface.get()); |
| // Set commit behavior to synchronized. |
| sub_surface->SetCommitBehavior(true); |
| child_surface->Attach(child_buffer.get()); |
| child_surface->Commit(); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| { |
| // Initial frame has full damage. |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| const gfx::Rect scaled_damage = gfx::ToNearestRect(gfx::ScaleRect( |
| gfx::RectF(gfx::Rect(buffer_size)), device_scale_factor())); |
| EXPECT_EQ(scaled_damage, GetCompleteDamage(frame)); |
| } |
| |
| const gfx::RectF subsurface_damage(32, 32, 16, 16); |
| const gfx::RectF subsurface_damage2(0, 0, 16, 16); |
| int margin = ceil(device_scale_factor()); |
| |
| child_surface->Damage(gfx::ToNearestRect(subsurface_damage)); |
| EXPECT_TRUE(child_surface->HasPendingDamageForTesting( |
| gfx::ToNearestRect(subsurface_damage))); |
| // Subsurface damage is cached. |
| child_surface->Commit(); |
| EXPECT_FALSE(child_surface->HasPendingDamageForTesting( |
| gfx::ToNearestRect(subsurface_damage))); |
| EXPECT_TRUE(shell_surface->GetFrameCallbacksForTesting().empty()); |
| |
| { |
| // Subsurface damage should not be propagated at all. |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| const gfx::Rect scaled_damage = gfx::ToNearestRect(gfx::ScaleRect( |
| gfx::RectF(gfx::Rect(buffer_size)), device_scale_factor())); |
| EXPECT_EQ(scaled_damage, GetCompleteDamage(frame)); |
| } |
| |
| // Damage but do not commit. |
| child_surface->Damage(gfx::ToNearestRect(subsurface_damage2)); |
| EXPECT_TRUE(child_surface->HasPendingDamageForTesting( |
| gfx::ToNearestRect(subsurface_damage2))); |
| // Apply subsurface damage from cached state, not pending state. |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| { |
| // Subsurface damage in cached state should be propagated. |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| const gfx::Rect scaled_damage = gfx::ToNearestRect( |
| gfx::ScaleRect(subsurface_damage, device_scale_factor())); |
| EXPECT_TRUE( |
| scaled_damage.ApproximatelyEqual(GetCompleteDamage(frame), margin)); |
| } |
| } |
| |
| TEST_P(SurfaceTest, SubsurfaceDamageDesynchronizedCommitBehavior) { |
| gfx::Size buffer_size(256, 512); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| surface->Attach(buffer.get()); |
| gfx::Size child_buffer_size(64, 128); |
| auto child_buffer = test::ExoTestHelper::CreateBuffer(child_buffer_size); |
| auto child_surface = std::make_unique<Surface>(); |
| auto sub_surface = |
| std::make_unique<SubSurface>(child_surface.get(), surface.get()); |
| // Set commit behavior to desynchronized. |
| sub_surface->SetCommitBehavior(false); |
| child_surface->Attach(child_buffer.get()); |
| child_surface->Commit(); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| { |
| // Initial frame has full damage. |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| const gfx::Rect scaled_damage = gfx::ToNearestRect(gfx::ScaleRect( |
| gfx::RectF(gfx::Rect(buffer_size)), device_scale_factor())); |
| EXPECT_EQ(scaled_damage, GetCompleteDamage(frame)); |
| } |
| |
| const gfx::RectF subsurface_damage(32, 32, 16, 16); |
| int margin = ceil(device_scale_factor()); |
| |
| child_surface->Damage(gfx::ToNearestRect(subsurface_damage)); |
| EXPECT_TRUE(child_surface->HasPendingDamageForTesting( |
| gfx::ToNearestRect(subsurface_damage))); |
| // Subsurface damage is applied. |
| child_surface->Commit(); |
| EXPECT_FALSE(child_surface->HasPendingDamageForTesting( |
| gfx::ToNearestRect(subsurface_damage))); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| { |
| // Subsurface damage should be propagated. |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| const gfx::Rect scaled_damage = gfx::ToNearestRect( |
| gfx::ScaleRect(subsurface_damage, device_scale_factor())); |
| EXPECT_TRUE( |
| scaled_damage.ApproximatelyEqual(GetCompleteDamage(frame), margin)); |
| } |
| } |
| |
| void SetFrameTime(base::TimeTicks* result, base::TimeTicks frame_time) { |
| *result = frame_time; |
| } |
| |
| TEST_P(SurfaceTest, RequestFrameCallback) { |
| // Must be before surface so it outlives it, for surface's destructor calls |
| // SetFrameTime() referencing this. |
| base::TimeTicks frame_time; |
| |
| std::unique_ptr<Surface> surface(new Surface); |
| |
| surface->RequestFrameCallback( |
| base::BindRepeating(&SetFrameTime, base::Unretained(&frame_time))); |
| surface->Commit(); |
| |
| // Callback should not run synchronously. |
| EXPECT_TRUE(frame_time.is_null()); |
| } |
| |
| // Disabled due to flakiness: crbug.com/856145 |
| #if defined(LEAK_SANITIZER) |
| #define MAYBE_SetOpaqueRegion DISABLED_SetOpaqueRegion |
| #else |
| #define MAYBE_SetOpaqueRegion SetOpaqueRegion |
| #endif |
| TEST_P(SurfaceTest, MAYBE_SetOpaqueRegion) { |
| gfx::Size buffer_size(1, 1); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| // Attaching a buffer with alpha channel. |
| surface->Attach(buffer.get()); |
| |
| // Setting an opaque region that contains the buffer size doesn't require |
| // draw with blending. |
| surface->SetOpaqueRegion(gfx::Rect(256, 256)); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| ASSERT_EQ(1u, frame.render_pass_list.back()->quad_list.size()); |
| auto* texture_draw_quad = viz::TextureDrawQuad::MaterialCast( |
| frame.render_pass_list.back()->quad_list.back()); |
| |
| EXPECT_FALSE(texture_draw_quad->ShouldDrawWithBlending()); |
| EXPECT_EQ(SkColors::kBlack, texture_draw_quad->background_color); |
| EXPECT_EQ(gfx::Rect(buffer_size), ToTargetSpaceDamage(frame)); |
| } |
| |
| // Setting an empty opaque region requires draw with blending. |
| surface->SetOpaqueRegion(gfx::Rect()); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| ASSERT_EQ(1u, frame.render_pass_list.back()->quad_list.size()); |
| auto* texture_draw_quad = viz::TextureDrawQuad::MaterialCast( |
| frame.render_pass_list.back()->quad_list.back()); |
| EXPECT_TRUE(texture_draw_quad->ShouldDrawWithBlending()); |
| EXPECT_EQ(SkColors::kTransparent, texture_draw_quad->background_color); |
| EXPECT_EQ(gfx::Rect(buffer_size), ToTargetSpaceDamage(frame)); |
| } |
| |
| auto buffer_without_alpha = test::ExoTestHelper::CreateBuffer( |
| buffer_size, gfx::BufferFormat::RGBX_8888); |
| |
| // Attaching a buffer without an alpha channel doesn't require draw with |
| // blending. |
| surface->Attach(buffer_without_alpha.get()); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| ASSERT_EQ(1u, frame.render_pass_list.back()->quad_list.size()); |
| EXPECT_FALSE(frame.render_pass_list.back() |
| ->quad_list.back() |
| ->ShouldDrawWithBlending()); |
| EXPECT_EQ(ToPixel(gfx::Rect(0, 0, 0, 0)), GetCompleteDamage(frame)); |
| } |
| } |
| |
| TEST_P(SurfaceTest, SetInputRegion) { |
| // Create a shell surface which size is 512x512. |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| gfx::Size buffer_size(512, 512); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| surface->Attach(buffer.get()); |
| surface->Commit(); |
| |
| { |
| // Default input region should match surface bounds. |
| auto rects = GetHitTestShapeRects(surface.get()); |
| ASSERT_TRUE(rects); |
| ASSERT_EQ(1u, rects->size()); |
| ASSERT_EQ(gfx::Rect(512, 512), (*rects)[0]); |
| } |
| |
| { |
| // Setting a non-empty input region should succeed. |
| surface->SetInputRegion(gfx::Rect(256, 256)); |
| surface->Commit(); |
| |
| auto rects = GetHitTestShapeRects(surface.get()); |
| ASSERT_TRUE(rects); |
| ASSERT_EQ(1u, rects->size()); |
| ASSERT_EQ(gfx::Rect(256, 256), (*rects)[0]); |
| } |
| |
| { |
| // Setting an empty input region should succeed. |
| surface->SetInputRegion(gfx::Rect()); |
| surface->Commit(); |
| |
| EXPECT_FALSE(GetHitTestShapeRects(surface.get())); |
| } |
| |
| { |
| cc::Region region = gfx::Rect(512, 512); |
| region.Subtract(gfx::Rect(0, 64, 64, 64)); |
| region.Subtract(gfx::Rect(88, 88, 12, 55)); |
| region.Subtract(gfx::Rect(100, 0, 33, 66)); |
| |
| // Setting a non-rectangle input region should succeed. |
| surface->SetInputRegion(region); |
| surface->Commit(); |
| |
| auto rects = GetHitTestShapeRects(surface.get()); |
| ASSERT_TRUE(rects); |
| ASSERT_EQ(10u, rects->size()); |
| cc::Region result; |
| for (const auto& r : *rects) |
| result.Union(r); |
| ASSERT_EQ(result, region); |
| } |
| |
| { |
| // Input region should be clipped to surface bounds. |
| surface->SetInputRegion(gfx::Rect(-50, -50, 1000, 100)); |
| surface->Commit(); |
| |
| auto rects = GetHitTestShapeRects(surface.get()); |
| ASSERT_TRUE(rects); |
| ASSERT_EQ(1u, rects->size()); |
| ASSERT_EQ(gfx::Rect(512, 50), (*rects)[0]); |
| } |
| |
| { |
| // Hit test region should accumulate input regions of sub-surfaces. |
| gfx::Rect input_rect(50, 50, 100, 100); |
| surface->SetInputRegion(input_rect); |
| |
| gfx::Rect child_input_rect(-50, -50, 1000, 100); |
| auto child_buffer = |
| test::ExoTestHelper::CreateBuffer(child_input_rect.size()); |
| auto child_surface = std::make_unique<Surface>(); |
| auto sub_surface = |
| std::make_unique<SubSurface>(child_surface.get(), surface.get()); |
| sub_surface->SetPosition(gfx::PointF(child_input_rect.origin())); |
| child_surface->Attach(child_buffer.get()); |
| child_surface->Commit(); |
| surface->Commit(); |
| |
| auto rects = GetHitTestShapeRects(surface.get()); |
| ASSERT_TRUE(rects); |
| ASSERT_EQ(2u, rects->size()); |
| cc::Region result = cc::UnionRegions((*rects)[0], (*rects)[1]); |
| ASSERT_EQ(cc::UnionRegions(input_rect, child_input_rect), result); |
| } |
| } |
| |
| TEST_P(SurfaceTest, SetBufferScale) { |
| gfx::Size buffer_size(512, 512); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| // This will update the bounds of the surface and take the buffer scale into |
| // account. |
| const float kBufferScale = 2.0f; |
| surface->Attach(buffer.get()); |
| surface->SetBufferScale(kBufferScale); |
| surface->Commit(); |
| EXPECT_EQ( |
| gfx::ScaleToFlooredSize(buffer_size, 1.0f / kBufferScale).ToString(), |
| surface->window()->bounds().size().ToString()); |
| gfx::SizeF buffer_size_float = gfx::SizeF(buffer_size); |
| buffer_size_float.Scale(1.0f / kBufferScale); |
| EXPECT_EQ(buffer_size_float.ToString(), surface->content_size().ToString()); |
| |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| const viz::CompositorFrame& frame = GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| EXPECT_EQ(ToPixel(gfx::Rect(0, 0, 256, 256)), GetCompleteDamage(frame)); |
| } |
| |
| void SurfaceTest::SetBufferTransformHelperTransformAndTest( |
| Surface* surface, |
| ShellSurface* shell_surface, |
| Transform transform, |
| const gfx::Size& expected_size) { |
| std::stringstream scoped_trace_message; |
| scoped_trace_message << "SetBufferTransformHelperTransformAndTest(" |
| << "transform=" << TransformToString(transform) << ")"; |
| SCOPED_TRACE(scoped_trace_message.str()); |
| |
| surface->SetBufferTransform(transform); |
| surface->Commit(); |
| EXPECT_EQ(gfx::Size(expected_size.width(), expected_size.height()), |
| surface->window()->bounds().size()); |
| EXPECT_EQ(gfx::SizeF(expected_size.width(), expected_size.height()), |
| surface->content_size()); |
| |
| test::WaitForLastFrameAck(shell_surface); |
| |
| { |
| const viz::CompositorFrame& frame = GetFrameFromSurface(shell_surface); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| EXPECT_EQ( |
| ToPixel(gfx::Rect(0, 0, expected_size.width(), expected_size.height())), |
| GetCompleteDamage(frame)); |
| const auto& quad_list = frame.render_pass_list[0]->quad_list; |
| ASSERT_EQ(1u, quad_list.size()); |
| EXPECT_EQ( |
| ToPixel(gfx::Rect(0, 0, 512, 256)), |
| cc::MathUtil::MapEnclosingClippedRect( |
| quad_list.front()->shared_quad_state->quad_to_target_transform, |
| quad_list.front()->rect)); |
| } |
| } |
| |
| // Disabled due to flakiness: crbug.com/856145 |
| #if defined(LEAK_SANITIZER) |
| #define MAYBE_SetBufferTransform DISABLED_SetBufferTransform |
| #else |
| #define MAYBE_SetBufferTransform SetBufferTransform |
| #endif |
| TEST_P(SurfaceTest, MAYBE_SetBufferTransform) { |
| gfx::Size buffer_size(256, 512); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| // This will update the bounds of the surface and take the buffer transform |
| // into account. |
| surface->Attach(buffer.get()); |
| |
| gfx::Size inverted_size(buffer_size.height(), buffer_size.width()); |
| |
| SetBufferTransformHelperTransformAndTest(surface.get(), shell_surface.get(), |
| Transform::ROTATE_90, inverted_size); |
| |
| SetBufferTransformHelperTransformAndTest(surface.get(), shell_surface.get(), |
| Transform::FLIPPED_ROTATE_90, |
| inverted_size); |
| |
| gfx::Size child_buffer_size(64, 128); |
| auto child_buffer = test::ExoTestHelper::CreateBuffer(child_buffer_size); |
| auto child_surface = std::make_unique<Surface>(); |
| auto sub_surface = |
| std::make_unique<SubSurface>(child_surface.get(), surface.get()); |
| |
| // Set position to 20, 10. |
| gfx::PointF child_position(20, 10); |
| sub_surface->SetPosition(child_position); |
| |
| child_surface->Attach(child_buffer.get()); |
| child_surface->SetBufferTransform(Transform::ROTATE_180); |
| const int kChildBufferScale = 2; |
| child_surface->SetBufferScale(kChildBufferScale); |
| child_surface->Commit(); |
| surface->Commit(); |
| EXPECT_EQ( |
| gfx::ScaleToRoundedSize(child_buffer_size, 1.0f / kChildBufferScale), |
| child_surface->window()->bounds().size()); |
| EXPECT_EQ( |
| gfx::ScaleToRoundedSize(child_buffer_size, 1.0f / kChildBufferScale), |
| gfx::ToRoundedSize(child_surface->content_size())); |
| |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| const auto& quad_list = frame.render_pass_list[0]->quad_list; |
| ASSERT_EQ(2u, quad_list.size()); |
| EXPECT_EQ( |
| ToPixel(gfx::Rect(gfx::ToRoundedPoint(child_position), |
| gfx::ScaleToRoundedSize(child_buffer_size, |
| 1.0f / kChildBufferScale))), |
| cc::MathUtil::MapEnclosingClippedRect( |
| quad_list.front()->shared_quad_state->quad_to_target_transform, |
| quad_list.front()->rect)); |
| } |
| } |
| |
| TEST_P(SurfaceTest, MirrorLayers) { |
| gfx::Size buffer_size(512, 512); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| surface->Attach(buffer.get()); |
| surface->Commit(); |
| |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| EXPECT_EQ(buffer_size, surface->window()->bounds().size()); |
| EXPECT_EQ(buffer_size, surface->window()->layer()->bounds().size()); |
| std::unique_ptr<ui::LayerTreeOwner> old_layer_owner = |
| ::wm::MirrorLayers(shell_surface->host_window(), false /* sync_bounds */); |
| EXPECT_EQ(buffer_size, surface->window()->bounds().size()); |
| EXPECT_EQ(buffer_size, surface->window()->layer()->bounds().size()); |
| EXPECT_EQ(buffer_size, old_layer_owner->root()->bounds().size()); |
| EXPECT_TRUE(shell_surface->host_window()->layer()->has_external_content()); |
| EXPECT_TRUE(old_layer_owner->root()->has_external_content()); |
| } |
| |
| TEST_P(SurfaceTest, SetViewport) { |
| gfx::Size buffer_size(1, 1); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| // This will update the bounds of the surface and take the viewport into |
| // account. |
| surface->Attach(buffer.get()); |
| gfx::SizeF viewport(256, 256); |
| surface->SetViewport(viewport); |
| surface->Commit(); |
| EXPECT_EQ(viewport.ToString(), surface->content_size().ToString()); |
| |
| // This will update the bounds of the surface and take the viewport2 into |
| // account. |
| gfx::SizeF viewport2(512, 512); |
| surface->SetViewport(viewport2); |
| surface->Commit(); |
| EXPECT_EQ(viewport2.ToString(), |
| gfx::SizeF(surface->window()->bounds().size()).ToString()); |
| EXPECT_EQ(viewport2.ToString(), surface->content_size().ToString()); |
| |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| const viz::CompositorFrame& frame = GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| EXPECT_EQ(ToPixel(gfx::Rect(0, 0, 512, 512)), GetCompleteDamage(frame)); |
| |
| // This will make the surface have no content regardless of the viewport. |
| surface->Attach(nullptr); |
| surface->Commit(); |
| EXPECT_TRUE(surface->content_size().IsEmpty()); |
| } |
| |
| TEST_P(SurfaceTest, SubpixelCoordinate) { |
| gfx::Size buffer_size(512, 512); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| // This will update the bounds of the surface and take the buffer transform |
| // into account. |
| surface->Attach(buffer.get()); |
| |
| gfx::Size inverted_size(buffer_size.height(), buffer_size.width()); |
| |
| gfx::Size child_buffer_size(64, 64); |
| auto child_buffer = test::ExoTestHelper::CreateBuffer(child_buffer_size); |
| auto child_surface = std::make_unique<Surface>(); |
| auto sub_surface = |
| std::make_unique<SubSurface>(child_surface.get(), surface.get()); |
| |
| gfx::Transform device_scale_transform; |
| device_scale_transform.Scale(1.f / device_scale_factor(), |
| 1.f / device_scale_factor()); |
| |
| child_surface->Attach(child_buffer.get()); |
| |
| // These rects are in pixel coordinates with some having subpixel coordinates. |
| gfx::RectF kTestRects[] = { |
| gfx::RectF(10, 20, 30, 40), gfx::RectF(11, 22, 33, 44), |
| gfx::RectF(10.5, 20, 30, 40), gfx::RectF(10, 20.5, 30, 40), |
| gfx::RectF(10, 20, 30.5, 40), gfx::RectF(10, 20, 30, 40.5), |
| gfx::RectF(10.5, 20, 30, 40.5), gfx::RectF(10.5, 20.5, 30, 40)}; |
| bool kExpectedAligned[] = {true, true, false, false, |
| false, false, false, false}; |
| static_assert(std::size(kTestRects) == std::size(kExpectedAligned), |
| "Number of elements in each list should be the identical."); |
| for (int j = 0; j < 2; j++) { |
| const bool kTestCaseRotation = (j == 1); |
| for (size_t i = 0; i < std::size(kTestRects); i++) { |
| auto rect_in_dip = device_scale_transform.MapRect(kTestRects[i]); |
| sub_surface->SetPosition(rect_in_dip.origin()); |
| child_surface->SetViewport(rect_in_dip.size()); |
| const int kChildBufferScale = 2; |
| child_surface->SetBufferScale(kChildBufferScale); |
| if (kTestCaseRotation) { |
| child_surface->SetBufferTransform(Transform::ROTATE_90); |
| } |
| child_surface->Commit(); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| const auto& quad_list = frame.render_pass_list[0]->quad_list; |
| ASSERT_EQ(2u, quad_list.size()); |
| auto transform = |
| quad_list.front()->shared_quad_state->quad_to_target_transform; |
| auto rect = transform.MapRect(gfx::RectF(quad_list.front()->rect)); |
| if (kExpectedAligned[i] && !kTestCaseRotation) { |
| // A transformed rect cannot express a rotation. |
| // Manipulation of texture coordinates, in addition to a transformed |
| // rect, can represent flip/mirror but only as two uv points and not as |
| // a uv rect. |
| auto* tex_draw_quad = |
| viz::TextureDrawQuad::MaterialCast(quad_list.front()); |
| EXPECT_POINTF_NEAR(tex_draw_quad->uv_top_left, gfx::PointF(0, 0), |
| 0.001f); |
| EXPECT_POINTF_NEAR(tex_draw_quad->uv_bottom_right, gfx::PointF(1, 1), |
| 0.001f); |
| EXPECT_EQ(gfx::Transform(), transform); |
| EXPECT_EQ(kTestRects[i], rect); |
| } else { |
| EXPECT_EQ(gfx::Rect(1, 1), quad_list.front()->rect); |
| // Subpixel quads have non identity transforms and due to floating point |
| // math can only be approximately compared. |
| EXPECT_NEAR(kTestRects[i].x(), rect.x(), 0.001f); |
| EXPECT_NEAR(kTestRects[i].y(), rect.y(), 0.001f); |
| EXPECT_NEAR(kTestRects[i].width(), rect.width(), 0.001f); |
| EXPECT_NEAR(kTestRects[i].height(), rect.height(), 0.001f); |
| } |
| } |
| } |
| } |
| |
| TEST_P(SurfaceTest, SetCrop) { |
| gfx::Size buffer_size(16, 16); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| surface->Attach(buffer.get()); |
| gfx::Size crop_size(12, 12); |
| surface->SetCrop(gfx::RectF(gfx::PointF(2.0, 2.0), gfx::SizeF(crop_size))); |
| surface->Commit(); |
| EXPECT_EQ(crop_size.ToString(), |
| surface->window()->bounds().size().ToString()); |
| EXPECT_EQ(gfx::SizeF(crop_size).ToString(), |
| surface->content_size().ToString()); |
| |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| const viz::CompositorFrame& frame = GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| EXPECT_EQ(ToPixel(gfx::Rect(0, 0, 12, 12)), GetCompleteDamage(frame)); |
| |
| // This will make the surface have no content regardless of the crop. |
| surface->Attach(nullptr); |
| surface->Commit(); |
| EXPECT_TRUE(surface->content_size().IsEmpty()); |
| } |
| |
| void SurfaceTest::SetCropAndBufferTransformHelperTransformAndTest( |
| Surface* surface, |
| ShellSurface* shell_surface, |
| Transform transform, |
| const gfx::RectF& expected_rect, |
| bool has_viewport) { |
| const gfx::Rect target_with_no_viewport(ToPixel(gfx::Rect(gfx::Size(52, 4)))); |
| const gfx::Rect target_with_viewport(ToPixel(gfx::Rect(gfx::Size(128, 64)))); |
| |
| std::stringstream scoped_trace_message; |
| scoped_trace_message << "SetCropAndBufferTransformHelperTransformAndTest(" |
| << "transform=" << TransformToString(transform) |
| << ", has_viewport=" |
| << ((has_viewport) ? "true" : "false") << ")"; |
| SCOPED_TRACE(scoped_trace_message.str()); |
| |
| surface->SetBufferTransform(transform); |
| surface->Commit(); |
| |
| test::WaitForLastFrameAck(shell_surface); |
| |
| { |
| const viz::CompositorFrame& frame = GetFrameFromSurface(shell_surface); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| const viz::QuadList& quad_list = frame.render_pass_list[0]->quad_list; |
| ASSERT_EQ(1u, quad_list.size()); |
| const viz::TextureDrawQuad* quad = |
| viz::TextureDrawQuad::MaterialCast(quad_list.front()); |
| EXPECT_EQ(expected_rect.origin(), quad->uv_top_left); |
| EXPECT_EQ(expected_rect.bottom_right(), quad->uv_bottom_right); |
| EXPECT_EQ( |
| (has_viewport) ? target_with_viewport : target_with_no_viewport, |
| cc::MathUtil::MapEnclosingClippedRect( |
| quad->shared_quad_state->quad_to_target_transform, quad->rect)); |
| } |
| } |
| |
| // Disabled due to flakiness: crbug.com/856145 |
| #if defined(LEAK_SANITIZER) |
| #define MAYBE_SetCropAndBufferTransform DISABLED_SetCropAndBufferTransform |
| #else |
| #define MAYBE_SetCropAndBufferTransform SetCropAndBufferTransform |
| #endif |
| TEST_P(SurfaceTest, MAYBE_SetCropAndBufferTransform) { |
| gfx::Size buffer_size(128, 64); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| surface->Attach(buffer.get()); |
| gfx::Size crop_size(52, 4); |
| gfx::Point crop_origin(4, 12); |
| |
| gfx::Rect crop_rect(crop_origin, crop_size); |
| |
| // These rects represent the left, right, top, bottom values of the crop rect |
| // normalized from the buffer size for each transformation. |
| static constexpr SkRect crop_0 = |
| SkRect::MakeLTRB(0.03125f, 0.1875f, 0.4375f, 0.25f); |
| static constexpr SkRect crop_90 = |
| SkRect::MakeLTRB(0.875f, 0.0625f, 0.90625f, 0.875f); |
| static constexpr SkRect crop_180 = |
| SkRect::MakeLTRB(0.5625f, 0.75f, 0.96875f, 0.8125f); |
| static constexpr SkRect crop_270 = |
| SkRect::MakeLTRB(0.09375f, 0.125f, 0.125f, 0.9375f); |
| static constexpr SkRect flipped_crop_0 = |
| SkRect::MakeLTRB(0.5625f, 0.1875f, 0.96875f, 0.25f); |
| static constexpr SkRect flipped_crop_90 = |
| SkRect::MakeLTRB(0.09375f, 0.0625f, 0.125f, 0.875f); |
| static constexpr SkRect flipped_crop_180 = |
| SkRect::MakeLTRB(0.03125f, 0.75f, 0.4375f, 0.8125f); |
| static constexpr SkRect flipped_crop_270 = |
| SkRect::MakeLTRB(0.875f, 0.125f, 0.90625f, 0.9375f); |
| |
| surface->SetCrop(gfx::RectF(gfx::PointF(crop_origin), gfx::SizeF(crop_size))); |
| |
| struct TransformTestcase { |
| Transform transform; |
| const raw_ref<const SkRect> expected_rect; |
| |
| constexpr TransformTestcase(Transform transform_in, |
| const SkRect& expected_rect_in) |
| : transform(transform_in), expected_rect(expected_rect_in) {} |
| }; |
| |
| constexpr std::array<TransformTestcase, 8> testcases{ |
| TransformTestcase(Transform::NORMAL, crop_0), |
| TransformTestcase(Transform::ROTATE_90, crop_90), |
| TransformTestcase(Transform::ROTATE_180, crop_180), |
| TransformTestcase(Transform::ROTATE_270, crop_270), |
| TransformTestcase(Transform::FLIPPED, flipped_crop_0), |
| TransformTestcase(Transform::FLIPPED_ROTATE_90, flipped_crop_90), |
| TransformTestcase(Transform::FLIPPED_ROTATE_180, flipped_crop_180), |
| TransformTestcase(Transform::FLIPPED_ROTATE_270, flipped_crop_270)}; |
| |
| for (const auto& tc : testcases) { |
| SetCropAndBufferTransformHelperTransformAndTest( |
| surface.get(), shell_surface.get(), tc.transform, |
| gfx::SkRectToRectF(*tc.expected_rect), false); |
| } |
| |
| surface->SetViewport(gfx::SizeF(128, 64)); |
| |
| for (const auto& tc : testcases) { |
| SetCropAndBufferTransformHelperTransformAndTest( |
| surface.get(), shell_surface.get(), tc.transform, |
| gfx::SkRectToRectF(*tc.expected_rect), true); |
| } |
| } |
| |
| TEST_P(SurfaceTest, SetBlendMode) { |
| gfx::Size buffer_size(1, 1); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| surface->Attach(buffer.get()); |
| surface->SetBlendMode(SkBlendMode::kSrc); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| const viz::CompositorFrame& frame = GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| ASSERT_EQ(1u, frame.render_pass_list.back()->quad_list.size()); |
| EXPECT_FALSE(frame.render_pass_list.back() |
| ->quad_list.back() |
| ->ShouldDrawWithBlending()); |
| } |
| |
| TEST_P(SurfaceTest, OverlayCandidate) { |
| gfx::Size buffer_size(1, 1); |
| auto buffer = test::ExoTestHelper::CreateBuffer( |
| buffer_size, gfx::BufferFormat::RGBA_8888, |
| /*is_overlay_candidate=*/true); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| surface->Attach(buffer.get()); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| const viz::CompositorFrame& frame = GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| ASSERT_EQ(1u, frame.render_pass_list.back()->quad_list.size()); |
| viz::DrawQuad* draw_quad = frame.render_pass_list.back()->quad_list.back(); |
| ASSERT_EQ(viz::DrawQuad::Material::kTextureContent, draw_quad->material); |
| } |
| |
| TEST_P(SurfaceTest, SetAlpha) { |
| gfx::Size buffer_size(1, 1); |
| auto buffer = test::ExoTestHelper::CreateBuffer( |
| buffer_size, gfx::BufferFormat::RGBA_8888, |
| /*is_overlay_candidate=*/true); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| { |
| surface->Attach(buffer.get()); |
| surface->SetAlpha(0.5f); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| ASSERT_EQ(1u, frame.render_pass_list.back()->quad_list.size()); |
| ASSERT_EQ(1u, frame.resource_list.size()); |
| ASSERT_EQ(viz::ResourceId(1u), frame.resource_list.back().id); |
| EXPECT_EQ(gfx::Rect(buffer_size), ToTargetSpaceDamage(frame)); |
| } |
| |
| { |
| surface->SetAlpha(0.f); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| // We always need to submit surface resources because we have created shared |
| // images that have release callbacks that will only fire when releasing a |
| // compositor frame. |
| ASSERT_EQ(1u, frame.resource_list.size()); |
| ASSERT_EQ(0u, frame.render_pass_list.back()->quad_list.size()); |
| EXPECT_EQ(gfx::Rect(buffer_size), ToTargetSpaceDamage(frame)); |
| } |
| |
| { |
| surface->SetAlpha(1.f); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| ASSERT_EQ(1u, frame.render_pass_list.back()->quad_list.size()); |
| ASSERT_EQ(1u, frame.resource_list.size()); |
| // The resource should be updated again, the id should be changed. |
| ASSERT_EQ(viz::ResourceId(2u), frame.resource_list.back().id); |
| EXPECT_EQ(gfx::Rect(buffer_size), ToTargetSpaceDamage(frame)); |
| } |
| } |
| |
| // TODO(crbug.com/369003507): This unit test is checking |
| // temporarily disable non YUV overlays on hatch devices |
| TEST_P(SurfaceTest, DisableNonYUVOverlays) { |
| gfx::Size buffer_size(2, 2); |
| auto buffer_non_yuv = test::ExoTestHelper::CreateBuffer( |
| buffer_size, gfx::BufferFormat::RGBA_8888, /*is_overlay_candidate=*/true); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| base::test::ScopedChromeOSVersionInfo version_info( |
| "CHROMEOS_RELEASE_BOARD=DRALLION\n", base::Time()); |
| |
| { |
| surface->Attach(buffer_non_yuv.get()); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| EXPECT_EQ(1u, frame.render_pass_list.size()); |
| EXPECT_EQ(1u, frame.render_pass_list.back()->quad_list.size()); |
| viz::DrawQuad* draw_quad = frame.render_pass_list.back()->quad_list.back(); |
| EXPECT_EQ(viz::DrawQuad::Material::kTextureContent, draw_quad->material); |
| EXPECT_EQ( |
| viz::OverlayPriority::kLow, |
| viz::TextureDrawQuad::MaterialCast(draw_quad)->overlay_priority_hint); |
| } |
| } |
| |
| TEST_P(SurfaceTest, ForceRgbxTest) { |
| gfx::Size buffer_size(1, 1); |
| auto buffer = test::ExoTestHelper::CreateBuffer( |
| buffer_size, gfx::BufferFormat::RGBA_8888, |
| /*is_overlay_candidate=*/true); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| { |
| surface->Attach(buffer.get()); |
| // Blend mode 'kSrc' will result in an opaque surface. |
| surface->SetBlendMode(SkBlendMode::kSrc); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| ASSERT_EQ(1u, frame.render_pass_list.back()->quad_list.size()); |
| ASSERT_EQ(1u, frame.resource_list.size()); |
| ASSERT_EQ(viz::ResourceId(1u), frame.resource_list.back().id); |
| EXPECT_EQ(gfx::Rect(buffer_size), ToTargetSpaceDamage(frame)); |
| auto& quad_list = frame.render_pass_list.back()->quad_list; |
| auto* texture_quad = quad_list.front()->DynamicCast<viz::TextureDrawQuad>(); |
| ASSERT_TRUE(texture_quad); |
| ASSERT_TRUE(texture_quad->force_rgbx); |
| } |
| } |
| |
| TEST_P(SurfaceTest, ForceRgbxTestNoBufferAlpha) { |
| gfx::Size buffer_size(1, 1); |
| auto buffer = test::ExoTestHelper::CreateBuffer( |
| buffer_size, gfx::BufferFormat::RGBX_8888, |
| /*is_overlay_candidate=*/true); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| { |
| surface->Attach(buffer.get()); |
| // Blend mode 'kSrc' will result in an opaque surface. |
| surface->SetBlendMode(SkBlendMode::kSrc); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(1u, frame.render_pass_list.size()); |
| ASSERT_EQ(1u, frame.render_pass_list.back()->quad_list.size()); |
| ASSERT_EQ(1u, frame.resource_list.size()); |
| ASSERT_EQ(viz::ResourceId(1u), frame.resource_list.back().id); |
| EXPECT_EQ(gfx::Rect(buffer_size), ToTargetSpaceDamage(frame)); |
| auto& quad_list = frame.render_pass_list.back()->quad_list; |
| auto* texture_quad = quad_list.front()->DynamicCast<viz::TextureDrawQuad>(); |
| ASSERT_TRUE(texture_quad); |
| ASSERT_FALSE(texture_quad->force_rgbx); |
| } |
| } |
| |
| TEST_P(SurfaceTest, ColorBufferAlpha) { |
| gfx::Size buffer_size(1, 1); |
| constexpr SkColor4f kBuffColorExpected[] = {{1.f, 128.0f / 255.0f, 0.f, 1.f}, |
| {0.f, 128.0f / 255.0f, 1.f, 0.f}}; |
| constexpr bool kExpectedOpaque[] = {true, false}; |
| for (size_t i = 0; i < std::size(kBuffColorExpected); i++) { |
| auto buffer = |
| std::make_unique<SolidColorBuffer>(kBuffColorExpected[i], buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| surface->Attach(buffer.get()); |
| surface->SetAlpha(1.0f); |
| |
| { |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| EXPECT_EQ(1u, frame.render_pass_list.size()); |
| EXPECT_EQ(1u, frame.render_pass_list.back()->quad_list.size()); |
| EXPECT_EQ(0u, frame.resource_list.size()); |
| auto* draw_quad = frame.render_pass_list.back()->quad_list.back(); |
| EXPECT_EQ(viz::DrawQuad::Material::kSolidColor, draw_quad->material); |
| EXPECT_EQ(kExpectedOpaque[i], |
| draw_quad->shared_quad_state->are_contents_opaque); |
| auto* solid_color_quad = viz::SolidColorDrawQuad::MaterialCast(draw_quad); |
| EXPECT_EQ(kBuffColorExpected[i], solid_color_quad->color); |
| } |
| } |
| } |
| |
| TEST_P(SurfaceTest, Commit) { |
| std::unique_ptr<Surface> surface(new Surface); |
| |
| // Calling commit without a buffer should succeed. |
| surface->Commit(); |
| } |
| |
| TEST_P(SurfaceTest, RemoveSubSurface) { |
| gfx::Size buffer_size(256, 256); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| std::unique_ptr<Surface> surface(new Surface); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| surface->Attach(buffer.get()); |
| |
| // Create a subsurface: |
| gfx::Size child_buffer_size(64, 128); |
| auto child_buffer = test::ExoTestHelper::CreateBuffer(child_buffer_size); |
| auto child_surface = std::make_unique<Surface>(); |
| auto sub_surface = |
| std::make_unique<SubSurface>(child_surface.get(), surface.get()); |
| sub_surface->SetPosition(gfx::PointF(20, 10)); |
| child_surface->Attach(child_buffer.get()); |
| child_surface->Commit(); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| // Remove the subsurface by destroying it. This should not damage |surface|. |
| // TODO(penghuang): Make the damage more precise for sub surface changes. |
| // https://crbug.com/779704 |
| sub_surface.reset(); |
| EXPECT_FALSE(surface->HasPendingDamageForTesting(gfx::Rect(20, 10, 64, 128))); |
| } |
| |
| TEST_P(SurfaceTest, DestroyAttachedBuffer) { |
| gfx::Size buffer_size(1, 1); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| surface->Attach(buffer.get()); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| // Make sure surface size is still valid after buffer is destroyed. |
| buffer.reset(); |
| surface->Commit(); |
| EXPECT_FALSE(surface->content_size().IsEmpty()); |
| } |
| |
| TEST_P(SurfaceTest, SetClientSurfaceId) { |
| auto surface = std::make_unique<Surface>(); |
| const std::string kTestId = "42"; |
| |
| surface->SetClientSurfaceId(kTestId.c_str()); |
| EXPECT_EQ(kTestId, surface->GetClientSurfaceId()); |
| } |
| |
| TEST_P(SurfaceTest, DestroyWithAttachedBufferReleasesBuffer) { |
| gfx::Size buffer_size(1, 1); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| int release_buffer_call_count = 0; |
| base::RunLoop run_loop; |
| buffer->set_release_callback(test::CreateReleaseBufferClosure( |
| &release_buffer_call_count, run_loop.QuitClosure())); |
| |
| surface->Attach(buffer.get()); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| // Buffer is still attached at this point. |
| EXPECT_EQ(0, release_buffer_call_count); |
| |
| // After the surface is destroyed, we should get a release event for the |
| // attached buffer. |
| shell_surface.reset(); |
| surface.reset(); |
| run_loop.Run(); |
| ASSERT_EQ(1, release_buffer_call_count); |
| } |
| |
| TEST_P(SurfaceTest, AcquireFence) { |
| auto buffer = test::ExoTestHelper::CreateBuffer(gfx::Size(1, 1)); |
| auto surface = std::make_unique<Surface>(); |
| |
| // We can only commit an acquire fence if a buffer is attached. |
| surface->Attach(buffer.get()); |
| |
| EXPECT_FALSE(surface->HasPendingAcquireFence()); |
| surface->SetAcquireFence( |
| std::make_unique<gfx::GpuFence>(gfx::GpuFenceHandle())); |
| EXPECT_TRUE(surface->HasPendingAcquireFence()); |
| surface->Commit(); |
| EXPECT_FALSE(surface->HasPendingAcquireFence()); |
| } |
| |
| TEST_P(SurfaceTest, UpdatesOcclusionOnDestroyingSubsurface) { |
| gfx::Size buffer_size(256, 512); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| surface->Attach(buffer.get()); |
| surface->Commit(); |
| |
| gfx::Size child_buffer_size(64, 128); |
| auto child_buffer = test::ExoTestHelper::CreateBuffer(child_buffer_size); |
| auto child_surface = std::make_unique<Surface>(); |
| auto sub_surface = |
| std::make_unique<SubSurface>(child_surface.get(), surface.get()); |
| child_surface->Attach(child_buffer.get()); |
| // Turn on occlusion tracking. |
| child_surface->SetOcclusionTracking(true); |
| child_surface->Commit(); |
| surface->Commit(); |
| |
| SurfaceObserverForTest observer( |
| child_surface.get()->window()->GetOcclusionState()); |
| ScopedSurface scoped_child_surface(child_surface.get(), &observer); |
| |
| // Destroy the subsurface and expect to get an occlusion update. |
| sub_surface.reset(); |
| EXPECT_EQ(1, observer.num_occlusion_changes()); |
| EXPECT_EQ(aura::Window::OcclusionState::HIDDEN, |
| child_surface->window()->GetOcclusionState()); |
| } |
| |
| TEST_P(SurfaceTest, OcclusionNotRecomputedOnWidgetCommit) { |
| constexpr gfx::Size kBufferSize(32, 32); |
| auto shell_surface = |
| test::ShellSurfaceBuilder(kBufferSize).BuildShellSurface(); |
| auto* surface = shell_surface->root_surface(); |
| |
| // Turn on occlusion tracking. |
| surface->SetOcclusionTracking(true); |
| surface->Commit(); |
| |
| // Commit the surface with no changes and expect not to get an occlusion |
| // update. |
| aura::test::WindowOcclusionTrackerTestApi window_occlusion_tracker_test_api( |
| aura::Env::GetInstance()->GetWindowOcclusionTracker()); |
| const int num_times_occlusion_recomputed = |
| window_occlusion_tracker_test_api.GetNumTimesOcclusionRecomputed(); |
| surface->Commit(); |
| EXPECT_EQ(num_times_occlusion_recomputed, |
| window_occlusion_tracker_test_api.GetNumTimesOcclusionRecomputed()); |
| |
| // Set a non-null alpha shape and make sure occlusion is recomputed. |
| shell_surface->SetShape(cc::Region(gfx::Rect(0, 0, 24, 24))); |
| surface->Commit(); |
| EXPECT_EQ(num_times_occlusion_recomputed + 1, |
| window_occlusion_tracker_test_api.GetNumTimesOcclusionRecomputed()); |
| } |
| |
| TEST_P(SurfaceTest, HasPendingPerCommitBufferReleaseCallback) { |
| auto buffer = test::ExoTestHelper::CreateBuffer(gfx::Size(1, 1)); |
| auto surface = std::make_unique<Surface>(); |
| |
| // We can only commit a buffer release callback if a buffer is attached. |
| surface->Attach(buffer.get()); |
| |
| EXPECT_FALSE(surface->HasPendingPerCommitBufferReleaseCallback()); |
| surface->SetPerCommitBufferReleaseCallback( |
| base::BindOnce([](gfx::GpuFenceHandle) {})); |
| EXPECT_TRUE(surface->HasPendingPerCommitBufferReleaseCallback()); |
| surface->Commit(); |
| EXPECT_FALSE(surface->HasPendingPerCommitBufferReleaseCallback()); |
| } |
| |
| TEST_P(SurfaceTest, PerCommitBufferReleaseCallbackForSameSurface) { |
| gfx::Size buffer_size(64, 64); |
| auto buffer1 = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto buffer2 = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| int per_commit_release_count = 0; |
| |
| // Set the release callback that will be run when buffer is no longer in use. |
| int buffer_release_count = 0; |
| base::RunLoop run_loop1; |
| buffer1->set_release_callback(test::CreateReleaseBufferClosure( |
| &buffer_release_count, run_loop1.QuitClosure())); |
| |
| base::RunLoop run_loop2; |
| surface->SetPerCommitBufferReleaseCallback( |
| test::CreateExplicitReleaseCallback(&per_commit_release_count, |
| run_loop2.QuitClosure())); |
| surface->Attach(buffer1.get()); |
| surface->Damage(gfx::Rect(buffer_size)); |
| surface->Commit(); |
| test::WaitForLastFramePresentation(shell_surface.get()); |
| EXPECT_EQ(per_commit_release_count, 0); |
| EXPECT_EQ(buffer_release_count, 0); |
| |
| // Attaching the same buffer causes the per-commit callback to be emitted. |
| surface->SetPerCommitBufferReleaseCallback( |
| test::CreateExplicitReleaseCallback(&per_commit_release_count, |
| base::DoNothing())); |
| surface->Attach(buffer1.get()); |
| surface->Damage(gfx::Rect(buffer_size)); |
| surface->Commit(); |
| test::WaitForLastFramePresentation(shell_surface.get()); |
| |
| run_loop2.Run(); |
| EXPECT_EQ(per_commit_release_count, 1); |
| EXPECT_EQ(buffer_release_count, 0); |
| |
| // Attaching a different buffer causes the per-commit callback to be emitted. |
| surface->Attach(buffer2.get()); |
| surface->Damage(gfx::Rect(buffer_size)); |
| surface->Commit(); |
| test::WaitForLastFramePresentation(shell_surface.get()); |
| |
| run_loop1.Run(); |
| EXPECT_EQ(per_commit_release_count, 2); |
| // The buffer should now be completely released. |
| EXPECT_EQ(buffer_release_count, 1); |
| } |
| |
| TEST_P(SurfaceTest, PerCommitBufferReleaseCallbackForDifferentSurfaces) { |
| gfx::Size buffer_size(64, 64); |
| auto buffer1 = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto buffer2 = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface1 = std::make_unique<Surface>(); |
| auto shell_surface1 = std::make_unique<ShellSurface>(surface1.get()); |
| auto surface2 = std::make_unique<Surface>(); |
| auto shell_surface2 = std::make_unique<ShellSurface>(surface2.get()); |
| int per_commit_release_count1 = 0; |
| int per_commit_release_count2 = 0; |
| |
| // Set the release callback that will be run when buffer is no longer in use. |
| int buffer_release_count = 0; |
| base::RunLoop run_loop1; |
| buffer1->set_release_callback(test::CreateReleaseBufferClosure( |
| &buffer_release_count, run_loop1.QuitClosure())); |
| |
| // Attach buffer1 to both surface1 and surface2. |
| base::RunLoop run_loop2; |
| surface1->SetPerCommitBufferReleaseCallback( |
| test::CreateExplicitReleaseCallback(&per_commit_release_count1, |
| run_loop2.QuitClosure())); |
| surface1->Attach(buffer1.get()); |
| surface1->Damage(gfx::Rect(buffer_size)); |
| surface1->Commit(); |
| surface2->SetPerCommitBufferReleaseCallback( |
| test::CreateExplicitReleaseCallback(&per_commit_release_count2, |
| base::DoNothing())); |
| surface2->Attach(buffer1.get()); |
| surface2->Damage(gfx::Rect(buffer_size)); |
| surface2->Commit(); |
| test::WaitForLastFramePresentation(shell_surface2.get()); |
| |
| EXPECT_EQ(per_commit_release_count1, 0); |
| EXPECT_EQ(per_commit_release_count2, 0); |
| EXPECT_EQ(buffer_release_count, 0); |
| |
| // Attach buffer2 to surface1, only the surface1 callback should be emitted. |
| surface1->Attach(buffer2.get()); |
| surface1->Damage(gfx::Rect(buffer_size)); |
| surface1->Commit(); |
| test::WaitForLastFramePresentation(shell_surface1.get()); |
| |
| run_loop2.Run(); |
| EXPECT_EQ(per_commit_release_count1, 1); |
| EXPECT_EQ(per_commit_release_count2, 0); |
| EXPECT_EQ(buffer_release_count, 0); |
| |
| // Attach buffer2 to surface2, only the surface2 callback should be emitted. |
| surface2->Attach(buffer2.get()); |
| surface2->Damage(gfx::Rect(buffer_size)); |
| surface2->Commit(); |
| test::WaitForLastFramePresentation(shell_surface2.get()); |
| |
| run_loop1.Run(); |
| EXPECT_EQ(per_commit_release_count1, 1); |
| EXPECT_EQ(per_commit_release_count2, 1); |
| // The buffer should now be completely released. |
| EXPECT_EQ(buffer_release_count, 1); |
| } |
| |
| TEST_P(SurfaceTest, SimpleSurfaceGraphicsOcclusion) { |
| // This parent is merely the background for our children and plays no role in |
| // this test. |
| gfx::Size buffer_size(256, 256); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| auto surface = std::make_unique<Surface>(); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| surface->Attach(buffer.get()); |
| surface->SetViewport(gfx::SizeF(13, 13)); |
| |
| // # Basic occlusion |
| |
| // The order of subsurface parent attachment is the inverse order of quad |
| // submission so child B comes first. |
| auto child_buffer_b = test::ExoTestHelper::CreateBuffer(gfx::Size(64, 64)); |
| auto child_surface_b = std::make_unique<Surface>(); |
| auto sub_surface_b = |
| std::make_unique<SubSurface>(child_surface_b.get(), surface.get()); |
| child_surface_b->Attach(child_buffer_b.get()); |
| sub_surface_b->SetPosition(gfx::PointF(40, 10)); |
| child_surface_b->SetViewport(gfx::SizeF(20, 10)); |
| child_surface_b->Commit(); |
| |
| auto child_buffer_a = test::ExoTestHelper::CreateBuffer(gfx::Size(64, 64)); |
| auto child_surface_a = std::make_unique<Surface>(); |
| auto sub_surface_a = |
| std::make_unique<SubSurface>(child_surface_a.get(), surface.get()); |
| child_surface_a->Attach(child_buffer_a.get()); |
| sub_surface_a->SetPosition(gfx::PointF(40, 10)); |
| child_surface_a->SetViewport(gfx::SizeF(20, 10)); |
| child_surface_a->SetBlendMode(SkBlendMode::kSrc); |
| child_surface_a->Commit(); |
| |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(2u, frame.render_pass_list.back()->shared_quad_state_list.size()); |
| } |
| |
| // # Non occlusion location |
| sub_surface_a->SetPosition(gfx::PointF(20, 10)); |
| child_surface_a->SetViewport(gfx::SizeF(20, 10)); |
| child_surface_a->Commit(); |
| |
| sub_surface_b->SetPosition(gfx::PointF(30, 10)); |
| child_surface_b->SetViewport(gfx::SizeF(20, 10)); |
| child_surface_b->Commit(); |
| |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(3u, frame.render_pass_list.back()->shared_quad_state_list.size()); |
| } |
| |
| // # Non occluding size. |
| sub_surface_a->SetPosition(gfx::PointF(20, 10)); |
| child_surface_a->SetViewport(gfx::SizeF(20, 10)); |
| child_surface_a->Commit(); |
| |
| sub_surface_b->SetPosition(gfx::PointF(20, 10)); |
| child_surface_b->SetViewport(gfx::SizeF(30, 10)); |
| child_surface_b->Commit(); |
| |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(3u, frame.render_pass_list.back()->shared_quad_state_list.size()); |
| } |
| |
| // # Different occlusion |
| sub_surface_a->SetPosition(gfx::PointF(30, 20)); |
| child_surface_a->SetViewport(gfx::SizeF(30, 15)); |
| child_surface_a->Commit(); |
| |
| sub_surface_b->SetPosition(gfx::PointF(30, 20)); |
| child_surface_b->SetViewport(gfx::SizeF(30, 15)); |
| child_surface_b->Commit(); |
| |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(2u, frame.render_pass_list.back()->shared_quad_state_list.size()); |
| } |
| |
| // # Rounded occlusion not matching |
| child_surface_a->SetRoundedCorners(gfx::RRectF(gfx::RectF(0, 0, 30, 15), 6.0), |
| false); |
| child_surface_a->Commit(); |
| |
| child_surface_b->SetRoundedCorners(gfx::RRectF(gfx::RectF(0, 0, 30, 15), 1.0), |
| false); |
| child_surface_b->Commit(); |
| |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(3u, frame.render_pass_list.back()->shared_quad_state_list.size()); |
| } |
| |
| // # Rounded occlusion matching |
| child_surface_a->SetRoundedCorners(gfx::RRectF(gfx::RectF(0, 0, 20, 10), 6.0), |
| false); |
| child_surface_a->Commit(); |
| |
| child_surface_b->SetRoundedCorners(gfx::RRectF(gfx::RectF(0, 0, 20, 10), 6.0), |
| false); |
| child_surface_b->Commit(); |
| |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(2u, frame.render_pass_list.back()->shared_quad_state_list.size()); |
| } |
| |
| // # Clip rect too small |
| child_surface_a->SetClipRect(gfx::RectF(10, 10)); |
| child_surface_a->Commit(); |
| |
| child_surface_b->Commit(); |
| |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(3u, frame.render_pass_list.back()->shared_quad_state_list.size()); |
| } |
| |
| // # Clip rect large enough |
| child_surface_a->SetClipRect(gfx::RectF(100, 100)); |
| child_surface_a->Commit(); |
| child_surface_b->Commit(); |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(2u, frame.render_pass_list.back()->shared_quad_state_list.size()); |
| } |
| |
| gfx::Transform non_axis_aligned_transform; |
| non_axis_aligned_transform.Rotate(45); |
| |
| gfx::Transform identity_transform; |
| identity_transform.MakeIdentity(); |
| |
| // # Non axis-preserving transform |
| sub_surface_a->SetPosition(gfx::PointF(30, 20)); |
| child_surface_a->SetViewport(gfx::SizeF(30, 15)); |
| child_surface_a->SetSurfaceTransform(non_axis_aligned_transform); |
| child_surface_a->SetClipRect(std::nullopt); |
| child_surface_a->Commit(); |
| |
| sub_surface_b->SetPosition(gfx::PointF(30, 20)); |
| child_surface_b->SetViewport(gfx::SizeF(30, 15)); |
| child_surface_b->SetClipRect(std::nullopt); |
| child_surface_b->Commit(); |
| |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(3u, frame.render_pass_list.back()->shared_quad_state_list.size()); |
| } |
| |
| // # Non axis-preserving transform |
| sub_surface_a->SetPosition(gfx::PointF(30, 20)); |
| child_surface_a->SetViewport(gfx::SizeF(30, 15)); |
| child_surface_a->SetSurfaceTransform(identity_transform); |
| child_surface_a->SetClipRect(std::nullopt); |
| child_surface_a->Commit(); |
| |
| sub_surface_b->SetPosition(gfx::PointF(30, 20)); |
| child_surface_b->SetViewport(gfx::SizeF(30, 15)); |
| child_surface_b->SetClipRect(std::nullopt); |
| child_surface_b->SetSurfaceTransform(non_axis_aligned_transform); |
| child_surface_b->Commit(); |
| |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(3u, frame.render_pass_list.back()->shared_quad_state_list.size()); |
| } |
| |
| gfx::Transform axis_aligned_transform; |
| axis_aligned_transform.Rotate(90); |
| |
| // # Axis-preserving transform |
| sub_surface_a->SetPosition(gfx::PointF(30, 20)); |
| child_surface_a->SetViewport(gfx::SizeF(30, 15)); |
| child_surface_a->SetSurfaceTransform(axis_aligned_transform); |
| child_surface_a->SetClipRect(std::nullopt); |
| child_surface_a->Commit(); |
| |
| sub_surface_b->SetPosition(gfx::PointF(30, 20)); |
| child_surface_b->SetViewport(gfx::SizeF(30, 15)); |
| child_surface_b->SetSurfaceTransform(axis_aligned_transform); |
| child_surface_b->SetClipRect(std::nullopt); |
| child_surface_b->Commit(); |
| |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| ASSERT_EQ(2u, frame.render_pass_list.back()->shared_quad_state_list.size()); |
| } |
| } |
| |
| // Tests that only apply if ExoReactiveFrameSubmission is enabled. |
| class ReactiveFrameSubmissionSurfaceTest : public SurfaceTest { |
| public: |
| ReactiveFrameSubmissionSurfaceTest() { |
| DCHECK_EQ(GetFrameSubmissionType(), test::FrameSubmissionType::kReactive); |
| } |
| |
| ReactiveFrameSubmissionSurfaceTest( |
| const ReactiveFrameSubmissionSurfaceTest&) = delete; |
| ReactiveFrameSubmissionSurfaceTest& operator=( |
| const ReactiveFrameSubmissionSurfaceTest&) = delete; |
| |
| ~ReactiveFrameSubmissionSurfaceTest() override = default; |
| }; |
| |
| // Instantiate the values of frame submission types and device scale factor in |
| // the parameterized tests. |
| INSTANTIATE_TEST_SUITE_P( |
| All, |
| ReactiveFrameSubmissionSurfaceTest, |
| testing::Combine(testing::Values(test::FrameSubmissionType::kReactive), |
| testing::Values(1.0f, 1.25f, 2.0f))); |
| |
| TEST_P(ReactiveFrameSubmissionSurfaceTest, FullDamageAfterDiscardingFrame) { |
| gfx::Size buffer_size(256, 256); |
| auto buffer = test::ExoTestHelper::CreateBuffer(buffer_size); |
| std::unique_ptr<Surface> surface(new Surface); |
| auto shell_surface = std::make_unique<ShellSurface>(surface.get()); |
| |
| surface->Attach(buffer.get()); |
| |
| shell_surface->layer_tree_frame_sink_holder() |
| ->ClearPendingBeginFramesForTesting(); |
| |
| // This will result in a cached frame in LayerTreeFrameSinkHolder. |
| // Do the action twice is necessary when AutoNeedsBeginFrame is enabled, |
| // because the first commit will be an unsolicited frame submission and |
| // therefore not cached. |
| for (int i = 0; i < 2; ++i) { |
| surface->Damage(gfx::Rect(10, 10, 10, 10)); |
| surface->Commit(); |
| } |
| |
| // Commit a frame without any damage. It will cause the previously cached |
| // frame to be discarded. |
| // It is expected that the damage area of the new frame is expanded to full |
| // damage. |
| surface->Commit(); |
| test::WaitForLastFrameAck(shell_surface.get()); |
| |
| { |
| const viz::CompositorFrame& frame = |
| GetFrameFromSurface(shell_surface.get()); |
| EXPECT_EQ(ToPixel(gfx::Rect(buffer_size)), GetCompleteDamage(frame)); |
| } |
| } |
| |
| } // namespace |
| } // namespace exo |