ash/style/rounded_rect_cutout_path_builder.cc - chromium/src.git - Git at Google

 // 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/style/rounded_rect_cutout_path_builder.h"

 #include <array>
 #include <utility>

 #include "base/check_op.h"
 #include "base/containers/fixed_flat_map.h"
 #include "base/logging.h"
 #include "third_party/skia/include/core/SkPathBuilder.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/skia/include/core/SkSize.h"

 namespace ash {

 namespace {

 enum class Direction { kCounterClockwise, kClockwise };

 class CornersSequence {
  public:
   // A never ending sequence of corners around a rectangle in a given
   // `direction` starting at `start`.
   CornersSequence(RoundedRectCutoutPathBuilder::Corner start,
                   Direction direction)
       : direction_(direction) {
     size_t i = 0;
     for (; i < kOrderedCorners.size(); i++) {
       if (kOrderedCorners[i] == start) {
         break;
       }
     }
     current_ = i;
   }

   // Returns the current corner and advances in `direction_`.
   RoundedRectCutoutPathBuilder::Corner Next() {
     RoundedRectCutoutPathBuilder::Corner corner = kOrderedCorners[current_];
     current_ = NextIndex(current_, direction_);
     return corner;
   }

   // Returns the current corner then updates the current corner in the opposite
   // of `direction_`.
   RoundedRectCutoutPathBuilder::Corner Back() {
     RoundedRectCutoutPathBuilder::Corner corner = kOrderedCorners[current_];
     Direction reversed_direction = direction_ == Direction::kCounterClockwise
                                        ? Direction::kClockwise
                                        : Direction::kCounterClockwise;
     current_ = NextIndex(current_, reversed_direction);
     return corner;
   }

   // Returns the corner that is opposite of the current corner.
   RoundedRectCutoutPathBuilder::Corner OppositeCurrent() const {
     // Since this is a rectangle, the opposite corner is always 2 steps away.
     return kOrderedCorners.at((current_ + 2) % 4);
   }

  private:
   // Corners in counterclockwise order.
   static constexpr std::array<RoundedRectCutoutPathBuilder::Corner, 4>
       kOrderedCorners = {RoundedRectCutoutPathBuilder::Corner::kUpperLeft,
                          RoundedRectCutoutPathBuilder::Corner::kLowerLeft,
                          RoundedRectCutoutPathBuilder::Corner::kLowerRight,
                          RoundedRectCutoutPathBuilder::Corner::kUpperRight};

   int NextIndex(int current, Direction direction) const {
     int index = current + (direction == Direction::kCounterClockwise
                                ? 1
                                : kOrderedCorners.size() - 1);
     return index % kOrderedCorners.size();
   }

   Direction direction_;
   // Tracks the index of the current corner.
   int current_;
 };

 // Returns the offset vector from the kUpperLeft to `corner` for `rect`.
 //
 // NOTE: Since the vector is relative to `rect`, it is independent of the origin
 // of `rect`.
 SkVector OffsetFromUpperLeft(RoundedRectCutoutPathBuilder::Corner corner,
                              const SkRect& rect) {
   switch (corner) {
     case RoundedRectCutoutPathBuilder::Corner::kUpperLeft:
       return {0.f, 0.f};
     case RoundedRectCutoutPathBuilder::Corner::kLowerLeft:
       return {0.f, rect.height()};
     case RoundedRectCutoutPathBuilder::Corner::kLowerRight:
       return {rect.width(), rect.height()};
     case RoundedRectCutoutPathBuilder::Corner::kUpperRight:
       return {rect.width(), 0.f};
   }
 }

 // Returns the `corner` point of the `rect`.
 SkPoint CornerFromRect(RoundedRectCutoutPathBuilder::Corner corner,
                        const SkRect& rect) {
   SkPoint top_left(rect.left(), rect.top());
   return top_left + OffsetFromUpperLeft(corner, rect);
 }

 // Move `rect` so that the position of `rect_corner` in `rect` matches the
 // position of `view_corner` in `view`.
 void MatchCorners(RoundedRectCutoutPathBuilder::Corner view_corner,
                   const SkRect& view,
                   RoundedRectCutoutPathBuilder::Corner rect_corner,
                   SkRect& rect) {
   SkPoint new_location = CornerFromRect(view_corner, view) -
                          OffsetFromUpperLeft(rect_corner, rect);
   rect.offsetTo(new_location.x(), new_location.y());
 }

 // Modifies `rect` so that the `corner` of `view` and `rect` match.
 // e.g. If `corner` is `kBottomRight`, `rect` is moved so that the bottom right
 // corner of `view` and `rect` match.
 void MoveRectToCorner(RoundedRectCutoutPathBuilder::Corner corner,
                       const SkRect& view,
                       SkRect& rect) {
   MatchCorners(corner, view, corner, rect);
 }

 // Generates 3 rectangles (small corner, inner corner, small corner) that
 // represent the bounds of the arcs for the cutout at `corner`. The cutout is
 // of `cutout_size`, inscribed into `view`. Small corners have
 // `outer_corner_radius` and the inner corner has `inner_corner_radius`.
 //
 // e.g. Corner::kLowerRight
 //
 //             SS
 //             SS
 //         LLLLOO
 //         LLLLOO
 //         LLLLOO
 //       RROOOOOO
 //       RROOOOOO
 //
 //  R = 1st outer corner, L = inner corner, S = 2nd outer corner, O = Remainder
 //  of cutout (not in rects).
 std::array<SkRect, 3> PlaceRects(RoundedRectCutoutPathBuilder::Corner corner,
                                  const SkRect& view,
                                  const SkSize& cutout_size,
                                  float outer_corner_radius,
                                  float inner_corner_radius) {
   // rects[0] is the first outer corner, rects[1] is the inner corner, rects[2]
   // is the last outer corner.
   std::array<SkRect, 3> rects = {
       SkRect::MakeWH(outer_corner_radius, outer_corner_radius),
       SkRect::MakeWH(inner_corner_radius, inner_corner_radius),
       SkRect::MakeWH(outer_corner_radius, outer_corner_radius)};

   SkRect cutout = SkRect::MakeSize(cutout_size);
   // Place `cutout` in the appropriate corner of `view`.
   MoveRectToCorner(corner, view, cutout);

   CornersSequence sequence(corner, Direction::kClockwise);
   // For the cutout, corners are drawn in the opposite direction from how we
   // iterate around the rectangle (because the cutouts are convex).  We happen
   // to draw all the corners except the corner where the cutout is located. So
   // start there but skip it.
   sequence.Next();

   MatchCorners(sequence.Next(), cutout, corner, rects[0]);
   MoveRectToCorner(sequence.Next(), cutout, rects[1]);
   MatchCorners(sequence.Next(), cutout, corner, rects[2]);

   // This draws nonsensical curves if the corners overlap.
   CHECK(!rects[1].intersect(rects[0]));
   CHECK(!rects[1].intersect(rects[2]));
   return rects;
 }

 // Add a rounded path to `builder` for a `corner` of `rect`. The path is drawn
 // counter clockwise from the corner before `corner` to the opposite corner.
 // e.g. if `corner` is kUpperRight, the path is drawn from kLowerRight to
 // kUpperLeft.
 void AddRoundedCorner(RoundedRectCutoutPathBuilder::Corner corner,
                       const SkRect& rect,
                       SkPathBuilder& builder,
                       Direction direction = Direction::kCounterClockwise) {
   CornersSequence sequence(corner, direction);
   // The large rounded corner starts at the corner before the corner where
   // it is drawn. So, backup one and discard it since we'll hit it again.
   sequence.Back();

   SkPoint start = CornerFromRect(sequence.Next(), rect);
   SkPoint control_point = CornerFromRect(sequence.Next(), rect);
   SkPoint end = CornerFromRect(sequence.Next(), rect);

   builder.lineTo(start);
   builder.conicTo(control_point, end, SK_ScalarRoot2Over2);
 }

 // Adds the required paths to `builder` to draw a the cutout of
 // `cutout_size` within `view` with `outer_corner_radius` for the first two
 // corners and `inner_corner_radius` for the interior corner. A line will be
 // drawn to the first conic will be drawn from the location of `builder`.
 // The path will end at the end of the last conic.
 SkRect AddCutoutPaths(RoundedRectCutoutPathBuilder::Corner corner,
                       SkPathBuilder& builder,
                       const SkRect& view,
                       const SkSize& cutout_size,
                       int outer_corner_radius,
                       int inner_corner_radius) {
   // Create rectangles that enclose each of the curves.
   std::array<SkRect, 3> rects = PlaceRects(
       corner, view, cutout_size, outer_corner_radius, inner_corner_radius);

   // Draw the first outer corner.
   AddRoundedCorner(corner, rects[0], builder);

   // The inner corner is drawn opposite from the current corner and in the
   // clockwise direction because it is convex.
   CornersSequence sequence(corner, Direction::kCounterClockwise);
   AddRoundedCorner(sequence.OppositeCurrent(), rects[1], builder,
                    Direction::kClockwise);

   // Draw the other outer corner.
   AddRoundedCorner(corner, rects[2], builder);

   // A rectangle enclosing all the rectangles to conservatively check for
   // overlap.
   SkRect union_rect = rects[0];
   union_rect.join(rects[1]);
   union_rect.join(rects[2]);
   return union_rect;
 }

 }  // namespace

 RoundedRectCutoutPathBuilder::RoundedRectCutoutPathBuilder(gfx::SizeF bounds)
     : bounds_(bounds) {
   CHECK_GE(bounds.width(), corner_radius_ * 2.f)
       << "Width must be at least twice as large as corner radius";
   CHECK_GE(bounds.height(), corner_radius_ * 2.f)
       << "Height must be at least twice as large as corner radius";
 }

 RoundedRectCutoutPathBuilder::RoundedRectCutoutPathBuilder(
     const RoundedRectCutoutPathBuilder&) = default;
 RoundedRectCutoutPathBuilder& RoundedRectCutoutPathBuilder::operator=(
     const RoundedRectCutoutPathBuilder&) = default;

 RoundedRectCutoutPathBuilder::~RoundedRectCutoutPathBuilder() = default;

 RoundedRectCutoutPathBuilder& RoundedRectCutoutPathBuilder::CornerRadius(
     int radius) {
   corner_radius_ = radius;
   return *this;
 }

 RoundedRectCutoutPathBuilder& RoundedRectCutoutPathBuilder::AddCutout(
     RoundedRectCutoutPathBuilder::Corner corner,
     gfx::SizeF size) {
   if (size.IsZero()) {
     cutouts_.erase(corner);
     return *this;
   }

   cutouts_[corner] = size;
   return *this;
 }

 RoundedRectCutoutPathBuilder&
 RoundedRectCutoutPathBuilder::CutoutInnerCornerRadius(int radius) {
   cutout_inner_corner_radius_ = radius;
   return *this;
 }

 RoundedRectCutoutPathBuilder&
 RoundedRectCutoutPathBuilder::CutoutOuterCornerRadius(int radius) {
   cutout_outer_corner_radius_ = radius;
   return *this;
 }

 SkPath RoundedRectCutoutPathBuilder::Build() {
   SkRect view = SkRect::MakeWH(bounds_.width(), bounds_.height());
   CHECK_GE(view.width(), corner_radius_ * 2.f)
       << "Width must be at least twice as large as corner radius";
   CHECK_GE(view.height(), corner_radius_ * 2.f)
       << "Height must be at least twice as large as corner radius";

   SkPathBuilder builder;
   // Start at the top center of the rectangle.
   builder.moveTo(view.width() / 2.f, view.top());

   // Save cutout bounds to check for overlap.
   std::vector<SkRect> drawn_cutouts;
   drawn_cutouts.reserve(4);

   // Build paths counter clockwise around view.
   CornersSequence around(RoundedRectCutoutPathBuilder::Corner::kUpperLeft,
                          Direction::kCounterClockwise);
   RoundedRectCutoutPathBuilder::Corner cur_corner = around.Next();
   do {
     auto iter = cutouts_.find(cur_corner);
     if (iter != cutouts_.end()) {
       // Adds the paths for the cutout.
       gfx::SizeF size = iter->second;
       CHECK_GE(bounds_.width(),
                (size.width() + cutout_outer_corner_radius_ + corner_radius_))
           << "Cutout width + outer corner radius + corner radius must be less "
              "than or equal to bounds width";
       CHECK_GE(bounds_.height(),
                (size.height() + cutout_outer_corner_radius_ + corner_radius_))
           << "Cutout height + outer corner radius + corner radius must be less "
              "than or equal to bounds height";

       SkRect rect = AddCutoutPaths(
           cur_corner, builder, view, SkSize::Make(size.width(), size.height()),
           cutout_outer_corner_radius_, cutout_inner_corner_radius_);
       drawn_cutouts.push_back(rect);
     } else {
       if (corner_radius_ == 0) {
         // If corner radius is 0, it's a point so just draw a line.
         SkPoint point = CornerFromRect(cur_corner, view);
         builder.lineTo(point);
       } else {
         // Draw the rounded corners for the larger view.
         SkRect rect = SkRect::MakeWH(corner_radius_, corner_radius_);
         MoveRectToCorner(cur_corner, view, rect);
         AddRoundedCorner(cur_corner, rect, builder);
       }
     }
     cur_corner = around.Next();
   } while (cur_corner != RoundedRectCutoutPathBuilder::Corner::kUpperLeft);

   // Verify that none of the cutouts intersect or the drawn shape will not work.
   // This is checking all pairs so it's O(n^2) but n<4.
   for (size_t i = 0; i < drawn_cutouts.size(); i++) {
     const SkRect& cutout = drawn_cutouts[i];
     for (size_t j = i + 1; j < drawn_cutouts.size(); j++) {
       CHECK(!cutout.intersects(drawn_cutouts[j]))
           << "At least two cutouts intersect and the path is invalid";
     }
   }

   // `close()` will draw a line from the last point to the start (top middle of
   // the shape).
   builder.close();
   return builder.detach();
 }

 }  // namespace ash
	// 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/style/rounded_rect_cutout_path_builder.h"

	#include <array>
	#include <utility>

	#include "base/check_op.h"
	#include "base/containers/fixed_flat_map.h"
	#include "base/logging.h"
	#include "third_party/skia/include/core/SkPathBuilder.h"
	#include "third_party/skia/include/core/SkRect.h"
	#include "third_party/skia/include/core/SkSize.h"

	namespace ash {

	namespace {

	enum class Direction { kCounterClockwise, kClockwise };

	class CornersSequence {
	public:
	// A never ending sequence of corners around a rectangle in a given
	// `direction` starting at `start`.
	CornersSequence(RoundedRectCutoutPathBuilder::Corner start,
	Direction direction)
	: direction_(direction) {
	size_t i = 0;
	for (; i < kOrderedCorners.size(); i++) {
	if (kOrderedCorners[i] == start) {
	break;
	}
	}
	current_ = i;
	}

	// Returns the current corner and advances in `direction_`.
	RoundedRectCutoutPathBuilder::Corner Next() {
	RoundedRectCutoutPathBuilder::Corner corner = kOrderedCorners[current_];
	current_ = NextIndex(current_, direction_);
	return corner;
	}

	// Returns the current corner then updates the current corner in the opposite
	// of `direction_`.
	RoundedRectCutoutPathBuilder::Corner Back() {
	RoundedRectCutoutPathBuilder::Corner corner = kOrderedCorners[current_];
	Direction reversed_direction = direction_ == Direction::kCounterClockwise
	? Direction::kClockwise
	: Direction::kCounterClockwise;
	current_ = NextIndex(current_, reversed_direction);
	return corner;
	}

	// Returns the corner that is opposite of the current corner.
	RoundedRectCutoutPathBuilder::Corner OppositeCurrent() const {
	// Since this is a rectangle, the opposite corner is always 2 steps away.
	return kOrderedCorners.at((current_ + 2) % 4);
	}

	private:
	// Corners in counterclockwise order.
	static constexpr std::array<RoundedRectCutoutPathBuilder::Corner, 4>
	kOrderedCorners = {RoundedRectCutoutPathBuilder::Corner::kUpperLeft,
	RoundedRectCutoutPathBuilder::Corner::kLowerLeft,
	RoundedRectCutoutPathBuilder::Corner::kLowerRight,
	RoundedRectCutoutPathBuilder::Corner::kUpperRight};

	int NextIndex(int current, Direction direction) const {
	int index = current + (direction == Direction::kCounterClockwise
	? 1
	: kOrderedCorners.size() - 1);
	return index % kOrderedCorners.size();
	}

	Direction direction_;
	// Tracks the index of the current corner.
	int current_;
	};

	// Returns the offset vector from the kUpperLeft to `corner` for `rect`.
	//
	// NOTE: Since the vector is relative to `rect`, it is independent of the origin
	// of `rect`.
	SkVector OffsetFromUpperLeft(RoundedRectCutoutPathBuilder::Corner corner,
	const SkRect& rect) {
	switch (corner) {
	case RoundedRectCutoutPathBuilder::Corner::kUpperLeft:
	return {0.f, 0.f};
	case RoundedRectCutoutPathBuilder::Corner::kLowerLeft:
	return {0.f, rect.height()};
	case RoundedRectCutoutPathBuilder::Corner::kLowerRight:
	return {rect.width(), rect.height()};
	case RoundedRectCutoutPathBuilder::Corner::kUpperRight:
	return {rect.width(), 0.f};
	}
	}

	// Returns the `corner` point of the `rect`.
	SkPoint CornerFromRect(RoundedRectCutoutPathBuilder::Corner corner,
	const SkRect& rect) {
	SkPoint top_left(rect.left(), rect.top());
	return top_left + OffsetFromUpperLeft(corner, rect);
	}

	// Move `rect` so that the position of `rect_corner` in `rect` matches the
	// position of `view_corner` in `view`.
	void MatchCorners(RoundedRectCutoutPathBuilder::Corner view_corner,
	const SkRect& view,
	RoundedRectCutoutPathBuilder::Corner rect_corner,
	SkRect& rect) {
	SkPoint new_location = CornerFromRect(view_corner, view) -
	OffsetFromUpperLeft(rect_corner, rect);
	rect.offsetTo(new_location.x(), new_location.y());
	}

	// Modifies `rect` so that the `corner` of `view` and `rect` match.
	// e.g. If `corner` is `kBottomRight`, `rect` is moved so that the bottom right
	// corner of `view` and `rect` match.
	void MoveRectToCorner(RoundedRectCutoutPathBuilder::Corner corner,
	const SkRect& view,
	SkRect& rect) {
	MatchCorners(corner, view, corner, rect);
	}

	// Generates 3 rectangles (small corner, inner corner, small corner) that
	// represent the bounds of the arcs for the cutout at `corner`. The cutout is
	// of `cutout_size`, inscribed into `view`. Small corners have
	// `outer_corner_radius` and the inner corner has `inner_corner_radius`.
	//
	// e.g. Corner::kLowerRight
	//
	// SS
	// SS
	// LLLLOO
	// LLLLOO
	// LLLLOO
	// RROOOOOO
	// RROOOOOO
	//
	// R = 1st outer corner, L = inner corner, S = 2nd outer corner, O = Remainder
	// of cutout (not in rects).
	std::array<SkRect, 3> PlaceRects(RoundedRectCutoutPathBuilder::Corner corner,
	const SkRect& view,
	const SkSize& cutout_size,
	float outer_corner_radius,
	float inner_corner_radius) {
	// rects[0] is the first outer corner, rects[1] is the inner corner, rects[2]
	// is the last outer corner.
	std::array<SkRect, 3> rects = {
	SkRect::MakeWH(outer_corner_radius, outer_corner_radius),
	SkRect::MakeWH(inner_corner_radius, inner_corner_radius),
	SkRect::MakeWH(outer_corner_radius, outer_corner_radius)};

	SkRect cutout = SkRect::MakeSize(cutout_size);
	// Place `cutout` in the appropriate corner of `view`.
	MoveRectToCorner(corner, view, cutout);

	CornersSequence sequence(corner, Direction::kClockwise);
	// For the cutout, corners are drawn in the opposite direction from how we
	// iterate around the rectangle (because the cutouts are convex). We happen
	// to draw all the corners except the corner where the cutout is located. So
	// start there but skip it.
	sequence.Next();

	MatchCorners(sequence.Next(), cutout, corner, rects[0]);
	MoveRectToCorner(sequence.Next(), cutout, rects[1]);
	MatchCorners(sequence.Next(), cutout, corner, rects[2]);

	// This draws nonsensical curves if the corners overlap.
	CHECK(!rects[1].intersect(rects[0]));
	CHECK(!rects[1].intersect(rects[2]));
	return rects;
	}

	// Add a rounded path to `builder` for a `corner` of `rect`. The path is drawn
	// counter clockwise from the corner before `corner` to the opposite corner.
	// e.g. if `corner` is kUpperRight, the path is drawn from kLowerRight to
	// kUpperLeft.
	void AddRoundedCorner(RoundedRectCutoutPathBuilder::Corner corner,
	const SkRect& rect,
	SkPathBuilder& builder,
	Direction direction = Direction::kCounterClockwise) {
	CornersSequence sequence(corner, direction);
	// The large rounded corner starts at the corner before the corner where
	// it is drawn. So, backup one and discard it since we'll hit it again.
	sequence.Back();

	SkPoint start = CornerFromRect(sequence.Next(), rect);
	SkPoint control_point = CornerFromRect(sequence.Next(), rect);
	SkPoint end = CornerFromRect(sequence.Next(), rect);

	builder.lineTo(start);
	builder.conicTo(control_point, end, SK_ScalarRoot2Over2);
	}

	// Adds the required paths to `builder` to draw a the cutout of
	// `cutout_size` within `view` with `outer_corner_radius` for the first two
	// corners and `inner_corner_radius` for the interior corner. A line will be
	// drawn to the first conic will be drawn from the location of `builder`.
	// The path will end at the end of the last conic.
	SkRect AddCutoutPaths(RoundedRectCutoutPathBuilder::Corner corner,
	SkPathBuilder& builder,
	const SkRect& view,
	const SkSize& cutout_size,
	int outer_corner_radius,
	int inner_corner_radius) {
	// Create rectangles that enclose each of the curves.
	std::array<SkRect, 3> rects = PlaceRects(
	corner, view, cutout_size, outer_corner_radius, inner_corner_radius);

	// Draw the first outer corner.
	AddRoundedCorner(corner, rects[0], builder);

	// The inner corner is drawn opposite from the current corner and in the
	// clockwise direction because it is convex.
	CornersSequence sequence(corner, Direction::kCounterClockwise);
	AddRoundedCorner(sequence.OppositeCurrent(), rects[1], builder,
	Direction::kClockwise);

	// Draw the other outer corner.
	AddRoundedCorner(corner, rects[2], builder);

	// A rectangle enclosing all the rectangles to conservatively check for
	// overlap.
	SkRect union_rect = rects[0];
	union_rect.join(rects[1]);
	union_rect.join(rects[2]);
	return union_rect;
	}

	} // namespace

	RoundedRectCutoutPathBuilder::RoundedRectCutoutPathBuilder(gfx::SizeF bounds)
	: bounds_(bounds) {
	CHECK_GE(bounds.width(), corner_radius_ * 2.f)
	<< "Width must be at least twice as large as corner radius";
	CHECK_GE(bounds.height(), corner_radius_ * 2.f)
	<< "Height must be at least twice as large as corner radius";
	}

	RoundedRectCutoutPathBuilder::RoundedRectCutoutPathBuilder(
	const RoundedRectCutoutPathBuilder&) = default;
	RoundedRectCutoutPathBuilder& RoundedRectCutoutPathBuilder::operator=(
	const RoundedRectCutoutPathBuilder&) = default;

	RoundedRectCutoutPathBuilder::~RoundedRectCutoutPathBuilder() = default;

	RoundedRectCutoutPathBuilder& RoundedRectCutoutPathBuilder::CornerRadius(
	int radius) {
	corner_radius_ = radius;
	return *this;
	}

	RoundedRectCutoutPathBuilder& RoundedRectCutoutPathBuilder::AddCutout(
	RoundedRectCutoutPathBuilder::Corner corner,
	gfx::SizeF size) {
	if (size.IsZero()) {
	cutouts_.erase(corner);
	return *this;
	}

	cutouts_[corner] = size;
	return *this;
	}

	RoundedRectCutoutPathBuilder&
	RoundedRectCutoutPathBuilder::CutoutInnerCornerRadius(int radius) {
	cutout_inner_corner_radius_ = radius;
	return *this;
	}

	RoundedRectCutoutPathBuilder&
	RoundedRectCutoutPathBuilder::CutoutOuterCornerRadius(int radius) {
	cutout_outer_corner_radius_ = radius;
	return *this;
	}

	SkPath RoundedRectCutoutPathBuilder::Build() {
	SkRect view = SkRect::MakeWH(bounds_.width(), bounds_.height());
	CHECK_GE(view.width(), corner_radius_ * 2.f)
	<< "Width must be at least twice as large as corner radius";
	CHECK_GE(view.height(), corner_radius_ * 2.f)
	<< "Height must be at least twice as large as corner radius";

	SkPathBuilder builder;
	// Start at the top center of the rectangle.
	builder.moveTo(view.width() / 2.f, view.top());

	// Save cutout bounds to check for overlap.
	std::vector<SkRect> drawn_cutouts;
	drawn_cutouts.reserve(4);

	// Build paths counter clockwise around view.
	CornersSequence around(RoundedRectCutoutPathBuilder::Corner::kUpperLeft,
	Direction::kCounterClockwise);
	RoundedRectCutoutPathBuilder::Corner cur_corner = around.Next();
	do {
	auto iter = cutouts_.find(cur_corner);
	if (iter != cutouts_.end()) {
	// Adds the paths for the cutout.
	gfx::SizeF size = iter->second;
	CHECK_GE(bounds_.width(),
	(size.width() + cutout_outer_corner_radius_ + corner_radius_))
	<< "Cutout width + outer corner radius + corner radius must be less "
	"than or equal to bounds width";
	CHECK_GE(bounds_.height(),
	(size.height() + cutout_outer_corner_radius_ + corner_radius_))
	<< "Cutout height + outer corner radius + corner radius must be less "
	"than or equal to bounds height";

	SkRect rect = AddCutoutPaths(
	cur_corner, builder, view, SkSize::Make(size.width(), size.height()),
	cutout_outer_corner_radius_, cutout_inner_corner_radius_);
	drawn_cutouts.push_back(rect);
	} else {
	if (corner_radius_ == 0) {
	// If corner radius is 0, it's a point so just draw a line.
	SkPoint point = CornerFromRect(cur_corner, view);
	builder.lineTo(point);
	} else {
	// Draw the rounded corners for the larger view.
	SkRect rect = SkRect::MakeWH(corner_radius_, corner_radius_);
	MoveRectToCorner(cur_corner, view, rect);
	AddRoundedCorner(cur_corner, rect, builder);
	}
	}
	cur_corner = around.Next();
	} while (cur_corner != RoundedRectCutoutPathBuilder::Corner::kUpperLeft);

	// Verify that none of the cutouts intersect or the drawn shape will not work.
	// This is checking all pairs so it's O(n^2) but n<4.
	for (size_t i = 0; i < drawn_cutouts.size(); i++) {
	const SkRect& cutout = drawn_cutouts[i];
	for (size_t j = i + 1; j < drawn_cutouts.size(); j++) {
	CHECK(!cutout.intersects(drawn_cutouts[j]))
	<< "At least two cutouts intersect and the path is invalid";
	}
	}

	// `close()` will draw a line from the last point to the start (top middle of
	// the shape).
	builder.close();
	return builder.detach();
	}

	} // namespace ash