ios/chrome/browser/bubble/ui_bundled/bubble_util.mm - chromium/src - Git at Google

 // Copyright 2017 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #import "ios/chrome/browser/bubble/ui_bundled/bubble_util.h"

 #import <ostream>

 #import "base/check_op.h"
 #import "base/i18n/rtl.h"
 #import "base/notreached.h"
 #import "ios/chrome/browser/shared/ui/util/rtl_geometry.h"
 #import "ios/chrome/browser/bubble/ui_bundled/bubble_constants.h"

 namespace {

 // Bubble's maximum width, preserves readability, ensuring that the bubble does
 // not span across wide screens.
 const CGFloat kBubbleMaxWidth = 375.0f;

 // Whether bubble with arrow direction `direction` is pointing left.
 BOOL IsArrowPointingLeft(BubbleArrowDirection direction, bool is_rtl) {
   return direction ==
          (is_rtl ? BubbleArrowDirectionTrailing : BubbleArrowDirectionLeading);
 }

 // Calculate the distance from the bubble's leading edge to the leading edge of
 // its bounding coordinate system. In LTR contexts, the returned float is the
 // x-coordinate of the bubble's origin. This calculation is based on
 // `anchor_point`, which is the point of the target UI element the bubble is
 // anchored at, and the bubble's alignment offset, alignment, direction, and
 // size. The returned float is in the same coordinate system as `anchor_point`,
 // which should be the coordinate system in which the bubble is drawn.
 CGFloat LeadingDistance(CGPoint anchor_point,
                         BubbleArrowDirection arrow_direction,
                         CGFloat bubble_alignment_offset,
                         BubbleAlignment alignment,
                         CGFloat bubble_width,
                         CGFloat bounding_width,
                         bool is_rtl) {
   // Find `leading_offset`, the distance from the bubble's leading edge to the
   // anchor point. This depends on alignment and bubble width.
   CGFloat leading_offset;
   switch (arrow_direction) {
     case BubbleArrowDirectionUp:
     case BubbleArrowDirectionDown:
       switch (alignment) {
         case BubbleAlignmentTopOrLeading:
           leading_offset = bubble_alignment_offset;
           break;
         case BubbleAlignmentCenter:
           leading_offset = bubble_width / 2.0f;
           break;
         case BubbleAlignmentBottomOrTrailing:
           leading_offset = bubble_width - bubble_alignment_offset;
           break;
         default:
           NOTREACHED_IN_MIGRATION() << "Invalid bubble alignment " << alignment;
           break;
       }
       break;
     case BubbleArrowDirectionLeading:
       leading_offset = 0;
       break;
     case BubbleArrowDirectionTrailing:
       leading_offset = bubble_width;
       break;
   }
   CGFloat leading_distance;
   if (is_rtl) {
     leading_distance = bounding_width - (anchor_point.x + leading_offset);
   } else {
     leading_distance = anchor_point.x - leading_offset;
   }
   // Round the leading distance.
   return round(leading_distance);
 }

 // Calculate the y-coordinate of the bubble's origin based on `anchor_point`,
 // the point of the UI element the bubble is anchored at, and the bubble's
 // alignment offset, alignment, direction and size. The returned float is in the
 // same coordinate system as `anchor_point`, which should be the coordinate
 // system in which the bubble is drawn.
 CGFloat OriginY(CGPoint anchor_point,
                 BubbleArrowDirection arrow_direction,
                 CGFloat bubble_alignment_offset,
                 BubbleAlignment alignment,
                 CGFloat bubble_height) {
   CGFloat origin_y;
   switch (arrow_direction) {
     case BubbleArrowDirectionUp:
       origin_y = anchor_point.y;
       break;
     case BubbleArrowDirectionDown:
       origin_y = anchor_point.y - bubble_height;
       break;
     case BubbleArrowDirectionLeading:
     case BubbleArrowDirectionTrailing:
       switch (alignment) {
         case BubbleAlignmentTopOrLeading:
           origin_y = anchor_point.y - bubble_alignment_offset;
           break;
         case BubbleAlignmentCenter:
           origin_y = anchor_point.y - bubble_height / 2;
           break;
         case BubbleAlignmentBottomOrTrailing:
           origin_y = anchor_point.y - (bubble_height - bubble_alignment_offset);
           break;
       }
       break;
   }
   // Round down the origin Y.
   return floor(origin_y);
 }

 // Calculate the maximum width of the bubble such that it stays within its
 // bounding coordinate space. `anchor_point_x` is the x-coordinate of the point
 // on the target UI element the bubble is anchored at. It is in the coordinate
 // system in which the bubble is drawn. `direction` is the direction the bubble
 // arrow points to. `bubble_alignment_offset` is the distance from the leading
 // edge of the bubble to the anchor point if leading aligned, and from the
 // trailing edge of the bubble to the anchor point if trailing aligned.
 // `alignment` is the bubble's alignment, `bounding_width` is the width of the
 // coordinate space in which the bubble is drawn, and `is_rtl` is true if the
 // language is RTL and `false` otherwise.
 CGFloat BubbleMaxWidth(CGFloat anchor_point_x,
                        BubbleArrowDirection direction,
                        CGFloat bubble_alignment_offset,
                        BubbleAlignment alignment,
                        CGFloat bounding_width,
                        bool is_rtl) {
   CGFloat max_width;
   // Space on the left of the anchor point.
   CGFloat distance_to_left_edge = anchor_point_x;
   // Space on the right of the anchor point.
   CGFloat distance_to_right_edge = bounding_width - anchor_point_x;
   switch (direction) {
     case BubbleArrowDirectionUp:
     case BubbleArrowDirectionDown:
       switch (alignment) {
         case BubbleAlignmentTopOrLeading:
           // The bubble can use the space from the anchor point to the trailing
           // edge.
           max_width =
               (is_rtl ? distance_to_left_edge : distance_to_right_edge) +
               bubble_alignment_offset;
           break;
         case BubbleAlignmentCenter:
           // The width of half the bubble cannot exceed the distance from the
           // anchor point to the closest edge of the superview.
           max_width = MIN(distance_to_left_edge, distance_to_right_edge) * 2.0f;
           break;
         case BubbleAlignmentBottomOrTrailing:
           // The bubble can use the space from the anchor point to the leading
           // edge.
           max_width =
               (is_rtl ? distance_to_right_edge : distance_to_left_edge) +
               bubble_alignment_offset;
           break;
         default:
           NOTREACHED_IN_MIGRATION() << "Invalid bubble alignment " << alignment;
           break;
       }
       break;
     case BubbleArrowDirectionLeading:
     case BubbleArrowDirectionTrailing:
       if (IsArrowPointingLeft(direction, is_rtl)) {
         max_width = distance_to_right_edge;
       } else {
         max_width = distance_to_left_edge;
       }
       break;
   }
   // Round up the width.
   return ceil(MIN(max_width, kBubbleMaxWidth));
 }

 // Calculate the maximum height of the bubble such that it stays within its
 // bounding coordinate space. `anchor_point_y` is the y-coordinate of the point
 // on the target UI element the bubble is anchored at. It is in the coordinate
 // system in which the bubble is drawn. `direction` is the direction the arrow
 // is pointing. `bubble_alignment_offset` is the distance from the leading or
 // top edge of the bubble to the anchor point if leading aligned, and from the
 // bottom or trailing edge of the bubble to the anchor point if trailing
 // aligned. `alignment` is the bubble's alignment, `bounding_height` is the
 // height of the coordinate space in which the bubble is drawn.
 CGFloat BubbleMaxHeight(CGFloat anchor_point_y,
                         BubbleArrowDirection direction,
                         CGFloat bubble_alignment_offset,
                         BubbleAlignment alignment,
                         CGFloat bounding_height) {
   CGFloat max_height;
   // Space on the top of the anchor point.
   CGFloat distance_to_top_edge = anchor_point_y;
   // Space on the bottom of the anchor point.
   CGFloat distance_to_bottom_edge = bounding_height - anchor_point_y;
   switch (direction) {
     case BubbleArrowDirectionUp:
       max_height = distance_to_bottom_edge;
       break;
     case BubbleArrowDirectionDown:
       max_height = distance_to_top_edge;
       break;
     case BubbleArrowDirectionLeading:
     case BubbleArrowDirectionTrailing:
       switch (alignment) {
         case BubbleAlignmentTopOrLeading:
           // The bubble can use the space from the anchor point to the bottom
           // edge.
           max_height = distance_to_bottom_edge + bubble_alignment_offset;
           break;
         case BubbleAlignmentCenter:
           // The height of half the bubble cannot exceed the distance from the
           // anchor point to the closest edge of the superview.
           max_height =
               MIN(distance_to_top_edge, distance_to_bottom_edge) * 2.0f;
           break;
         case BubbleAlignmentBottomOrTrailing:
           // The bubble can use the space from the anchor point to the top
           // edge.
           max_height = distance_to_top_edge + bubble_alignment_offset;
           break;
       }
       break;
   }
   // Round up the height.
   return ceil(max_height);
 }

 }  // namespace

 namespace bubble_util {

 CGFloat BubbleDefaultAlignmentOffset() {
   // This is used to replace a constant that would change based on the flag.
   return 29;
 }

 CGPoint AnchorPoint(CGRect target_frame, BubbleArrowDirection arrow_direction) {
   CGPoint anchor_point;
   bool is_rtl = base::i18n::IsRTL();
   switch (arrow_direction) {
     case BubbleArrowDirectionUp:
       anchor_point.x = CGRectGetMidX(target_frame);
       anchor_point.y = CGRectGetMaxY(target_frame);
       break;
     case BubbleArrowDirectionDown:
       anchor_point.x = CGRectGetMidX(target_frame);
       anchor_point.y = CGRectGetMinY(target_frame);
       break;
     case BubbleArrowDirectionLeading:
     case BubbleArrowDirectionTrailing:
       anchor_point.x = IsArrowPointingLeft(arrow_direction, is_rtl)
                            ? CGRectGetMaxX(target_frame)
                            : CGRectGetMinX(target_frame);
       anchor_point.y = CGRectGetMidY(target_frame);
       break;
   }
   return anchor_point;
 }

 // Calculate the maximum size of the bubble such that it stays within its
 // superview's bounding coordinate space and does not overlap the other side of
 // the anchor point. `anchor_point` is the point on the target UI element the
 // bubble is anchored at in the bubble's superview's coordinate system.
 // `bubble_alignment_offset` is the distance from the leading edge of the bubble
 // to the anchor point if leading aligned, and from the trailing edge of the
 // bubble to the anchor point if trailing aligned. `direction` is the bubble's
 // direction. `alignment` is the bubble's alignment. `bounding_size` is the size
 // of the superview. `is_rtl` is `true` if the coordinates are in right-to-left
 // language coordinates and `false` otherwise. This method is unit tested so it
 // cannot be in the above anonymous namespace.
 CGSize BubbleMaxSize(CGPoint anchor_point,
                      CGFloat bubble_alignment_offset,
                      BubbleArrowDirection direction,
                      BubbleAlignment alignment,
                      CGSize bounding_size,
                      bool is_rtl) {
   CGFloat max_width =
       BubbleMaxWidth(anchor_point.x, direction, bubble_alignment_offset,
                      alignment, bounding_size.width, is_rtl);
   CGFloat max_height =
       BubbleMaxHeight(anchor_point.y, direction, bubble_alignment_offset,
                       alignment, bounding_size.height);
   return CGSizeMake(max_width, max_height);
 }

 CGSize BubbleMaxSize(CGPoint anchor_point,
                      CGFloat bubble_alignment_offset,
                      BubbleArrowDirection direction,
                      BubbleAlignment alignment,
                      CGSize bounding_size) {
   bool is_rtl = base::i18n::IsRTL();
   return BubbleMaxSize(anchor_point, bubble_alignment_offset, direction,
                        alignment, bounding_size, is_rtl);
 }

 // Calculate the bubble's frame. `anchor_point` is the point on the UI element
 // the bubble is pointing to. `bubble_alignment_offset` is the distance from the
 // leading edge of the bubble to the anchor point if leading aligned, and from
 // the trailing edge of the bubble to the anchor point if trailing aligned.
 // `size` is the size of the bubble. `direction` is the direction the bubble's
 // arrow is pointing. `alignment` is the alignment of the anchor (either
 // leading, centered, or trailing). `bounding_width` is the width of the
 // bubble's superview. `is_rtl` is `true` if the coordinates are in
 // right-to-left language coordinates and `false` otherwise. This method is unit
 // tested so it cannot be in the above anonymous namespace.
 CGRect BubbleFrame(CGPoint anchor_point,
                    CGFloat bubble_alignment_offset,
                    CGSize size,
                    BubbleArrowDirection direction,
                    BubbleAlignment alignment,
                    CGFloat bounding_width,
                    bool is_rtl) {
   CGFloat leading =
       LeadingDistance(anchor_point, direction, bubble_alignment_offset,
                       alignment, size.width, bounding_width, is_rtl);
   CGFloat origin_y = OriginY(anchor_point, direction, bubble_alignment_offset,
                              alignment, size.height);
   // Use a `LayoutRect` to ensure that the bubble is mirrored in RTL contexts.
   base::i18n::TextDirection textDirection =
       is_rtl ? base::i18n::RIGHT_TO_LEFT : base::i18n::LEFT_TO_RIGHT;
   CGRect bubble_frame = LayoutRectGetRectUsingDirection(
       LayoutRectMake(leading, bounding_width, origin_y, size.width,
                      size.height),
       textDirection);
   return bubble_frame;
 }

 CGRect BubbleFrame(CGPoint anchor_point,
                    CGFloat bubble_alignment_offset,
                    CGSize size,
                    BubbleArrowDirection direction,
                    BubbleAlignment alignment,
                    CGFloat bounding_width) {
   bool is_rtl = base::i18n::IsRTL();
   return BubbleFrame(anchor_point, bubble_alignment_offset, size, direction,
                      alignment, bounding_width, is_rtl);
 }

 CGFloat FloatingArrowAlignmentOffset(CGFloat bounding_width,
                                      CGPoint anchor_point,
                                      BubbleAlignment alignment) {
   CGFloat alignment_offset;
   BOOL is_rtl = base::i18n::IsRTL();
   // TODO(crbug.com/40276959): Leading and trailing direction.
   switch (alignment) {
     case BubbleAlignmentTopOrLeading:
       alignment_offset =
           is_rtl ? bounding_width - anchor_point.x : anchor_point.x;
       break;
     case BubbleAlignmentCenter:
       alignment_offset = 0.0f;  // value is ignored when laying out the arrow.
       break;
     case BubbleAlignmentBottomOrTrailing:
       alignment_offset =
           is_rtl ? anchor_point.x : bounding_width - anchor_point.x;
       break;
   }
   // Alignment offset must be greater than `BubbleDefaultAlignmentOffset` to
   // make sure the arrow is in the frame of the background of the bubble. The
   // maximum is set to the middle of the bubble so the arrow stays close to the
   // leading edge when using a leading alignment.
   return MAX(MIN(kBubbleMaxWidth / 2, alignment_offset),
              BubbleDefaultAlignmentOffset());
 }

 }  // namespace bubble_util
	// Copyright 2017 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#import "ios/chrome/browser/bubble/ui_bundled/bubble_util.h"

	#import <ostream>

	#import "base/check_op.h"
	#import "base/i18n/rtl.h"
	#import "base/notreached.h"
	#import "ios/chrome/browser/shared/ui/util/rtl_geometry.h"
	#import "ios/chrome/browser/bubble/ui_bundled/bubble_constants.h"

	namespace {

	// Bubble's maximum width, preserves readability, ensuring that the bubble does
	// not span across wide screens.
	const CGFloat kBubbleMaxWidth = 375.0f;

	// Whether bubble with arrow direction `direction` is pointing left.
	BOOL IsArrowPointingLeft(BubbleArrowDirection direction, bool is_rtl) {
	return direction ==
	(is_rtl ? BubbleArrowDirectionTrailing : BubbleArrowDirectionLeading);
	}

	// Calculate the distance from the bubble's leading edge to the leading edge of
	// its bounding coordinate system. In LTR contexts, the returned float is the
	// x-coordinate of the bubble's origin. This calculation is based on
	// `anchor_point`, which is the point of the target UI element the bubble is
	// anchored at, and the bubble's alignment offset, alignment, direction, and
	// size. The returned float is in the same coordinate system as `anchor_point`,
	// which should be the coordinate system in which the bubble is drawn.
	CGFloat LeadingDistance(CGPoint anchor_point,
	BubbleArrowDirection arrow_direction,
	CGFloat bubble_alignment_offset,
	BubbleAlignment alignment,
	CGFloat bubble_width,
	CGFloat bounding_width,
	bool is_rtl) {
	// Find `leading_offset`, the distance from the bubble's leading edge to the
	// anchor point. This depends on alignment and bubble width.
	CGFloat leading_offset;
	switch (arrow_direction) {
	case BubbleArrowDirectionUp:
	case BubbleArrowDirectionDown:
	switch (alignment) {
	case BubbleAlignmentTopOrLeading:
	leading_offset = bubble_alignment_offset;
	break;
	case BubbleAlignmentCenter:
	leading_offset = bubble_width / 2.0f;
	break;
	case BubbleAlignmentBottomOrTrailing:
	leading_offset = bubble_width - bubble_alignment_offset;
	break;
	default:
	NOTREACHED_IN_MIGRATION() << "Invalid bubble alignment " << alignment;
	break;
	}
	break;
	case BubbleArrowDirectionLeading:
	leading_offset = 0;
	break;
	case BubbleArrowDirectionTrailing:
	leading_offset = bubble_width;
	break;
	}
	CGFloat leading_distance;
	if (is_rtl) {
	leading_distance = bounding_width - (anchor_point.x + leading_offset);
	} else {
	leading_distance = anchor_point.x - leading_offset;
	}
	// Round the leading distance.
	return round(leading_distance);
	}

	// Calculate the y-coordinate of the bubble's origin based on `anchor_point`,
	// the point of the UI element the bubble is anchored at, and the bubble's
	// alignment offset, alignment, direction and size. The returned float is in the
	// same coordinate system as `anchor_point`, which should be the coordinate
	// system in which the bubble is drawn.
	CGFloat OriginY(CGPoint anchor_point,
	BubbleArrowDirection arrow_direction,
	CGFloat bubble_alignment_offset,
	BubbleAlignment alignment,
	CGFloat bubble_height) {
	CGFloat origin_y;
	switch (arrow_direction) {
	case BubbleArrowDirectionUp:
	origin_y = anchor_point.y;
	break;
	case BubbleArrowDirectionDown:
	origin_y = anchor_point.y - bubble_height;
	break;
	case BubbleArrowDirectionLeading:
	case BubbleArrowDirectionTrailing:
	switch (alignment) {
	case BubbleAlignmentTopOrLeading:
	origin_y = anchor_point.y - bubble_alignment_offset;
	break;
	case BubbleAlignmentCenter:
	origin_y = anchor_point.y - bubble_height / 2;
	break;
	case BubbleAlignmentBottomOrTrailing:
	origin_y = anchor_point.y - (bubble_height - bubble_alignment_offset);
	break;
	}
	break;
	}
	// Round down the origin Y.
	return floor(origin_y);
	}

	// Calculate the maximum width of the bubble such that it stays within its
	// bounding coordinate space. `anchor_point_x` is the x-coordinate of the point
	// on the target UI element the bubble is anchored at. It is in the coordinate
	// system in which the bubble is drawn. `direction` is the direction the bubble
	// arrow points to. `bubble_alignment_offset` is the distance from the leading
	// edge of the bubble to the anchor point if leading aligned, and from the
	// trailing edge of the bubble to the anchor point if trailing aligned.
	// `alignment` is the bubble's alignment, `bounding_width` is the width of the
	// coordinate space in which the bubble is drawn, and `is_rtl` is true if the
	// language is RTL and `false` otherwise.
	CGFloat BubbleMaxWidth(CGFloat anchor_point_x,
	BubbleArrowDirection direction,
	CGFloat bubble_alignment_offset,
	BubbleAlignment alignment,
	CGFloat bounding_width,
	bool is_rtl) {
	CGFloat max_width;
	// Space on the left of the anchor point.
	CGFloat distance_to_left_edge = anchor_point_x;
	// Space on the right of the anchor point.
	CGFloat distance_to_right_edge = bounding_width - anchor_point_x;
	switch (direction) {
	case BubbleArrowDirectionUp:
	case BubbleArrowDirectionDown:
	switch (alignment) {
	case BubbleAlignmentTopOrLeading:
	// The bubble can use the space from the anchor point to the trailing
	// edge.
	max_width =
	(is_rtl ? distance_to_left_edge : distance_to_right_edge) +
	bubble_alignment_offset;
	break;
	case BubbleAlignmentCenter:
	// The width of half the bubble cannot exceed the distance from the
	// anchor point to the closest edge of the superview.
	max_width = MIN(distance_to_left_edge, distance_to_right_edge) * 2.0f;
	break;
	case BubbleAlignmentBottomOrTrailing:
	// The bubble can use the space from the anchor point to the leading
	// edge.
	max_width =
	(is_rtl ? distance_to_right_edge : distance_to_left_edge) +
	bubble_alignment_offset;
	break;
	default:
	NOTREACHED_IN_MIGRATION() << "Invalid bubble alignment " << alignment;
	break;
	}
	break;
	case BubbleArrowDirectionLeading:
	case BubbleArrowDirectionTrailing:
	if (IsArrowPointingLeft(direction, is_rtl)) {
	max_width = distance_to_right_edge;
	} else {
	max_width = distance_to_left_edge;
	}
	break;
	}
	// Round up the width.
	return ceil(MIN(max_width, kBubbleMaxWidth));
	}

	// Calculate the maximum height of the bubble such that it stays within its
	// bounding coordinate space. `anchor_point_y` is the y-coordinate of the point
	// on the target UI element the bubble is anchored at. It is in the coordinate
	// system in which the bubble is drawn. `direction` is the direction the arrow
	// is pointing. `bubble_alignment_offset` is the distance from the leading or
	// top edge of the bubble to the anchor point if leading aligned, and from the
	// bottom or trailing edge of the bubble to the anchor point if trailing
	// aligned. `alignment` is the bubble's alignment, `bounding_height` is the
	// height of the coordinate space in which the bubble is drawn.
	CGFloat BubbleMaxHeight(CGFloat anchor_point_y,
	BubbleArrowDirection direction,
	CGFloat bubble_alignment_offset,
	BubbleAlignment alignment,
	CGFloat bounding_height) {
	CGFloat max_height;
	// Space on the top of the anchor point.
	CGFloat distance_to_top_edge = anchor_point_y;
	// Space on the bottom of the anchor point.
	CGFloat distance_to_bottom_edge = bounding_height - anchor_point_y;
	switch (direction) {
	case BubbleArrowDirectionUp:
	max_height = distance_to_bottom_edge;
	break;
	case BubbleArrowDirectionDown:
	max_height = distance_to_top_edge;
	break;
	case BubbleArrowDirectionLeading:
	case BubbleArrowDirectionTrailing:
	switch (alignment) {
	case BubbleAlignmentTopOrLeading:
	// The bubble can use the space from the anchor point to the bottom
	// edge.
	max_height = distance_to_bottom_edge + bubble_alignment_offset;
	break;
	case BubbleAlignmentCenter:
	// The height of half the bubble cannot exceed the distance from the
	// anchor point to the closest edge of the superview.
	max_height =
	MIN(distance_to_top_edge, distance_to_bottom_edge) * 2.0f;
	break;
	case BubbleAlignmentBottomOrTrailing:
	// The bubble can use the space from the anchor point to the top
	// edge.
	max_height = distance_to_top_edge + bubble_alignment_offset;
	break;
	}
	break;
	}
	// Round up the height.
	return ceil(max_height);
	}

	} // namespace

	namespace bubble_util {

	CGFloat BubbleDefaultAlignmentOffset() {
	// This is used to replace a constant that would change based on the flag.
	return 29;
	}

	CGPoint AnchorPoint(CGRect target_frame, BubbleArrowDirection arrow_direction) {
	CGPoint anchor_point;
	bool is_rtl = base::i18n::IsRTL();
	switch (arrow_direction) {
	case BubbleArrowDirectionUp:
	anchor_point.x = CGRectGetMidX(target_frame);
	anchor_point.y = CGRectGetMaxY(target_frame);
	break;
	case BubbleArrowDirectionDown:
	anchor_point.x = CGRectGetMidX(target_frame);
	anchor_point.y = CGRectGetMinY(target_frame);
	break;
	case BubbleArrowDirectionLeading:
	case BubbleArrowDirectionTrailing:
	anchor_point.x = IsArrowPointingLeft(arrow_direction, is_rtl)
	? CGRectGetMaxX(target_frame)
	: CGRectGetMinX(target_frame);
	anchor_point.y = CGRectGetMidY(target_frame);
	break;
	}
	return anchor_point;
	}

	// Calculate the maximum size of the bubble such that it stays within its
	// superview's bounding coordinate space and does not overlap the other side of
	// the anchor point. `anchor_point` is the point on the target UI element the
	// bubble is anchored at in the bubble's superview's coordinate system.
	// `bubble_alignment_offset` is the distance from the leading edge of the bubble
	// to the anchor point if leading aligned, and from the trailing edge of the
	// bubble to the anchor point if trailing aligned. `direction` is the bubble's
	// direction. `alignment` is the bubble's alignment. `bounding_size` is the size
	// of the superview. `is_rtl` is `true` if the coordinates are in right-to-left
	// language coordinates and `false` otherwise. This method is unit tested so it
	// cannot be in the above anonymous namespace.
	CGSize BubbleMaxSize(CGPoint anchor_point,
	CGFloat bubble_alignment_offset,
	BubbleArrowDirection direction,
	BubbleAlignment alignment,
	CGSize bounding_size,
	bool is_rtl) {
	CGFloat max_width =
	BubbleMaxWidth(anchor_point.x, direction, bubble_alignment_offset,
	alignment, bounding_size.width, is_rtl);
	CGFloat max_height =
	BubbleMaxHeight(anchor_point.y, direction, bubble_alignment_offset,
	alignment, bounding_size.height);
	return CGSizeMake(max_width, max_height);
	}

	CGSize BubbleMaxSize(CGPoint anchor_point,
	CGFloat bubble_alignment_offset,
	BubbleArrowDirection direction,
	BubbleAlignment alignment,
	CGSize bounding_size) {
	bool is_rtl = base::i18n::IsRTL();
	return BubbleMaxSize(anchor_point, bubble_alignment_offset, direction,
	alignment, bounding_size, is_rtl);
	}

	// Calculate the bubble's frame. `anchor_point` is the point on the UI element
	// the bubble is pointing to. `bubble_alignment_offset` is the distance from the
	// leading edge of the bubble to the anchor point if leading aligned, and from
	// the trailing edge of the bubble to the anchor point if trailing aligned.
	// `size` is the size of the bubble. `direction` is the direction the bubble's
	// arrow is pointing. `alignment` is the alignment of the anchor (either
	// leading, centered, or trailing). `bounding_width` is the width of the
	// bubble's superview. `is_rtl` is `true` if the coordinates are in
	// right-to-left language coordinates and `false` otherwise. This method is unit
	// tested so it cannot be in the above anonymous namespace.
	CGRect BubbleFrame(CGPoint anchor_point,
	CGFloat bubble_alignment_offset,
	CGSize size,
	BubbleArrowDirection direction,
	BubbleAlignment alignment,
	CGFloat bounding_width,
	bool is_rtl) {
	CGFloat leading =
	LeadingDistance(anchor_point, direction, bubble_alignment_offset,
	alignment, size.width, bounding_width, is_rtl);
	CGFloat origin_y = OriginY(anchor_point, direction, bubble_alignment_offset,
	alignment, size.height);
	// Use a `LayoutRect` to ensure that the bubble is mirrored in RTL contexts.
	base::i18n::TextDirection textDirection =
	is_rtl ? base::i18n::RIGHT_TO_LEFT : base::i18n::LEFT_TO_RIGHT;
	CGRect bubble_frame = LayoutRectGetRectUsingDirection(
	LayoutRectMake(leading, bounding_width, origin_y, size.width,
	size.height),
	textDirection);
	return bubble_frame;
	}

	CGRect BubbleFrame(CGPoint anchor_point,
	CGFloat bubble_alignment_offset,
	CGSize size,
	BubbleArrowDirection direction,
	BubbleAlignment alignment,
	CGFloat bounding_width) {
	bool is_rtl = base::i18n::IsRTL();
	return BubbleFrame(anchor_point, bubble_alignment_offset, size, direction,
	alignment, bounding_width, is_rtl);
	}

	CGFloat FloatingArrowAlignmentOffset(CGFloat bounding_width,
	CGPoint anchor_point,
	BubbleAlignment alignment) {
	CGFloat alignment_offset;
	BOOL is_rtl = base::i18n::IsRTL();
	// TODO(crbug.com/40276959): Leading and trailing direction.
	switch (alignment) {
	case BubbleAlignmentTopOrLeading:
	alignment_offset =
	is_rtl ? bounding_width - anchor_point.x : anchor_point.x;
	break;
	case BubbleAlignmentCenter:
	alignment_offset = 0.0f; // value is ignored when laying out the arrow.
	break;
	case BubbleAlignmentBottomOrTrailing:
	alignment_offset =
	is_rtl ? anchor_point.x : bounding_width - anchor_point.x;
	break;
	}
	// Alignment offset must be greater than `BubbleDefaultAlignmentOffset` to
	// make sure the arrow is in the frame of the background of the bubble. The
	// maximum is set to the middle of the bubble so the arrow stays close to the
	// leading edge when using a leading alignment.
	return MAX(MIN(kBubbleMaxWidth / 2, alignment_offset),
	BubbleDefaultAlignmentOffset());
	}

	} // namespace bubble_util