// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/wm/scoped_layer_tree_synchronizer.h"
#include <cmath>
#include <memory>
#include <tuple>
#include <utility>
#include "ash/test/ash_test_base.h"
#include "base/functional/callback_helpers.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/aura/test/test_windows.h"
#include "ui/compositor/layer.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/rect_f.h"
#include "ui/gfx/geometry/rounded_corners_f.h"
#include "ui/gfx/geometry/rrect_f.h"
#include "ui/wm/core/window_util.h"
namespace ash {
namespace {
constexpr gfx::Rect kRootBounds(0, 0, 50, 50);
constexpr gfx::RoundedCornersF kRootLayerRadii(10);
constexpr gfx::RoundedCornersF kZeroRadii(0);
std::unique_ptr<ui::Layer> CreateLayer() {
return std::make_unique<ui::Layer>();
}
using BoundsWithRoundedCorners = std::pair<gfx::Rect, gfx::RoundedCornersF>;
using UpdatingScopedLayerTreeSynchronizerTestParam =
std::tuple</*root_layer_bounds=*/BoundsWithRoundedCorners,
/*child_layer_bounds=*/BoundsWithRoundedCorners,
/*expected_child_layer_radii=*/gfx::RoundedCornersF>;
class UpdatingScopedLayerTreeSynchronizerTest
: public testing::TestWithParam<
UpdatingScopedLayerTreeSynchronizerTestParam> {
public:
UpdatingScopedLayerTreeSynchronizerTest() = default;
UpdatingScopedLayerTreeSynchronizerTest(
const UpdatingScopedLayerTreeSynchronizerTest&) = delete;
UpdatingScopedLayerTreeSynchronizerTest& operator=(
const UpdatingScopedLayerTreeSynchronizerTest&) = delete;
~UpdatingScopedLayerTreeSynchronizerTest() override = default;
protected:
gfx::Rect root_layer_bounds() const { return std::get<0>(GetParam()).first; }
gfx::RoundedCornersF root_layer_radii() const {
return std::get<0>(GetParam()).second;
}
gfx::Rect child_layer_bounds() const { return std::get<1>(GetParam()).first; }
gfx::RoundedCornersF child_layer_radii() const {
return std::get<1>(GetParam()).second;
}
gfx::RoundedCornersF expected_child_layer_radii() const {
return std::get<2>(GetParam());
}
};
TEST_P(UpdatingScopedLayerTreeSynchronizerTest, OverlappingCorners) {
// Layer Tree:
// +root
// +--child_layer
std::unique_ptr<ui::Layer> root = CreateLayer();
std::unique_ptr<ui::Layer> child_layer = CreateLayer();
// Set up layer tree.
root->Add(child_layer.get());
// Set up layer bounds.
root->SetBounds(root_layer_bounds());
child_layer->SetBounds(child_layer_bounds());
// Set layer properties.
root->SetRoundedCornerRadius(root_layer_radii());
root->SetIsFastRoundedCorner(true);
child_layer->SetRoundedCornerRadius(child_layer_radii());
child_layer->SetIsFastRoundedCorner(true);
auto layer_tree_synchronizer = std::make_unique<ScopedLayerTreeSynchronizer>(
root.get(), /*restore_tree=*/false);
ASSERT_EQ(child_layer->rounded_corner_radii(), child_layer_radii());
layer_tree_synchronizer->SynchronizeRoundedCorners(
root.get(),
gfx::RRectF(gfx::RectF(root_layer_bounds()), root_layer_radii()));
// Root layer bounds and radii should be unaffected.
ASSERT_EQ(root->rounded_corner_radii(), root_layer_radii());
ASSERT_EQ(root->bounds(), root_layer_bounds());
EXPECT_EQ(child_layer->rounded_corner_radii(), expected_child_layer_radii());
}
UpdatingScopedLayerTreeSynchronizerTestParam MakeTestParams(
const gfx::Rect& root_layer_bounds,
const gfx::RoundedCornersF& root_layer_radii,
const gfx::Rect& child_layer_bounds,
const gfx::RoundedCornersF& child_layer_radii,
const gfx::RoundedCornersF& expected_child_layer_radii) {
return std::make_tuple(std::make_pair(root_layer_bounds, root_layer_radii),
std::make_pair(child_layer_bounds, child_layer_radii),
expected_child_layer_radii);
}
INSTANTIATE_TEST_SUITE_P(
SanityTests,
UpdatingScopedLayerTreeSynchronizerTest,
testing::Values(
// Child layer has zero bounds.
MakeTestParams(kRootBounds,
kZeroRadii,
gfx::Rect(),
kZeroRadii,
kZeroRadii),
// Parent layer has zero bounds.
MakeTestParams(gfx::Rect(),
kZeroRadii,
gfx::Rect(5, 5, 10, 10),
kZeroRadii,
kZeroRadii),
// If child layer has no rounded corners, we do not update those layers.
MakeTestParams(kRootBounds,
gfx::RoundedCornersF(5),
gfx::Rect(0, 0, 50, 50),
kZeroRadii,
kZeroRadii)));
INSTANTIATE_TEST_SUITE_P(
RootLayerHasNoRoundedCorners,
UpdatingScopedLayerTreeSynchronizerTest,
testing::Values(
// Child layer is the same size as the root layer.
MakeTestParams(kRootBounds,
kZeroRadii,
gfx::Rect(0, 0, 50, 50),
kZeroRadii,
kZeroRadii),
// Child layer (has rounded corners) is the same size as the root layer.
MakeTestParams(kRootBounds,
kZeroRadii,
gfx::Rect(0, 0, 50, 50),
gfx::RoundedCornersF(5),
gfx::RoundedCornersF(5)),
// Child layer (has rounded corners) fits inside the root layer.
MakeTestParams(kRootBounds,
kZeroRadii,
gfx::Rect(10, 10, 20, 0),
gfx::RoundedCornersF(5),
gfx::RoundedCornersF(5))));
INSTANTIATE_TEST_SUITE_P(
RootLayerAndChildLayerHaveRoundedCorners,
UpdatingScopedLayerTreeSynchronizerTest,
testing::Values(
// Root and child layer overlaps completely.
MakeTestParams(kRootBounds,
gfx::RoundedCornersF(10),
gfx::Rect(0, 0, 50, 50),
gfx::RoundedCornersF(10),
gfx::RoundedCornersF(10)),
// Child layer fits inside the root.
MakeTestParams(kRootBounds,
gfx::RoundedCornersF(10),
gfx::Rect(5, 5, 10, 10),
gfx::RoundedCornersF(2),
gfx::RoundedCornersF(2)),
// Corners do not intersect but child layer corners
// are outside root layer rounded bounds. (Test 1)
MakeTestParams(kRootBounds,
gfx::RoundedCornersF(10),
gfx::Rect(0, 0, 50, 50),
gfx::RoundedCornersF(9),
gfx::RoundedCornersF(10)),
// Corners do not intersect but child layer corners
// are outside root layer rounded bounds. (Test 2)
MakeTestParams(kRootBounds,
gfx::RoundedCornersF(20),
gfx::Rect(5, 0, 40, 50),
gfx::RoundedCornersF(5),
gfx::RoundedCornersF(20)),
// Corners intersect. (Test 1)
MakeTestParams(kRootBounds,
gfx::RoundedCornersF(20),
gfx::Rect(3, 5, 44, 40),
gfx::RoundedCornersF(5),
gfx::RoundedCornersF(20)),
// Corners partially intersect.
MakeTestParams(kRootBounds,
gfx::RoundedCornersF(20),
gfx::Rect(4, 5, 43, 40),
gfx::RoundedCornersF(5),
gfx::RoundedCornersF(5, 20, 20, 5))));
class ScopedLayerTreeSynchronizerTest : public testing::TestWithParam<bool> {
public:
ScopedLayerTreeSynchronizerTest() = default;
ScopedLayerTreeSynchronizerTest(const ScopedLayerTreeSynchronizerTest&) =
delete;
ScopedLayerTreeSynchronizerTest& operator=(
const ScopedLayerTreeSynchronizerTest&) = delete;
~ScopedLayerTreeSynchronizerTest() override = default;
protected:
bool restore_layer_tree() const { return GetParam(); }
};
TEST_P(ScopedLayerTreeSynchronizerTest, UpdatingLayerTree) {
// Layer Tree:
// +root (has rounded corners)
// +--layer1 (has intersecting rounded corners with root)
// +----layer2 (has intersecting rounded corners with root)
// +--layer3 (has rounded corners)
constexpr gfx::Rect kLayer1Bounds(0, 0, 30, 30);
constexpr gfx::Rect kLayer2Bounds(20, 20, 60, 60);
constexpr gfx::Rect kLayer3Bounds(10, 10, 20, 20);
constexpr gfx::RoundedCornersF kLayer1Radii(5);
constexpr gfx::RoundedCornersF kLayer2Radii(7);
constexpr gfx::RoundedCornersF kLayer3Radii(0);
constexpr float kLayer2Scale = 0.5;
std::unique_ptr<ui::Layer> root = CreateLayer();
std::unique_ptr<ui::Layer> layer_1 = CreateLayer();
std::unique_ptr<ui::Layer> layer_2 = CreateLayer();
std::unique_ptr<ui::Layer> layer_3 = CreateLayer();
// Set up layer tree.
root->Add(layer_1.get());
root->Add(layer_3.get());
layer_1->Add(layer_2.get());
// Set up layer bounds.
root->SetBounds(kRootBounds);
layer_1->SetBounds(kLayer1Bounds);
layer_2->SetBounds(kLayer2Bounds);
layer_3->SetBounds(kLayer3Bounds);
// Set layer transform.
gfx::Transform layer_2_transform;
layer_2_transform.Scale(kLayer2Scale);
layer_2->SetTransform(layer_2_transform);
// Set layer properties.
root->SetRoundedCornerRadius(kRootLayerRadii);
root->SetIsFastRoundedCorner(true);
layer_1->SetRoundedCornerRadius(kLayer1Radii);
layer_1->SetIsFastRoundedCorner(true);
layer_2->SetRoundedCornerRadius(kLayer2Radii);
layer_2->SetIsFastRoundedCorner(true);
layer_3->SetRoundedCornerRadius(kLayer3Radii);
layer_3->SetIsFastRoundedCorner(true);
auto layer_tree_synchronizer = std::make_unique<ScopedLayerTreeSynchronizer>(
root.get(), restore_layer_tree());
layer_tree_synchronizer->SynchronizeRoundedCorners(
root.get(), gfx::RRectF(gfx::RectF(kRootBounds), kRootLayerRadii));
EXPECT_EQ(root->rounded_corner_radii(), kRootLayerRadii);
constexpr gfx::RoundedCornersF kUpdatedLayer1Radii =
gfx::RoundedCornersF(10, 5, 5, 5);
EXPECT_EQ(layer_1->rounded_corner_radii(), kUpdatedLayer1Radii);
constexpr gfx::RoundedCornersF kUpdatedLayer2Radii =
gfx::RoundedCornersF(7, 7, 20, 7);
EXPECT_EQ(layer_2->rounded_corner_radii(), kUpdatedLayer2Radii);
EXPECT_EQ(layer_3->rounded_corner_radii(), kLayer3Radii);
layer_tree_synchronizer->Restore();
EXPECT_EQ(root->rounded_corner_radii(), kRootLayerRadii);
EXPECT_EQ(layer_1->rounded_corner_radii(),
restore_layer_tree() ? kLayer1Radii : kUpdatedLayer1Radii);
EXPECT_EQ(layer_2->rounded_corner_radii(),
restore_layer_tree() ? kLayer2Radii : kUpdatedLayer2Radii);
EXPECT_EQ(layer_3->rounded_corner_radii(), kLayer3Radii);
}
INSTANTIATE_TEST_SUITE_P(/* no prefix */,
ScopedLayerTreeSynchronizerTest,
testing::Bool());
using ScopedWindowTreeSynchronizerTest = AshTestBase;
TEST_F(ScopedWindowTreeSynchronizerTest, Basics) {
// root
// +---transient_parent
// +------child_window
// +---transient_window_1
// +---transient_window_2
std::unique_ptr<aura::Window> root(
aura::test::CreateTestWindowWithId(0, nullptr));
std::unique_ptr<aura::Window> transient_parent(
aura::test::CreateTestWindowWithId(1, root.get()));
std::unique_ptr<aura::Window> child_window(
aura::test::CreateTestWindowWithId(2, transient_parent.get()));
std::unique_ptr<aura::Window> transient_window_1(
aura::test::CreateTestWindowWithId(3, root.get()));
std::unique_ptr<aura::Window> transient_window_2(
aura::test::CreateTestWindowWithId(4, root.get()));
wm::AddTransientChild(transient_parent.get(), transient_window_1.get());
wm::AddTransientChild(transient_parent.get(), transient_window_2.get());
transient_parent->SetBounds(gfx::Rect(0, 0, 1000, 500));
child_window->SetBounds(gfx::Rect(0, 0, 50, 50));
transient_window_1->SetBounds(gfx::Rect(0, 0, 1000, 500));
transient_window_2->SetBounds(gfx::Rect(20, 20, 200, 200));
transient_parent->layer()->SetRoundedCornerRadius(gfx::RoundedCornersF(5));
child_window->layer()->SetRoundedCornerRadius(gfx::RoundedCornersF(2));
transient_window_1->layer()->SetRoundedCornerRadius(gfx::RoundedCornersF(5));
transient_window_2->layer()->SetRoundedCornerRadius(gfx::RoundedCornersF());
auto window_tree_synchronizer =
std::make_unique<ScopedWindowTreeSynchronizer>(root.get(),
/*restore_tree=*/true);
gfx::RRectF reference_bounds(gfx::RectF(0, 0, 1000, 500),
gfx::RoundedCornersF(10));
window_tree_synchronizer->SynchronizeRoundedCorners(
transient_parent.get(), /*consider_curvature=*/true, reference_bounds,
base::NullCallback());
// All the windows rooted at `transient_parent`(including transient windows)
// should be synchronized again `reference_bounds`.
EXPECT_EQ(transient_parent->layer()->rounded_corner_radii(),
gfx::RoundedCornersF(10));
EXPECT_EQ(child_window->layer()->rounded_corner_radii(),
gfx::RoundedCornersF(10, 2, 2, 2));
EXPECT_EQ(transient_window_1->layer()->rounded_corner_radii(),
gfx::RoundedCornersF(10));
EXPECT_EQ(transient_window_2->layer()->rounded_corner_radii(),
gfx::RoundedCornersF());
gfx::RRectF updated_reference_bounds(gfx::RectF(0, 0, 1000, 500),
gfx::RoundedCornersF(15));
window_tree_synchronizer->SynchronizeRoundedCorners(
transient_parent.get(), /*consider_curvature=*/true,
updated_reference_bounds, base::NullCallback());
// All the windows rooted at `transient_parent` should now have new rounded
// corners based on `updated_reference_bounds`.
EXPECT_EQ(transient_parent->layer()->rounded_corner_radii(),
gfx::RoundedCornersF(15));
EXPECT_EQ(child_window->layer()->rounded_corner_radii(),
gfx::RoundedCornersF(15, 2, 2, 2));
EXPECT_EQ(transient_window_1->layer()->rounded_corner_radii(),
gfx::RoundedCornersF(15));
EXPECT_EQ(transient_window_2->layer()->rounded_corner_radii(),
gfx::RoundedCornersF());
window_tree_synchronizer->Restore();
// All the windows should now be restored to their original state. (i.e
// before calling SynchronizeRoundedCorners() for the first time)
EXPECT_EQ(transient_parent->layer()->rounded_corner_radii(),
gfx::RoundedCornersF(5));
EXPECT_EQ(child_window->layer()->rounded_corner_radii(),
gfx::RoundedCornersF(2));
EXPECT_EQ(transient_window_1->layer()->rounded_corner_radii(),
gfx::RoundedCornersF(5));
EXPECT_EQ(transient_window_2->layer()->rounded_corner_radii(),
gfx::RoundedCornersF());
}
} // namespace
} // namespace ash
Codebase Browser
chromium