// Copyright 2023 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/rounded_display/rounded_display_gutter.h"
#include <algorithm>
#include <cstddef>
#include <string>
#include <vector>
#include "base/check.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/geometry/vector2d.h"
namespace ash {
namespace {
// TODO(zoraiznaeem): Write pixel tests for various types of gutter textures.
using RoundedCorner = RoundedDisplayGutter::RoundedCorner;
using RoundedCornerPosition = RoundedDisplayGutter::RoundedCorner::Position;
constexpr int kCornerRadiusInPixels_16 = 16;
constexpr int kCornerRadiusInPixels_14 = 14;
// If a rounded-corner of radius r, is enclosed in a square of length
// r, the ratio of area of corner to area of square is always 1-pie/4. It is the
// expected ratio of pixels drawn into buffer of size r^2.
constexpr float kExpectedDrawnPixelsToTotalRatio = 0.2146;
// This tolerance works for rounded corner of radius 16 or 14. If different
// values of radius are used to draw the corner, the tolerance value needs to be
// changed. The bigger the corner radius, the lower the tolerance should be and
// vice versa.
constexpr float kTolerance = 0.077;
// Calculate the ratio of drawn pixels to total pixels in the grid enclosed
// between `start_row` to `start_row` + `end_row` and `start_col` to `start_col`
// + `end_col`.
float CalculateDrawnPixelsRatio(SkBitmap& bitmap,
int start_row,
int end_row,
int start_col,
int end_col) {
DCHECK(start_row >= 0 && start_col >= 0);
DCHECK(start_row < bitmap.height() && start_col < bitmap.width());
DCHECK(end_row >= 0 && end_col >= 0);
DCHECK(end_row < bitmap.height() && end_col < bitmap.width());
int n_drawn_pixels = 0;
for (int row = start_row; row <= end_row; row++) {
for (int col = start_col; col <= end_col; col++) {
// Any non transparent pixel is counted as a drawn pixel.
if (bitmap.getColor4f(col, row).fA > 0.0) {
n_drawn_pixels++;
}
}
}
int n_pixels = (end_row - start_row + 1) * (end_col - start_col + 1);
return static_cast<float>(n_drawn_pixels) / n_pixels;
}
// By sampling pixel colors, this method tests if a correct type of
// RoundedCorner of `radius` is painted in the bitmap at position
// (`start_row`, `start_col`).
testing::AssertionResult TestCornerIsDrawn(SkBitmap& bitmap,
int start_row,
int start_col,
int radius,
RoundedCorner::Position position) {
int end_row = start_row + radius - 1;
int end_col = start_col + radius - 1;
float drawn_pixels_ratio =
CalculateDrawnPixelsRatio(bitmap, start_row, end_row, start_col, end_col);
// We expect 1 - pie/4 pixels to be drawn for corner mask texture but given
// the discrete nature of pixels and blending at the edges, we
// expect to have drawn more pixels.
EXPECT_NEAR(drawn_pixels_ratio, kExpectedDrawnPixelsToTotalRatio, kTolerance);
// We overestimate number of drawn pixels.
EXPECT_GE(drawn_pixels_ratio, kExpectedDrawnPixelsToTotalRatio);
// For the mask texture, this pixel will always be a transparent pixel.
EXPECT_EQ(
bitmap.getColor(start_col + (radius * 0.5), start_row + (radius * 0.5)),
SK_ColorTRANSPARENT);
int delta_move_quarter = radius * 0.25 - 1;
int delta_move_three_fourth = radius * 0.75 + 1;
// This pixel will only be drawn for the upper left corner.
EXPECT_EQ(bitmap.getColor(start_col + delta_move_quarter,
start_row + delta_move_quarter),
position == RoundedCorner::Position::kUpperLeft
? SK_ColorBLACK
: SK_ColorTRANSPARENT);
// This pixel will only be drawn for the lower left corner.
EXPECT_EQ(bitmap.getColor(start_col + delta_move_three_fourth,
start_row + delta_move_quarter),
position == RoundedCorner::Position::kUpperRight
? SK_ColorBLACK
: SK_ColorTRANSPARENT);
// This pixel will only be drawn for the upper right corner.
EXPECT_EQ(bitmap.getColor(start_col + delta_move_quarter,
start_row + delta_move_three_fourth),
position == RoundedCorner::Position::kLowerLeft
? SK_ColorBLACK
: SK_ColorTRANSPARENT);
// This pixel will only be drawn for the lower right corner.
EXPECT_EQ(bitmap.getColor(start_col + delta_move_three_fourth,
start_row + delta_move_three_fourth),
position == RoundedCorner::Position::kLowerRight
? SK_ColorBLACK
: SK_ColorTRANSPARENT);
return ::testing::AssertionSuccess();
}
testing::AssertionResult TestGutterHasCornerDrawn(
SkBitmap& texture_bitmap,
const RoundedCorner& corner,
const RoundedDisplayGutter* gutter) {
const gfx::Vector2d& offset =
corner.bounds().OffsetFromOrigin() - gutter->bounds().OffsetFromOrigin();
return TestCornerIsDrawn(texture_bitmap, offset.y(), offset.x(),
corner.radius(), corner.position());
}
// We minimally adjust the `bounds` to either have the same width or height of
// the `gutter_bounds`.
gfx::Rect AdjustToGutterBounds(gfx::Rect bounds, gfx::Rect gutter_bounds) {
gfx::Rect adjusted_bounds(bounds);
if (gutter_bounds.width() >= gutter_bounds.height()) {
adjusted_bounds.set_height(gutter_bounds.height());
}
if (gutter_bounds.width() < gutter_bounds.height()) {
adjusted_bounds.set_width(gutter_bounds.width());
}
return adjusted_bounds;
}
// Note: This method can only calculate the not drawn region of gutter with two
// adjacent corners.
gfx::Rect CalculateNotDrawnRegionOfGutter(
const RoundedDisplayGutter* gutter,
const std::vector<RoundedCorner>& corners) {
gfx::Rect not_drawn_region = gutter->bounds();
for (auto& corner : corners) {
if (corner.DoesPaint()) {
// To subtract the corner bounds from gutter bounds, corner bound needs
// complete intersection with gutter bounds either in x or y direction.
gfx::Rect adjusted_corner_bounds =
AdjustToGutterBounds(corner.bounds(), gutter->bounds());
not_drawn_region.Subtract(adjusted_corner_bounds);
}
}
not_drawn_region.Offset(-gutter->bounds().OffsetFromOrigin());
return not_drawn_region;
}
// Gets the bitmap of texture created by the `gutter`.
SkBitmap GetGutterSkBitmap(RoundedDisplayGutter* gutter) {
gfx::Canvas canvas(gutter->bounds().size(), 1.0, true);
gutter->Paint(&canvas);
return canvas.GetBitmap();
}
class RoundedDisplayGutterTest : public testing::Test {
public:
RoundedDisplayGutterTest() = default;
RoundedDisplayGutterTest(const RoundedDisplayGutterTest&) = delete;
RoundedDisplayGutterTest& operator=(const RoundedDisplayGutterTest&) = delete;
};
TEST_F(RoundedDisplayGutterTest, BoundsOfGuttersWithOneCorner) {
{
RoundedCorner corner(RoundedCornerPosition::kUpperLeft,
kCornerRadiusInPixels_16, gfx::Point(0, 0));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
EXPECT_EQ(gutter->bounds(), gfx::Rect(0, 0, kCornerRadiusInPixels_16,
kCornerRadiusInPixels_16));
}
{
RoundedCorner corner(RoundedCornerPosition::kUpperLeft,
kCornerRadiusInPixels_16, gfx::Point(15, 15));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
EXPECT_EQ(gutter->bounds(), gfx::Rect(15, 15, kCornerRadiusInPixels_16,
kCornerRadiusInPixels_16));
}
}
TEST_F(RoundedDisplayGutterTest, BoundsOfGuttersWithTwoCorners) {
{
// Corners are horizontally adjacent to each other.
RoundedCorner upper_left_corner(RoundedCornerPosition::kUpperLeft,
kCornerRadiusInPixels_16, gfx::Point(0, 0));
RoundedCorner upper_right_corner(RoundedCornerPosition::kUpperRight,
kCornerRadiusInPixels_14,
gfx::Point(100, 0));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(upper_left_corner));
corners.emplace_back(std::move(upper_right_corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
// Expect the bounds to union of both corner bounds.
EXPECT_EQ(gutter->bounds(), gfx::Rect(0, 0, 100 + kCornerRadiusInPixels_14,
kCornerRadiusInPixels_16));
}
{
// Corners are vertically adjacent to each other.
RoundedCorner upper_right_corner(RoundedCornerPosition::kUpperRight,
kCornerRadiusInPixels_16,
gfx::Point(50, 0));
RoundedCorner lower_right_corner(RoundedCornerPosition::kLowerRight,
kCornerRadiusInPixels_16,
gfx::Point(50, 100));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(upper_right_corner));
corners.emplace_back(std::move(lower_right_corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
// Expect the bounds to union of both corner bounds.
EXPECT_EQ(gutter->bounds(), gfx::Rect(50, 0, kCornerRadiusInPixels_16,
100 + kCornerRadiusInPixels_16));
}
{
// Corners are not adjacent to each other.
RoundedCorner upper_left_corner(RoundedCornerPosition::kUpperLeft,
kCornerRadiusInPixels_16, gfx::Point(0, 0));
RoundedCorner lower_right_corner(RoundedCornerPosition::kLowerRight,
kCornerRadiusInPixels_16,
gfx::Point(50, 50));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(upper_left_corner));
corners.emplace_back(std::move(lower_right_corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
// Expect the bounds to union of both corner bounds.
EXPECT_EQ(gutter->bounds(), gfx::Rect(0, 0, 50 + kCornerRadiusInPixels_16,
50 + kCornerRadiusInPixels_16));
}
{
// One of the corners has zero radius.
RoundedCorner upper_left_corner(RoundedCornerPosition::kUpperLeft, 0,
gfx::Point(0, 0));
RoundedCorner lower_right_corner(RoundedCornerPosition::kLowerRight,
kCornerRadiusInPixels_16,
gfx::Point(50, 50));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(upper_left_corner));
corners.emplace_back(std::move(lower_right_corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
// Expect the bounds to be that of non-zero corner.
EXPECT_EQ(gutter->bounds(), gfx::Rect(50, 50, kCornerRadiusInPixels_16,
kCornerRadiusInPixels_16));
}
}
TEST_F(RoundedDisplayGutterTest, BoundsOfGuttersWithThreeCorners) {
{
// Corners are horizontally adjacent to each other.
RoundedCorner upper_left_corner(RoundedCornerPosition::kUpperLeft,
kCornerRadiusInPixels_16, gfx::Point(0, 0));
RoundedCorner upper_right_corner(RoundedCornerPosition::kUpperRight,
kCornerRadiusInPixels_14,
gfx::Point(100, 0));
RoundedCorner lower_left_corner(RoundedCornerPosition::kLowerLeft,
kCornerRadiusInPixels_14,
gfx::Point(0, 50));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(upper_left_corner));
corners.emplace_back(std::move(upper_right_corner));
corners.emplace_back(std::move(lower_left_corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
// Expect the bounds to union of all corner bounds.
EXPECT_EQ(gutter->bounds(), gfx::Rect(0, 0, 100 + kCornerRadiusInPixels_14,
50 + kCornerRadiusInPixels_14));
}
}
TEST_F(RoundedDisplayGutterTest, CorrectTextures_GutterHasSingleCorner) {
{
RoundedCorner upper_right_corner(RoundedCornerPosition::kUpperRight,
kCornerRadiusInPixels_16,
gfx::Point(0, 0));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(upper_right_corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
auto& gutter_corners = gutter->GetGutterCorners();
SkBitmap texture_bitmap = GetGutterSkBitmap(gutter.get());
EXPECT_TRUE(TestGutterHasCornerDrawn(texture_bitmap, gutter_corners.at(0),
gutter.get()));
}
{
RoundedCorner upper_left_corner(RoundedCornerPosition::kUpperLeft,
kCornerRadiusInPixels_16, gfx::Point(0, 0));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(upper_left_corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
auto& gutter_corners = gutter->GetGutterCorners();
SkBitmap texture_bitmap = GetGutterSkBitmap(gutter.get());
EXPECT_TRUE(TestGutterHasCornerDrawn(texture_bitmap, gutter_corners.at(0),
gutter.get()));
}
{
RoundedCorner lower_left_corner(RoundedCornerPosition::kLowerLeft,
kCornerRadiusInPixels_14, gfx::Point(0, 0));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(lower_left_corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
auto& gutter_corners = gutter->GetGutterCorners();
SkBitmap texture_bitmap = GetGutterSkBitmap(gutter.get());
EXPECT_TRUE(TestGutterHasCornerDrawn(texture_bitmap, gutter_corners.at(0),
gutter.get()));
}
{
RoundedCorner lower_right_corner(RoundedCornerPosition::kLowerRight,
kCornerRadiusInPixels_14,
gfx::Point(0, 0));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(lower_right_corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
auto& gutter_corners = gutter->GetGutterCorners();
SkBitmap texture_bitmap = GetGutterSkBitmap(gutter.get());
EXPECT_TRUE(TestGutterHasCornerDrawn(texture_bitmap, gutter_corners.at(0),
gutter.get()));
}
}
TEST_F(RoundedDisplayGutterTest,
GutterHasTwoVerticallyAdjacentCorners_BothCornersPainted) {
RoundedCorner upper_right_corner(RoundedCornerPosition::kUpperRight,
kCornerRadiusInPixels_16, gfx::Point(50, 0));
RoundedCorner lower_right_corner(RoundedCornerPosition::kLowerRight,
kCornerRadiusInPixels_16,
gfx::Point(50, 100));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(upper_right_corner));
corners.emplace_back(std::move(lower_right_corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
SkBitmap texture_bitmap = GetGutterSkBitmap(gutter.get());
auto& gutter_corners = gutter->GetGutterCorners();
EXPECT_TRUE(TestGutterHasCornerDrawn(texture_bitmap, gutter_corners.at(0),
gutter.get()));
EXPECT_TRUE(TestGutterHasCornerDrawn(texture_bitmap, gutter_corners.at(1),
gutter.get()));
gfx::Rect not_drawn_region =
CalculateNotDrawnRegionOfGutter(gutter.get(), gutter_corners);
// We should not draw any thing between corners.
EXPECT_EQ(CalculateDrawnPixelsRatio(texture_bitmap, not_drawn_region.y(),
not_drawn_region.bottom() - 1,
not_drawn_region.x(),
not_drawn_region.right() - 1),
0);
}
TEST_F(RoundedDisplayGutterTest,
GutterHasTwoHorizontallyAdjacentCorners_BothCornersPainted) {
RoundedCorner upper_left_corner(RoundedCornerPosition::kUpperLeft,
kCornerRadiusInPixels_16, gfx::Point(0, 0));
RoundedCorner upper_right_corner(RoundedCornerPosition::kUpperRight,
kCornerRadiusInPixels_16,
gfx::Point(100, 0));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(upper_left_corner));
corners.emplace_back(std::move(upper_right_corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
SkBitmap texture_bitmap = GetGutterSkBitmap(gutter.get());
auto& gutter_corners = gutter->GetGutterCorners();
EXPECT_TRUE(TestGutterHasCornerDrawn(texture_bitmap, gutter_corners.at(0),
gutter.get()));
EXPECT_TRUE(TestGutterHasCornerDrawn(texture_bitmap, gutter_corners.at(1),
gutter.get()));
gfx::Rect not_drawn_region =
CalculateNotDrawnRegionOfGutter(gutter.get(), gutter_corners);
// We should not draw any thing between corners.
EXPECT_EQ(CalculateDrawnPixelsRatio(texture_bitmap, not_drawn_region.y(),
not_drawn_region.bottom() - 1,
not_drawn_region.x(),
not_drawn_region.right() - 1),
0);
}
TEST_F(RoundedDisplayGutterTest,
GutterHasTwoAdjacentCornersWithDifferentRadii) {
RoundedCorner upper_left_corner(RoundedCornerPosition::kUpperLeft,
kCornerRadiusInPixels_16, gfx::Point(0, 0));
RoundedCorner upper_right_corner(RoundedCornerPosition::kUpperRight,
kCornerRadiusInPixels_14,
gfx::Point(100, 0));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(upper_left_corner));
corners.emplace_back(std::move(upper_right_corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
SkBitmap texture_bitmap = GetGutterSkBitmap(gutter.get());
auto& gutter_corners = gutter->GetGutterCorners();
EXPECT_TRUE(TestGutterHasCornerDrawn(texture_bitmap, gutter_corners.at(0),
gutter.get()));
EXPECT_TRUE(TestGutterHasCornerDrawn(texture_bitmap, gutter_corners.at(1),
gutter.get()));
gfx::Rect not_drawn_region =
CalculateNotDrawnRegionOfGutter(gutter.get(), gutter_corners);
// We should not draw any thing between corners.
EXPECT_EQ(CalculateDrawnPixelsRatio(texture_bitmap, not_drawn_region.y(),
not_drawn_region.bottom() - 1,
not_drawn_region.x(),
not_drawn_region.right() - 1),
0);
}
TEST_F(RoundedDisplayGutterTest, GutterHasFourCorners_AllCornersPainted) {
RoundedCorner upper_left_corner(RoundedCornerPosition::kUpperLeft,
kCornerRadiusInPixels_16, gfx::Point(0, 0));
RoundedCorner upper_right_corner(RoundedCornerPosition::kUpperRight,
kCornerRadiusInPixels_16,
gfx::Point(100, 0));
RoundedCorner lower_left_corner(RoundedCornerPosition::kLowerLeft,
kCornerRadiusInPixels_14, gfx::Point(0, 100));
RoundedCorner lower_right_corner(RoundedCornerPosition::kLowerRight,
kCornerRadiusInPixels_14,
gfx::Point(100, 100));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(upper_left_corner));
corners.emplace_back(std::move(upper_right_corner));
corners.emplace_back(std::move(lower_left_corner));
corners.emplace_back(std::move(lower_right_corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
SkBitmap texture_bitmap = GetGutterSkBitmap(gutter.get());
auto& gutter_corners = gutter->GetGutterCorners();
EXPECT_TRUE(TestGutterHasCornerDrawn(texture_bitmap, gutter_corners.at(0),
gutter.get()));
EXPECT_TRUE(TestGutterHasCornerDrawn(texture_bitmap, gutter_corners.at(1),
gutter.get()));
EXPECT_TRUE(TestGutterHasCornerDrawn(texture_bitmap, gutter_corners.at(2),
gutter.get()));
EXPECT_TRUE(TestGutterHasCornerDrawn(texture_bitmap, gutter_corners.at(3),
gutter.get()));
}
TEST_F(RoundedDisplayGutterTest, GutterHasTwoAdjacentCorners_OneCornerPainted) {
RoundedCorner upper_left_corner(RoundedCornerPosition::kUpperLeft, 0,
gfx::Point(0, 0));
RoundedCorner lower_right_corner(RoundedCornerPosition::kLowerRight,
kCornerRadiusInPixels_16,
gfx::Point(50, 50));
std::vector<RoundedCorner> corners;
corners.emplace_back(std::move(upper_left_corner));
corners.emplace_back(std::move(lower_right_corner));
auto gutter = RoundedDisplayGutter::CreateGutter(std::move(corners),
/*is_overlay=*/true);
SkBitmap texture_bitmap = GetGutterSkBitmap(gutter.get());
auto& gutter_corners = gutter->GetGutterCorners();
// Since only one corner is drawn, there is no transparent region compared to
// the textures of gutters with two or more drawn corners.
EXPECT_TRUE(TestGutterHasCornerDrawn(texture_bitmap, gutter_corners.at(1),
gutter.get()));
}
} // namespace
} // namespace ash
Codebase Browser
chromium