Updated contents view rounded corner border (#31583)

Resolves brave/brave-browser#49755 This PR added different contents border radius per platform. LayoutProvider will give border radius per platform as we want different radius per platform. In same platform, different radius could be used( kRoundedCornersBorderRadius or kRoundedCornersBorderRadiusAtWindowCorner). BraveContentsViewUtil::GetRoundedCornersForContentsView() will give proper value for contents view based on some conditions. TEST=BraveBrowserViewWithRoundedCornersTest.*
2025-11-20 07:55:06 +09:00
parent ddfff017e2
commit 7acb9adb9a
24 changed files with 385 additions and 66 deletions
@@ -503,8 +503,6 @@ source_set("ui") {
      "views/bookmarks/saved_tab_groups/brave_saved_tab_group_button.h",
      "views/brave_javascript_tab_modal_dialog_view_views.cc",
      "views/brave_javascript_tab_modal_dialog_view_views.h",
-      "views/brave_layout_provider.cc",
-      "views/brave_layout_provider.h",
      "views/brave_news/brave_news_bubble_view.cc",
      "views/brave_news/brave_news_bubble_view.h",
      "views/brave_news/brave_news_feed_item_view.cc",
@@ -532,8 +530,6 @@ source_set("ui") {
      "views/frame/brave_browser_widget.h",
      "views/frame/brave_contents_layout_manager.cc",
      "views/frame/brave_contents_layout_manager.h",
-      "views/frame/brave_contents_view_util.cc",
-      "views/frame/brave_contents_view_util.h",
      "views/frame/brave_non_client_hit_test_helper.cc",
      "views/frame/brave_non_client_hit_test_helper.h",
      "views/frame/brave_opaque_browser_frame_view.cc",
@@ -627,6 +623,8 @@ source_set("ui") {
    deps += [
      "//brave/browser/ui/darker_theme",
      "//brave/browser/ui/side_panel",
+      "//brave/browser/ui/views:layout_provider",
+      "//brave/browser/ui/views/frame",
      "//brave/browser/ui/views/location_bar",
      "//chrome/browser:shell_integration",
      "//chrome/browser/devtools",
@@ -31,6 +31,8 @@ if (is_android) {
 }
 if (toolkit_views) {
  brave_ui_allow_circular_includes_from += [
+    "//brave/browser/ui/views:layout_provider",
+    "//brave/browser/ui/views/frame",
    "//brave/browser/ui/views/frame/split_view",
    "//brave/browser/ui/views/frame/vertical_tabs",
    "//brave/browser/ui/views/location_bar",
@@ -64,6 +64,7 @@ source_set("browser_tests") {
    ":sidebar",
    "//base",
    "//brave/app:command_ids",
+    "//brave/browser/ui/views/frame",
    "//brave/browser/ui/views/frame/split_view",
    "//brave/components/ai_chat/core/common/buildflags",
    "//brave/components/playlist/core/common",
@@ -0,0 +1,23 @@
+# Copyright (c) 2025 The Brave Authors. All rights reserved.
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this file,
+# You can obtain one at https://mozilla.org/MPL/2.0/.
+
+source_set("layout_provider") {
+  sources = [
+    "brave_layout_provider.cc",
+    "brave_layout_provider.h",
+  ]
+
+  if (is_mac) {
+    sources += [
+      "brave_layout_provider_mac.h",
+      "brave_layout_provider_mac.mm",
+    ]
+  }
+
+  deps = [
+    "//base",
+    "//ui/views",
+  ]
+}
@@ -5,7 +5,21 @@

 #include "brave/browser/ui/views/brave_layout_provider.h"

-#include "ui/views/layout/layout_provider.h"
+#include "build/build_config.h"
+
+#if BUILDFLAG(IS_MAC)
+#include "brave/browser/ui/views/brave_layout_provider_mac.h"
+#endif
+
+// static
+std::unique_ptr<views::LayoutProvider>
+ChromeLayoutProvider::CreateLayoutProvider() {
+#if BUILDFLAG(IS_MAC)
+  return std::make_unique<BraveLayoutProviderMac>();
+#else
+  return std::make_unique<BraveLayoutProvider>();
+#endif
+}

 int BraveLayoutProvider::GetCornerRadiusMetric(views::Emphasis emphasis,
                                               const gfx::Size& size) const {
@@ -22,6 +36,11 @@ int BraveLayoutProvider::GetCornerRadiusMetric(views::Emphasis emphasis,
  }
 }

+int BraveLayoutProvider::GetCornerRadiusMetric(
+    views::ShapeContextTokensOverride token) const {
+  return LayoutProvider::GetCornerRadiusMetric(token);
+}
+
 int BraveLayoutProvider::GetDistanceMetric(int metric) const {
  if (metric == views::DISTANCE_CONTROL_VERTICAL_TEXT_PADDING) {
    return 8;
@@ -17,6 +17,8 @@ class BraveLayoutProvider : public ChromeLayoutProvider {

  int GetCornerRadiusMetric(views::Emphasis emphasis,
                            const gfx::Size& size = gfx::Size()) const override;
+  int GetCornerRadiusMetric(
+      views::ShapeContextTokensOverride token) const override;
  int GetDistanceMetric(int metric) const override;
 };

@@ -0,0 +1,21 @@
+/* Copyright (c) 2025 The Brave Authors. All rights reserved.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+#ifndef BRAVE_BROWSER_UI_VIEWS_BRAVE_LAYOUT_PROVIDER_MAC_H_
+#define BRAVE_BROWSER_UI_VIEWS_BRAVE_LAYOUT_PROVIDER_MAC_H_
+
+#include "brave/browser/ui/views/brave_layout_provider.h"
+
+class BraveLayoutProviderMac : public BraveLayoutProvider {
+ public:
+  using BraveLayoutProvider::BraveLayoutProvider;
+  ~BraveLayoutProviderMac() override;
+
+  // BraveLayoutProvider
+  int GetCornerRadiusMetric(
+      views::ShapeContextTokensOverride token) const override;
+};
+
+#endif  // BRAVE_BROWSER_UI_VIEWS_BRAVE_LAYOUT_PROVIDER_MAC_H_
@@ -0,0 +1,26 @@
+/* Copyright (c) 2025 The Brave Authors. All rights reserved.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+#include "brave/browser/ui/views/brave_layout_provider_mac.h"
+
+BraveLayoutProviderMac::~BraveLayoutProviderMac() = default;
+
+int BraveLayoutProviderMac::GetCornerRadiusMetric(
+    views::ShapeContextTokensOverride token) const {
+  switch (token) {
+    case views::ShapeContextTokensOverride::kRoundedCornersBorderRadius:
+      return 6;
+    case views::ShapeContextTokensOverride::
+        kRoundedCornersBorderRadiusAtWindowCorner:
+      if (@available(macOS 26, *)) {
+        return 17;
+      }
+      return 6;
+    default:
+      break;
+  }
+
+  return LayoutProvider::GetCornerRadiusMetric(token);
+}
@@ -3,6 +3,26 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this file,
 # You can obtain one at https://mozilla.org/MPL/2.0/.

+source_set("frame") {
+  sources = [
+    "brave_contents_view_util.cc",
+    "brave_contents_view_util.h",
+  ]
+
+  deps = [
+    "//base",
+    "//chrome/browser/profiles:profile",
+    "//chrome/browser/ui/browser_window",
+    "//chrome/browser/ui/tabs:tab_strip",
+    "//chrome/common:constants",
+    "//components/prefs",
+    "//components/tabs:public",
+    "//components/tabs:split_tabs",
+    "//ui/compositor",
+    "//ui/views",
+  ]
+}
+
 source_set("browser_tests") {
  testonly = true
  defines = [ "HAS_OUT_OF_PROC_TEST_RUNNER" ]
@@ -11,6 +31,7 @@ source_set("browser_tests") {
      [ "//brave/browser/ui/views/frame/brave_browser_view_browsertest.cc" ]

  deps = [
+    ":frame",
    "//base",
    "//chrome/browser",
    "//chrome/browser/profiles:profile",
@@ -1102,7 +1102,8 @@ void BraveBrowserView::UpdateWebViewRoundedCorners() {
  gfx::RoundedCornersF corners;

  if (ShouldUseBraveWebViewRoundedCornersForContents(browser_.get())) {
-    corners = gfx::RoundedCornersF(BraveContentsViewUtil::kBorderRadius);
+    corners = BraveContentsViewUtil::GetRoundedCornersForContentsView(browser_,
+                                                                      nullptr);
  }

  // In fullscreen-for-tab mode (e.g. full-screen video), no corners should be
@@ -42,10 +42,15 @@
 #include "ui/compositor/layer.h"
 #include "ui/gfx/animation/animation.h"
 #include "ui/gfx/animation/animation_test_api.h"
+#include "ui/views/layout/layout_provider.h"
 #include "ui/views/view_class_properties.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"

+using views::ShapeContextTokensOverride::kRoundedCornersBorderRadius;
+using views::ShapeContextTokensOverride::
+    kRoundedCornersBorderRadiusAtWindowCorner;
+
 class BraveBrowserViewTest : public InProcessBrowserTest {
 public:
  BraveBrowserViewTest() = default;
@@ -254,6 +259,13 @@ IN_PROC_BROWSER_TEST_P(BraveBrowserViewWithRoundedCornersTest,
  views::View* side_panel = browser_view()->contents_height_side_panel();
  const auto rounded_corners_margin = BraveContentsViewUtil::kMarginThickness;

+  auto* layout_provider = views::LayoutProvider::Get();
+  const auto rounded_corners_border_radius =
+      layout_provider->GetCornerRadiusMetric(kRoundedCornersBorderRadius);
+  const auto rounded_corners_border_radius_at_window_corner =
+      layout_provider->GetCornerRadiusMetric(
+          kRoundedCornersBorderRadiusAtWindowCorner);
+
  if (IsRoundedCornersEnabled()) {
    // Check contents container has margin by comparing simply its left & bottom
    // with main container's local bounds. As views local bounds' origin is (0,
@@ -269,8 +281,23 @@ IN_PROC_BROWSER_TEST_P(BraveBrowserViewWithRoundedCornersTest,
              side_panel->GetProperty(views::kMarginsKey)->bottom());
    EXPECT_EQ(rounded_corners_margin,
              side_panel->GetProperty(views::kMarginsKey)->right());
-    EXPECT_EQ(gfx::RoundedCornersF(BraveContentsViewUtil::kBorderRadius),
+    EXPECT_EQ(gfx::RoundedCornersF(rounded_corners_border_radius),
              side_panel->layer()->rounded_corner_radii());
+    const auto contents_view_radii = browser_view()
+                                         ->GetActiveContentsContainerView()
+                                         ->contents_view()
+                                         ->GetBackgroundRadii();
+    EXPECT_EQ(BraveContentsViewUtil::GetRoundedCornersForContentsView(browser(),
+                                                                      nullptr),
+              contents_view_radii);
+    EXPECT_EQ(rounded_corners_border_radius, contents_view_radii.upper_left());
+    EXPECT_EQ(rounded_corners_border_radius, contents_view_radii.upper_right());
+
+    // lower-left radius should be radius around window as there is no ui
+    // between browser window border and contents.
+    EXPECT_EQ(rounded_corners_border_radius_at_window_corner,
+              contents_view_radii.lower_left());
+    EXPECT_EQ(rounded_corners_border_radius, contents_view_radii.lower_right());
  } else {
    // Check contents container doesn't have any margin. So, contents container
    // should have same left & bottom with main container.
@@ -286,6 +313,10 @@ IN_PROC_BROWSER_TEST_P(BraveBrowserViewWithRoundedCornersTest,

    // Panel doesn't have layer when its shadow is not set.
    EXPECT_FALSE(side_panel->layer());
+    EXPECT_EQ(gfx::RoundedCornersF(), browser_view()
+                                          ->GetActiveContentsContainerView()
+                                          ->contents_view()
+                                          ->GetBackgroundRadii());
  }

  // Create split tab and check contents container/sidebar has rounded corners
@@ -302,9 +333,26 @@ IN_PROC_BROWSER_TEST_P(BraveBrowserViewWithRoundedCornersTest,
            side_panel->GetProperty(views::kMarginsKey)->bottom());
  EXPECT_EQ(rounded_corners_margin,
            side_panel->GetProperty(views::kMarginsKey)->right());
-  EXPECT_EQ(gfx::RoundedCornersF(BraveContentsViewUtil::kBorderRadius),
+  EXPECT_EQ(gfx::RoundedCornersF(rounded_corners_border_radius),
            side_panel->layer()->rounded_corner_radii());

+  const auto start_contents_view_radii = browser_view()
+                                             ->GetContentsContainerViews()[0]
+                                             ->contents_view()
+                                             ->GetBackgroundRadii();
+  const auto end_contents_view_radii = browser_view()
+                                           ->GetContentsContainerViews()[1]
+                                           ->contents_view()
+                                           ->GetBackgroundRadii();
+  EXPECT_EQ(rounded_corners_border_radius_at_window_corner,
+            start_contents_view_radii.lower_left());
+  EXPECT_EQ(rounded_corners_border_radius,
+            start_contents_view_radii.lower_right());
+  EXPECT_EQ(rounded_corners_border_radius,
+            end_contents_view_radii.lower_left());
+  EXPECT_EQ(rounded_corners_border_radius,
+            end_contents_view_radii.lower_right());
+
  // Create new active tab to not have split tab as a active tab.
  // Check contents container doesn't have margin when rounded corners is
  // disabled.
@@ -320,8 +368,23 @@ IN_PROC_BROWSER_TEST_P(BraveBrowserViewWithRoundedCornersTest,
              side_panel->GetProperty(views::kMarginsKey)->bottom());
    EXPECT_EQ(rounded_corners_margin,
              side_panel->GetProperty(views::kMarginsKey)->right());
-    EXPECT_EQ(gfx::RoundedCornersF(BraveContentsViewUtil::kBorderRadius),
+    EXPECT_EQ(gfx::RoundedCornersF(rounded_corners_border_radius),
              side_panel->layer()->rounded_corner_radii());
+    const auto contents_view_radii = browser_view()
+                                         ->GetActiveContentsContainerView()
+                                         ->contents_view()
+                                         ->GetBackgroundRadii();
+    EXPECT_EQ(BraveContentsViewUtil::GetRoundedCornersForContentsView(browser(),
+                                                                      nullptr),
+              contents_view_radii);
+    EXPECT_EQ(rounded_corners_border_radius, contents_view_radii.upper_left());
+    EXPECT_EQ(rounded_corners_border_radius, contents_view_radii.upper_right());
+
+    // lower-left radius should be radius around window as there is no ui
+    // between browser window border and contents.
+    EXPECT_EQ(rounded_corners_border_radius_at_window_corner,
+              contents_view_radii.lower_left());
+    EXPECT_EQ(rounded_corners_border_radius, contents_view_radii.lower_right());
  } else {
    EXPECT_EQ(contents_container->bounds().x(),
              main_container->GetLocalBounds().x());
@@ -331,6 +394,10 @@ IN_PROC_BROWSER_TEST_P(BraveBrowserViewWithRoundedCornersTest,
    EXPECT_EQ(0, side_panel->GetProperty(views::kMarginsKey)->bottom());
    EXPECT_EQ(0, side_panel->GetProperty(views::kMarginsKey)->right());
    EXPECT_FALSE(side_panel->layer());
+    EXPECT_EQ(gfx::RoundedCornersF(), browser_view()
+                                          ->GetActiveContentsContainerView()
+                                          ->contents_view()
+                                          ->GetBackgroundRadii());
  }
 }

@@ -7,9 +7,23 @@

 #include "base/check.h"
 #include "brave/browser/ui/views/frame/brave_browser_view.h"
+#include "brave/browser/ui/views/tabs/vertical_tab_utils.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser_window/public/browser_window_interface.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/common/pref_names.h"
+#include "components/prefs/pref_service.h"
+#include "components/tabs/public/split_tab_data.h"
+#include "components/tabs/public/split_tab_id.h"
 #include "ui/compositor/layer.h"
+#include "ui/gfx/geometry/rounded_corners_f.h"
+#include "ui/views/layout/layout_provider.h"
 #include "ui/views/view.h"

+using views::ShapeContextTokensOverride::kRoundedCornersBorderRadius;
+using views::ShapeContextTokensOverride::
+    kRoundedCornersBorderRadiusAtWindowCorner;
+
 namespace {

 constexpr ViewShadow::ShadowParameters kShadow{
@@ -22,8 +36,12 @@ constexpr ViewShadow::ShadowParameters kShadow{
 std::unique_ptr<ViewShadow> BraveContentsViewUtil::CreateShadow(
    views::View* view) {
  DCHECK(view);
-  auto shadow = std::make_unique<ViewShadow>(view, kBorderRadius, kShadow);
-  view->layer()->SetRoundedCornerRadius(gfx::RoundedCornersF(kBorderRadius));
+  auto* layout_provider = views::LayoutProvider::Get();
+  auto shadow = std::make_unique<ViewShadow>(
+      view, layout_provider->GetCornerRadiusMetric(kRoundedCornersBorderRadius),
+      kShadow);
+  view->layer()->SetRoundedCornerRadius(gfx::RoundedCornersF(
+      layout_provider->GetCornerRadiusMetric(kRoundedCornersBorderRadius)));
  view->layer()->SetIsFastRoundedCorner(true);
  return shadow;
 }
@@ -34,3 +52,75 @@ int BraveContentsViewUtil::GetRoundedCornersWebViewMargin(Browser* browser) {
             ? BraveContentsViewUtil::kMarginThickness
             : 0;
 }
+
+// static
+gfx::RoundedCornersF BraveContentsViewUtil::GetRoundedCornersForContentsView(
+    BrowserWindowInterface* browser_window_interface,
+    tabs::TabInterface* tab) {
+  auto* layout_provider = views::LayoutProvider::Get();
+  auto rounded_corners =
+      gfx::RoundedCornersF(layout_provider->GetCornerRadiusMetric(
+          kRoundedCornersBorderRadiusAtWindowCorner));
+  const auto rounded_corners_border_radius =
+      layout_provider->GetCornerRadiusMetric(kRoundedCornersBorderRadius);
+  rounded_corners.set_upper_left(rounded_corners_border_radius);
+  rounded_corners.set_upper_right(rounded_corners_border_radius);
+
+  const bool show_vertical_tab = tabs::utils::ShouldShowVerticalTabs(
+      browser_window_interface->GetBrowserForMigrationOnly());
+  auto* browser_view = BraveBrowserView::From(
+      BrowserView::GetBrowserViewForBrowser(browser_window_interface));
+
+  // Can null during the startup.
+  if (!browser_view) {
+    return rounded_corners;
+  }
+
+  const bool is_sidebar_visible = browser_view->IsSidebarVisible();
+
+  // Check there is another ui between contents view and browser window border.
+  // It affects contents view's lower-left/right radius.
+  bool has_left_side_ui = false;
+  bool has_right_side_ui = false;
+
+  if (show_vertical_tab) {
+    if (tabs::utils::IsVerticalTabOnRight(
+            browser_window_interface->GetBrowserForMigrationOnly())) {
+      has_right_side_ui = true;
+    } else {
+      has_left_side_ui = true;
+    }
+  }
+
+  if (is_sidebar_visible) {
+    if (browser_window_interface->GetProfile()->GetPrefs()->GetBoolean(
+            prefs::kSidePanelHorizontalAlignment)) {
+      has_right_side_ui = true;
+    } else {
+      has_left_side_ui = true;
+    }
+  }
+
+  if (tab && tab->IsSplit()) {
+    auto split_tab_id = tab->GetSplit();
+    auto* tab_strip_model = browser_window_interface->GetTabStripModel();
+    auto* split_data = tab_strip_model->GetSplitData(*split_tab_id);
+
+    // Handle each split tab's lower edge.
+    if (split_data->ListTabs()[0] == tab) {
+      has_right_side_ui = true;
+    } else {
+      has_left_side_ui = true;
+    }
+  }
+
+  if (has_right_side_ui) {
+    rounded_corners.set_lower_right(rounded_corners_border_radius);
+  }
+
+  if (has_left_side_ui) {
+    rounded_corners.set_lower_left(rounded_corners_border_radius);
+  }
+
+  return rounded_corners;
+}
@@ -11,29 +11,36 @@
 #include "brave/browser/ui/views/view_shadow.h"

 class Browser;
+class BrowserWindowInterface;
+
+namespace gfx {
+class RoundedCornersF;
+}  // namespace gfx
+
+namespace tabs {
+class TabInterface;
+}  // namespace tabs

 namespace views {
 class View;
-}
+}  // namespace views

 class BraveContentsViewUtil {
 public:
  // The distance between main content areas and other UI elements.
  static constexpr int kMarginThickness = 4;

-  // The border radius applied to main content areas.
-#if BUILDFLAG(IS_MAC)
-  static constexpr int kBorderRadius = 7;
-#else
-  static constexpr int kBorderRadius = 4;
-#endif
-
  // Creates a drop shadow for the specified content area view.
  static std::unique_ptr<ViewShadow> CreateShadow(views::View* view);

  // If rounded corners are enabled, returns the additional margin required to
  // get the shadow to display properly. Otherwise 0.
  static int GetRoundedCornersWebViewMargin(Browser* browser);
+
+  // Pass content's tab to |tab| if it needs to consider split view state.
+  static gfx::RoundedCornersF GetRoundedCornersForContentsView(
+      BrowserWindowInterface* browser_window_interface,
+      tabs::TabInterface* tab);
 };

 #endif  // BRAVE_BROWSER_UI_VIEWS_FRAME_BRAVE_CONTENTS_VIEW_UTIL_H_
@@ -17,6 +17,7 @@ source_set("split_view") {

  deps = [
    "//brave/browser/ui/tabs:tab_model",
+    "//brave/browser/ui/views/frame",
    "//brave/components/vector_icons",
    "//chrome/browser/profiles:profile",
    "//chrome/browser/ui:ui_features",
@@ -20,6 +20,7 @@
 #include "chrome/browser/ui/views/frame/contents_container_outline.h"
 #include "chrome/browser/ui/views/frame/multi_contents_view_mini_toolbar.h"
 #include "chrome/browser/ui/views/frame/scrim_view.h"
+#include "components/tabs/public/tab_interface.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "ui/base/metadata/metadata_impl_macros.h"
@@ -27,7 +28,9 @@
 #include "ui/compositor/layer.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/rounded_corners_f.h"
 #include "ui/views/border.h"
+#include "ui/views/layout/layout_provider.h"

 namespace {

@@ -104,18 +107,21 @@ void BraveContentsContainerView::UpdateBorderAndOverlay(bool is_in_split,

  // Draw active/inactive outlines around the contents areas and updates mini
  // toolbar visibility.
-  const float border_corner_radius(GetCornerRadius(true));
+  const auto border_corner_radius(GetCornerRadius(true));
  if (is_active) {
-    SetBorder(views::CreateRoundedRectBorder(
-        kBorderThickness, border_corner_radius,
-        kColorBraveSplitViewActiveWebViewBorder));
+    SetBorder(views::CreateBorderPainter(
+        views::Painter::CreateSolidRoundRectPainterWithVariableRadius(
+            GetColorProvider()->GetColor(
+                kColorBraveSplitViewActiveWebViewBorder),
+            border_corner_radius, gfx::Insets(), SkBlendMode::kSrc),
+        gfx::Insets(kBorderThickness)));
  } else {
    SetBorder(views::CreateBorderPainter(
        views::Painter::CreateRoundRectWith1PxBorderPainter(
            GetColorProvider()->GetColor(
                kColorBraveSplitViewInactiveWebViewBorder),
-            GetColorProvider()->GetColor(kColorToolbar), border_corner_radius,
-            SkBlendMode::kSrc,
+            GetColorProvider()->GetColor(kColorToolbar),
+            gfx::RoundedCornersF(border_corner_radius), SkBlendMode::kSrc,
            /*anti_alias*/ true,
            /*should_border_scale*/ true),
        gfx::Insets(kBorderThickness)));
@@ -123,7 +129,7 @@ void BraveContentsContainerView::UpdateBorderAndOverlay(bool is_in_split,
 }

 void BraveContentsContainerView::UpdateBorderRoundedCorners() {
-  const gfx::RoundedCornersF contents_corner_radius(GetCornerRadius(false));
+  const auto contents_corner_radius(GetCornerRadius(false));

  contents_view_->layer()->SetRoundedCornerRadius(contents_corner_radius);
  contents_view_->holder()->SetCornerRadii(contents_corner_radius);
@@ -134,7 +140,9 @@ void BraveContentsContainerView::UpdateBorderRoundedCorners() {

 #if BUILDFLAG(ENABLE_SPEEDREADER)
  if (reader_mode_toolbar_) {
-    reader_mode_toolbar_->SetCornerRadius(GetCornerRadius(false));
+    reader_mode_toolbar_->SetCornerRadius(
+        views::LayoutProvider::Get()->GetCornerRadiusMetric(
+            views::ShapeContextTokensOverride::kRoundedCornersBorderRadius));
  }
 #endif
 }
@@ -185,19 +193,36 @@ void BraveContentsContainerView::OnReaderModeToolbarActivate(
 }
 #endif

-float BraveContentsContainerView::GetCornerRadius(bool for_border) const {
+gfx::RoundedCornersF BraveContentsContainerView::GetCornerRadius(
+    bool for_border) const {
  auto* exclusive_access_manager =
      browser_view_->browser()->GetFeatures().exclusive_access_manager();
  if (exclusive_access_manager &&
      exclusive_access_manager->fullscreen_controller()->IsTabFullscreen()) {
-    return 0;
+    return {};
  }

-  return BraveBrowserView::ShouldUseBraveWebViewRoundedCornersForContents(
-             browser_view_->browser())
-             ? BraveContentsViewUtil::kBorderRadius +
-                   (for_border ? kBorderThickness : 0)
-             : 0;
+  if (!BraveBrowserView::ShouldUseBraveWebViewRoundedCornersForContents(
+          browser_view_->browser())) {
+    return {};
+  }
+
+  tabs::TabInterface* tab = nullptr;
+  if (is_in_split_ && contents_view_->web_contents()) {
+    tab = tabs::TabInterface::GetFromContents(contents_view_->web_contents());
+  }
+
+  auto rounded_corners =
+      BraveContentsViewUtil::GetRoundedCornersForContentsView(
+          browser_view_->browser(), tab);
+  if (for_border) {
+    return {rounded_corners.upper_left() + kBorderThickness,
+            rounded_corners.upper_right() + kBorderThickness,
+            rounded_corners.lower_right() + kBorderThickness,
+            rounded_corners.lower_left() + kBorderThickness};
+  }
+
+  return rounded_corners;
 }

 BEGIN_METADATA(BraveContentsContainerView)
@@ -17,6 +17,10 @@
 #include "brave/browser/ui/views/speedreader/reader_mode_toolbar_view.h"
 #endif

+namespace gfx {
+class RoundedCornersF;
+}  // namespace gfx
+
 class BraveContentsContainerView :
 #if BUILDFLAG(ENABLE_SPEEDREADER)
    public ReaderModeToolbarView::Delegate,
@@ -51,7 +55,7 @@ class BraveContentsContainerView :
  FRIEND_TEST_ALL_PREFIXES(SideBySideEnabledBrowserTest,
                           BraveMultiContentsViewTest);

-  float GetCornerRadius(bool for_border) const;
+  gfx::RoundedCornersF GetCornerRadius(bool for_border) const;

  raw_ref<BrowserView> browser_view_;

@@ -9,6 +9,7 @@

 #include "base/check.h"
 #include "brave/browser/ui/views/frame/brave_browser_view.h"
+#include "brave/browser/ui/views/frame/brave_contents_view_util.h"
 #include "brave/browser/ui/views/frame/split_view/brave_contents_container_view.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
@@ -18,10 +19,6 @@
 #include "ui/base/metadata/metadata_impl_macros.h"
 #include "ui/views/widget/widget.h"

-namespace {
-constexpr auto kSpacingBetweenContentsContainerViews = 4;
-}  // namespace
-
 // static
 BraveMultiContentsView* BraveMultiContentsView::From(MultiContentsView* view) {
  CHECK(view);
@@ -32,8 +29,9 @@ BraveMultiContentsView::BraveMultiContentsView(
    BrowserView* browser_view,
    std::unique_ptr<MultiContentsViewDelegate> delegate)
    : MultiContentsView(browser_view, std::move(delegate)) {
+  // Use rounded corners margin as resize area's width.
  resize_area_->SetPreferredSize(
-      gfx::Size(kSpacingBetweenContentsContainerViews, 0));
+      gfx::Size(BraveContentsViewUtil::kMarginThickness, 0));
  start_contents_view_inset_ = gfx::Insets();
  end_contents_view_inset_ = gfx::Insets();
 }
@@ -25,6 +25,7 @@ source_set("vertical_tabs") {
  deps = [
    "//base",
    "//brave/browser/ui:brave_tab_prefs",
+    "//brave/browser/ui/views/frame",
    "//brave/components/constants",
    "//brave/components/vector_icons",
    "//chrome/app:command_ids",
@@ -54,6 +55,7 @@ source_set("browser_tests") {

  deps = [
    ":vertical_tabs",
+    "//brave/browser/ui/views/frame",
    "//chrome/browser",
    "//chrome/browser/tab_group_sync:factories",
    "//chrome/browser/ui",
@@ -12,6 +12,7 @@ source_set("browser_tests") {
  deps = [
    "//base",
    "//brave/browser/ui/tabs:tab_model",
+    "//brave/browser/ui/views/frame",
    "//brave/browser/ui/views/frame/split_view",
    "//brave/components/resources:strings_grit",
    "//chrome/browser/ui",
@@ -159,7 +159,8 @@ IN_PROC_BROWSER_TEST_F(SideBySideEnabledBrowserTest,
                                                    .exclusive_access_manager()
                                                    ->fullscreen_controller();
  fullscreen_controller->set_is_tab_fullscreen_for_testing(true);
-  EXPECT_EQ(0, start_contents_container_view->GetCornerRadius(true));
+  EXPECT_EQ(gfx::RoundedCornersF(),
+            start_contents_container_view->GetCornerRadius(true));
  fullscreen_controller->set_is_tab_fullscreen_for_testing(false);

  auto* start_contents_web_view =
@@ -169,11 +170,9 @@ IN_PROC_BROWSER_TEST_F(SideBySideEnabledBrowserTest,
  ASSERT_TRUE(start_contents_web_view);
  ASSERT_TRUE(end_contents_web_view);
  EXPECT_EQ(start_contents_web_view->layer()->rounded_corner_radii(),
-            gfx::RoundedCornersF(
-                start_contents_container_view->GetCornerRadius(false)));
+            start_contents_container_view->GetCornerRadius(false));
  EXPECT_EQ(end_contents_web_view->layer()->rounded_corner_radii(),
-            gfx::RoundedCornersF(
-                end_contents_container_view->GetCornerRadius(false)));
+            end_contents_container_view->GetCornerRadius(false));

  // Check borders.
  EXPECT_EQ(gfx::Insets(BraveContentsContainerView::kBorderThickness),
@@ -332,11 +331,13 @@ IN_PROC_BROWSER_TEST_F(SideBySideWithRoundedCornersTest,
  auto* contents_container = brave_browser_view()->contents_container();
  auto* contents_view = brave_browser_view()->GetContentsView();

+  const gfx::RoundedCornersF border_radius(
+      BraveContentsViewUtil::GetRoundedCornersForContentsView(browser(),
+                                                              nullptr));
+
  // Check it has rounded corners.
-  EXPECT_EQ(contents_container->layer()->rounded_corner_radii(),
-            gfx::RoundedCornersF(BraveContentsViewUtil::kBorderRadius));
-  EXPECT_EQ(contents_view->layer()->rounded_corner_radii(),
-            gfx::RoundedCornersF(BraveContentsViewUtil::kBorderRadius));
+  EXPECT_EQ(contents_container->layer()->rounded_corner_radii(), border_radius);
+  EXPECT_EQ(contents_view->layer()->rounded_corner_radii(), border_radius);

  FullscreenController* fullscreen_controller = browser()
                                                    ->GetFeatures()
@@ -354,10 +355,8 @@ IN_PROC_BROWSER_TEST_F(SideBySideWithRoundedCornersTest,
  // Check it has rounded corners again.
  fullscreen_controller->set_is_tab_fullscreen_for_testing(false);
  brave_browser_view()->UpdateWebViewRoundedCorners();
-  EXPECT_EQ(contents_container->layer()->rounded_corner_radii(),
-            gfx::RoundedCornersF(BraveContentsViewUtil::kBorderRadius));
-  EXPECT_EQ(contents_view->layer()->rounded_corner_radii(),
-            gfx::RoundedCornersF(BraveContentsViewUtil::kBorderRadius));
+  EXPECT_EQ(contents_container->layer()->rounded_corner_radii(), border_radius);
+  EXPECT_EQ(contents_view->layer()->rounded_corner_radii(), border_radius);
 }

 // Use for testing brave split view and SideBySide together.
@@ -3,7 +3,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // you can obtain one at http://mozilla.org/MPL/2.0/.

-#include "brave/browser/ui/views/brave_layout_provider.h"
+#include "chrome/browser/ui/views/chrome_layout_provider.h"

 // Replace LayoutProvider creation with our own function.
 // The definition is provided similarly by the override of
@@ -12,8 +12,5 @@
 #include <chrome/browser/ui/views/chrome_layout_provider.cc>
 #undef CreateLayoutProvider

-// static
-std::unique_ptr<views::LayoutProvider>
-ChromeLayoutProvider::CreateLayoutProvider() {
-  return std::make_unique<BraveLayoutProvider>();
-}
+// CreateLayoutProvider() is defined at brave_layout_provider.cc
+// to avoid brave dependencies.
@@ -3,7 +3,6 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at https://mozilla.org/MPL/2.0/. */

-#include "brave/browser/ui/views/frame/brave_contents_view_util.h"
 #include "brave/browser/ui/views/side_panel/side_panel_web_ui_view_utils.h"
 #include "brave/common/pref_names.h"
 #include "brave/components/constants/webui_url_constants.h"
@@ -12,6 +11,7 @@
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/context_menu_params.h"
 #include "content/public/browser/render_frame_host.h"
+#include "ui/views/layout/layout_provider.h"

 #include <chrome/browser/ui/views/side_panel/side_panel_web_ui_view.cc>

@@ -39,7 +39,8 @@ void SidePanelWebUIView::AddedToWidget() {
  auto* profile = Profile::FromBrowserContext(
      contents_wrapper_->web_contents()->GetBrowserContext());
  if (profile->GetPrefs()->GetBoolean(kWebViewRoundedCorners)) {
-    constexpr auto kRadius = BraveContentsViewUtil::kBorderRadius;
-    holder()->SetCornerRadii(gfx::RoundedCornersF(kRadius));
+    holder()->SetCornerRadii(gfx::RoundedCornersF(
+        views::LayoutProvider::Get()->GetCornerRadiusMetric(
+            views::ShapeContextTokensOverride::kRoundedCornersBorderRadius)));
  }
 }
@@ -10,7 +10,18 @@
 namespace views {

 int LayoutProvider::GetCornerRadiusMetric(ShapeContextTokensOverride id) const {
-  return 4;
+  switch (id) {
+    case ShapeContextTokensOverride::kOmniboxExpandedRadius:
+      return 4;
+    case ShapeContextTokensOverride::kRoundedCornersBorderRadius:
+      return 4;
+    case ShapeContextTokensOverride::kRoundedCornersBorderRadiusAtWindowCorner:
+      return 4;
+    default:
+      break;
+  }
+
+  NOTREACHED();
 }

 }  // namespace views
@@ -13,6 +13,8 @@ namespace views {
 // `RoundedOmniboxResultsFrame`.
 enum class ShapeContextTokensOverride {
  kOmniboxExpandedRadius,
+  kRoundedCornersBorderRadius,
+  kRoundedCornersBorderRadiusAtWindowCorner,
 };

 }  // namespace views
@@ -20,9 +22,9 @@ enum class ShapeContextTokensOverride {
 // This function is added to allow callers to retrieve an overriden value for
 // `kOmniboxExpandedRadius` by just replacing `ShapeContextTokens` on the
 // caller.
-#define GetDialogInsetsForContentType                                \
-  Unused();                                                          \
-  int GetCornerRadiusMetric(ShapeContextTokensOverride token) const; \
+#define GetDialogInsetsForContentType                                        \
+  Unused();                                                                  \
+  virtual int GetCornerRadiusMetric(ShapeContextTokensOverride token) const; \
  gfx::Insets GetDialogInsetsForContentType

 #include <ui/views/layout/layout_provider.h>  // IWYU pragma: export