fix: improved the appearance of shadows and borders on frameless windows on Wayland (#50213)

fix: improved the appearance of shadows and borders on frameless windows on Wayland (#50007)

* remove painting from linux frame layout

* use chromium csd strategy for frameless windows

* Apply suggestions from code review

Remove unneeded virtual methods



* removed inline destructors

---------

Co-authored-by: trop[bot] <37223003+trop[bot]@users.noreply.github.com>
Co-authored-by: Mitchell Cohen <mitch.cohen@me.com>

chromium_src/BUILD.gn

@@ -245,6 +245,10 @@ static_library("chrome") {
       "//chrome/browser/ui/views/dark_mode_manager_linux.cc",
       "//chrome/browser/ui/views/dark_mode_manager_linux.h",
     ]
+    sources += [
+      "//chrome/browser/ui/views/frame/browser_frame_view_paint_utils_linux.cc",
+      "//chrome/browser/ui/views/frame/browser_frame_view_paint_utils_linux.h",
+    ]
     public_deps += [ "//components/dbus" ]
   }
 

shell/browser/ui/electron_desktop_window_tree_host_linux.cc

@@ -243,8 +243,8 @@ void ElectronDesktopWindowTreeHostLinux::UpdateFrameHints() {
         // The opaque region is a list of rectangles that contain only fully
         // opaque pixels of the window.  We need to convert the clipping
         // rounded-rect into this format.
-        SkRRect rrect = layout->GetRoundedWindowContentBounds();
-        gfx::RectF rectf(layout->GetWindowContentBounds());
+        SkRRect rrect = layout->GetRoundedWindowBounds();
+        gfx::RectF rectf(layout->GetWindowBounds());
         rectf.Scale(scale);
         // It is acceptable to omit some pixels that are opaque, but the region
         // must not include any translucent pixels.  Therefore, we must

shell/browser/ui/views/client_frame_view_linux.cc

@@ -112,7 +112,7 @@ ClientFrameViewLinux::~ClientFrameViewLinux() {
 void ClientFrameViewLinux::Init(NativeWindowViews* window,
                                 views::Widget* frame) {
   FramelessView::Init(window, frame);
-  linux_frame_layout_ = std::make_unique<LinuxCSDFrameLayout>(window);
+  linux_frame_layout_ = std::make_unique<LinuxCSDNativeFrameLayout>(window);
 
   // Unretained() is safe because the subscription is saved into an instance
   // member and thus will be cancelled upon the instance's destruction.
@@ -156,7 +156,8 @@ void ClientFrameViewLinux::OnWindowButtonOrderingChange() {
 }
 
 int ClientFrameViewLinux::ResizingBorderHitTest(const gfx::Point& point) {
-  return ResizingBorderHitTestImpl(point, RestoredFrameBorderInsets());
+  return ResizingBorderHitTestImpl(
+      point, linux_frame_layout_->GetResizeBorderInsets());
 }
 
 gfx::Rect ClientFrameViewLinux::GetBoundsForClientView() const {
@@ -235,8 +236,11 @@ void ClientFrameViewLinux::Layout(PassKey) {
 }
 
 void ClientFrameViewLinux::OnPaint(gfx::Canvas* canvas) {
-  linux_frame_layout_->PaintWindowFrame(
-      canvas, GetLocalBounds(), GetTitlebarBounds(), ShouldPaintAsActive());
+  if (auto* frame_provider = linux_frame_layout_->GetFrameProvider()) {
+    frame_provider->PaintWindowFrame(
+        canvas, GetLocalBounds(), GetTitlebarBounds().bottom(),
+        ShouldPaintAsActive(), linux_frame_layout_->GetInputInsets());
+  }
 }
 
 void ClientFrameViewLinux::PaintAsActiveChanged() {
@@ -267,7 +271,7 @@ void ClientFrameViewLinux::UpdateThemeValues() {
   }
 
   theme_values_.window_border_radius =
-      linux_frame_layout_->GetFrameProvider()->GetTopCornerRadiusDip();
+      linux_frame_layout_->GetTopCornerRadiusDip();
 
   gtk::GtkStyleContextGet(headerbar_context, "min-height",
                           &theme_values_.titlebar_min_height, nullptr);

shell/browser/ui/views/client_frame_view_linux.h

@@ -112,7 +112,7 @@ class ClientFrameViewLinux : public FramelessView,
   gfx::Insets GetTitlebarContentInsets() const;
   gfx::Rect GetTitlebarContentBounds() const;
 
-  std::unique_ptr<LinuxFrameLayout> linux_frame_layout_;
+  std::unique_ptr<LinuxCSDNativeFrameLayout> linux_frame_layout_;
 
   raw_ptr<ui::NativeTheme> theme_;
   ThemeValues theme_values_;

shell/browser/ui/views/linux_frame_layout.cc

@@ -4,14 +4,20 @@
 // found in the LICENSE file.
 
 #include "shell/browser/ui/views/linux_frame_layout.h"
+
+#include <algorithm>
+
 #include "base/i18n/rtl.h"
+#include "chrome/browser/ui/views/frame/browser_frame_view_paint_utils_linux.h"  // nogncheck
+#include "shell/browser/linux/x11_util.h"
 #include "shell/browser/native_window_views.h"
 #include "shell/browser/ui/electron_desktop_window_tree_host_linux.h"
-#include "ui/gfx/canvas.h"
+#include "third_party/skia/include/core/SkRRect.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/skia_conversions.h"
 #include "ui/linux/linux_ui.h"
-#include "ui/native_theme/native_theme.h"
+#include "ui/linux/window_frame_provider.h"
+#include "ui/views/layout/layout_provider.h"
 #include "ui/views/widget/widget.h"
 
 namespace electron {
@@ -21,151 +27,174 @@ namespace {
 constexpr int kResizeBorder = 10;
 // This should match FramelessView's inside resize band.
 constexpr int kResizeInsideBoundsSize = 5;
+// These should match Chromium's restored frame edge thickness.
+constexpr gfx::Insets kDefaultCustomFrameBorder = gfx::Insets::TLBR(2, 1, 1, 1);
+
+bool CheckClientFrameShadowSupport(NativeWindowViews* window) {
+  auto* tree_host = static_cast<ElectronDesktopWindowTreeHostLinux*>(
+      ElectronDesktopWindowTreeHostLinux::GetHostForWidget(
+          window->GetAcceleratedWidget()));
+  return tree_host && tree_host->SupportsClientFrameShadow();
+}
 }  // namespace
 
 // static
 std::unique_ptr<LinuxFrameLayout> LinuxFrameLayout::Create(
     NativeWindowViews* window,
-    bool wants_shadow) {
+    bool wants_shadow,
+    CSDStyle csd_style) {
   if (x11_util::IsX11() || window->IsTranslucent() || !wants_shadow) {
-    return std::make_unique<LinuxUndecoratedFrameLayout>(window);
+    return std::make_unique<LinuxFrameLayout>(window);
+  } else if (csd_style == CSDStyle::kCustom) {
+    return std::make_unique<LinuxCSDCustomFrameLayout>(window);
   } else {
-    return std::make_unique<LinuxCSDFrameLayout>(window);
+    return std::make_unique<LinuxCSDNativeFrameLayout>(window);
   }
 }
 
-LinuxCSDFrameLayout::LinuxCSDFrameLayout(NativeWindowViews* window)
-    : window_(window) {
-  host_supports_client_frame_shadow_ = SupportsClientFrameShadow();
+gfx::Insets LinuxFrameLayout::GetResizeBorderInsets() const {
+  gfx::Insets insets = RestoredFrameBorderInsets();
+  return insets.IsEmpty() ? GetInputInsets() : insets;
 }
 
-bool LinuxCSDFrameLayout::tiled() const {
-  return tiled_;
-}
-
-void LinuxCSDFrameLayout::set_tiled(bool tiled) {
-  tiled_ = tiled;
-}
-
-gfx::Insets LinuxCSDFrameLayout::RestoredFrameBorderInsets() const {
-  gfx::Insets insets = GetFrameProvider()->GetFrameThicknessDip();
-  const gfx::Insets input = GetInputInsets();
-
-  auto expand_if_visible = [](int side_thickness, int min_band) {
-    return side_thickness > 0 ? std::max(side_thickness, min_band) : 0;
-  };
-
-  gfx::Insets merged;
-  merged.set_top(expand_if_visible(insets.top(), input.top()));
-  merged.set_left(expand_if_visible(insets.left(), input.left()));
-  merged.set_bottom(expand_if_visible(insets.bottom(), input.bottom()));
-  merged.set_right(expand_if_visible(insets.right(), input.right()));
-
-  return base::i18n::IsRTL() ? gfx::Insets::TLBR(merged.top(), merged.right(),
-                                                 merged.bottom(), merged.left())
-                             : merged;
-}
-
-gfx::Insets LinuxCSDFrameLayout::GetInputInsets() const {
-  bool showing_shadow = host_supports_client_frame_shadow_ &&
-                        !window_->IsMaximized() && !window_->IsFullscreen();
-  return gfx::Insets(showing_shadow ? kResizeBorder : 0);
-}
-
-bool LinuxCSDFrameLayout::SupportsClientFrameShadow() const {
-  auto* tree_host = static_cast<ElectronDesktopWindowTreeHostLinux*>(
-      ElectronDesktopWindowTreeHostLinux::GetHostForWidget(
-          window_->GetAcceleratedWidget()));
-  return tree_host->SupportsClientFrameShadow();
-}
-
-void LinuxCSDFrameLayout::PaintWindowFrame(gfx::Canvas* canvas,
-                                           gfx::Rect local_bounds,
-                                           gfx::Rect titlebar_bounds,
-                                           bool active) {
-  GetFrameProvider()->PaintWindowFrame(
-      canvas, local_bounds, titlebar_bounds.bottom(), active, GetInputInsets());
-}
-
-gfx::Rect LinuxCSDFrameLayout::GetWindowContentBounds() const {
-  gfx::Rect content_bounds = window_->widget()->GetWindowBoundsInScreen();
-  content_bounds.Inset(RestoredFrameBorderInsets());
-  return content_bounds;
-}
-
-SkRRect LinuxCSDFrameLayout::GetRoundedWindowContentBounds() const {
-  SkRect rect = gfx::RectToSkRect(GetWindowContentBounds());
+SkRRect LinuxFrameLayout::GetRoundedWindowBounds() const {
+  SkRect rect = gfx::RectToSkRect(GetWindowBounds());
   SkRRect rrect;
-
-  if (!window_->IsMaximized()) {
-    float radius = GetFrameProvider()->GetTopCornerRadiusDip();
+  float radius = GetTopCornerRadiusDip();
+  if (radius > 0) {
     SkPoint round_point{radius, radius};
     SkPoint radii[] = {round_point, round_point, {}, {}};
     rrect.setRectRadii(rect, radii);
   } else {
     rrect.setRect(rect);
   }
-
   return rrect;
 }
 
-int LinuxCSDFrameLayout::GetTranslucentTopAreaHeight() const {
+// Base implementation is suitable for X11/views without shadows
+LinuxFrameLayout::LinuxFrameLayout(NativeWindowViews* window)
+    : window_(window) {
+  host_supports_client_frame_shadow_ = false;
+}
+
+LinuxFrameLayout::~LinuxFrameLayout() = default;
+
+gfx::Insets LinuxFrameLayout::RestoredFrameBorderInsets() const {
+  return gfx::Insets();
+}
+
+gfx::Insets LinuxFrameLayout::GetInputInsets() const {
+  return gfx::Insets(kResizeInsideBoundsSize);
+}
+
+bool LinuxFrameLayout::IsShowingShadow() const {
+  return host_supports_client_frame_shadow_ && !window_->IsMaximized() &&
+         !window_->IsFullscreen();
+}
+
+bool LinuxFrameLayout::SupportsClientFrameShadow() const {
+  return host_supports_client_frame_shadow_;
+}
+
+bool LinuxFrameLayout::tiled() const {
+  return tiled_;
+}
+
+void LinuxFrameLayout::set_tiled(bool tiled) {
+  tiled_ = tiled;
+}
+
+gfx::Rect LinuxFrameLayout::GetWindowBounds() const {
+  gfx::Rect bounds = window_->widget()->GetWindowBoundsInScreen();
+  bounds.Inset(RestoredFrameBorderInsets());
+  return bounds;
+}
+
+float LinuxFrameLayout::GetTopCornerRadiusDip() const {
   return 0;
 }
 
-ui::WindowFrameProvider* LinuxCSDFrameLayout::GetFrameProvider() const {
+int LinuxFrameLayout::GetTranslucentTopAreaHeight() const {
+  return 0;
+}
+
+gfx::Insets LinuxFrameLayout::NormalizeBorderInsets(
+    const gfx::Insets& frame_insets,
+    const gfx::Insets& input_insets) const {
+  auto expand_if_visible = [](int side_thickness, int min_band) {
+    return side_thickness > 0 ? std::max(side_thickness, min_band) : 0;
+  };
+
+  // Ensure hit testing for resize targets works
+  // even if borders/shadows are absent on some edges.
+  gfx::Insets merged;
+  merged.set_top(expand_if_visible(frame_insets.top(), input_insets.top()));
+  merged.set_left(expand_if_visible(frame_insets.left(), input_insets.left()));
+  merged.set_bottom(
+      expand_if_visible(frame_insets.bottom(), input_insets.bottom()));
+  merged.set_right(
+      expand_if_visible(frame_insets.right(), input_insets.right()));
+
+  return base::i18n::IsRTL() ? gfx::Insets::TLBR(merged.top(), merged.right(),
+                                                 merged.bottom(), merged.left())
+                             : merged;
+}
+
+// Used for a native-like frame with a FrameProvider
+LinuxCSDNativeFrameLayout::LinuxCSDNativeFrameLayout(NativeWindowViews* window)
+    : LinuxFrameLayout(window) {
+  host_supports_client_frame_shadow_ = CheckClientFrameShadowSupport(window);
+}
+
+LinuxCSDNativeFrameLayout::~LinuxCSDNativeFrameLayout() = default;
+
+gfx::Insets LinuxCSDNativeFrameLayout::RestoredFrameBorderInsets() const {
+  const gfx::Insets input_insets = GetInputInsets();
+  const gfx::Insets frame_insets = GetFrameProvider()->GetFrameThicknessDip();
+  return NormalizeBorderInsets(frame_insets, input_insets);
+}
+
+gfx::Insets LinuxCSDNativeFrameLayout::GetInputInsets() const {
+  return gfx::Insets(IsShowingShadow() ? kResizeBorder : 0);
+}
+
+float LinuxCSDNativeFrameLayout::GetTopCornerRadiusDip() const {
+  return window_->IsMaximized() ? 0
+                                : GetFrameProvider()->GetTopCornerRadiusDip();
+}
+
+ui::WindowFrameProvider* LinuxCSDNativeFrameLayout::GetFrameProvider() const {
   return ui::LinuxUiTheme::GetForProfile(nullptr)->GetWindowFrameProvider(
       !host_supports_client_frame_shadow_, tiled(), window_->IsMaximized());
 }
 
-LinuxUndecoratedFrameLayout::LinuxUndecoratedFrameLayout(
-    NativeWindowViews* window)
-    : window_(window) {}
-
-gfx::Insets LinuxUndecoratedFrameLayout::RestoredFrameBorderInsets() const {
-  return gfx::Insets();
+// Used for Chromium-like custom CSD
+LinuxCSDCustomFrameLayout::LinuxCSDCustomFrameLayout(NativeWindowViews* window)
+    : LinuxFrameLayout(window) {
+  host_supports_client_frame_shadow_ = CheckClientFrameShadowSupport(window);
 }
 
-gfx::Insets LinuxUndecoratedFrameLayout::GetInputInsets() const {
-  return gfx::Insets(kResizeInsideBoundsSize);
+LinuxCSDCustomFrameLayout::~LinuxCSDCustomFrameLayout() = default;
+
+gfx::Insets LinuxCSDCustomFrameLayout::RestoredFrameBorderInsets() const {
+  const gfx::Insets input_insets = GetInputInsets();
+  const bool showing_shadow = IsShowingShadow();
+  const auto shadow_values = (showing_shadow && !tiled())
+                                 ? GetFrameShadowValuesLinux(/*active=*/true)
+                                 : gfx::ShadowValues();
+  const gfx::Insets frame_insets = GetRestoredFrameBorderInsetsLinux(
+      showing_shadow, kDefaultCustomFrameBorder, shadow_values, input_insets);
+  return NormalizeBorderInsets(frame_insets, input_insets);
 }
 
-bool LinuxUndecoratedFrameLayout::SupportsClientFrameShadow() const {
-  return false;
+gfx::Insets LinuxCSDCustomFrameLayout::GetInputInsets() const {
+  return gfx::Insets(IsShowingShadow() ? kResizeBorder : 0);
 }
 
-bool LinuxUndecoratedFrameLayout::tiled() const {
-  return tiled_;
-}
-
-void LinuxUndecoratedFrameLayout::set_tiled(bool tiled) {
-  tiled_ = tiled;
-}
-
-void LinuxUndecoratedFrameLayout::PaintWindowFrame(gfx::Canvas* canvas,
-                                                   gfx::Rect local_bounds,
-                                                   gfx::Rect titlebar_bounds,
-                                                   bool active) {
-  // No-op
-}
-
-gfx::Rect LinuxUndecoratedFrameLayout::GetWindowContentBounds() const {
-  // With no transparent insets, widget bounds and logical bounds match.
-  return window_->widget()->GetWindowBoundsInScreen();
-}
-
-SkRRect LinuxUndecoratedFrameLayout::GetRoundedWindowContentBounds() const {
-  SkRRect rrect;
-  rrect.setRect(gfx::RectToSkRect(GetWindowContentBounds()));
-  return rrect;
-}
-
-int LinuxUndecoratedFrameLayout::GetTranslucentTopAreaHeight() const {
-  return 0;
-}
-
-ui::WindowFrameProvider* LinuxUndecoratedFrameLayout::GetFrameProvider() const {
-  return nullptr;
+gfx::ShadowValues GetFrameShadowValuesLinux(bool active) {
+  const int elevation = views::LayoutProvider::Get()->GetShadowElevationMetric(
+      active ? views::Emphasis::kMaximum : views::Emphasis::kMedium);
+  return gfx::ShadowValue::MakeMdShadowValues(elevation);
 }
 
 }  // namespace electron

shell/browser/ui/views/linux_frame_layout.h

@@ -8,110 +8,96 @@
 
 #include <memory>
 
-#include "base/i18n/rtl.h"
-#include "shell/browser/linux/x11_util.h"
-#include "shell/browser/native_window_views.h"
-#include "shell/browser/ui/electron_desktop_window_tree_host_linux.h"
+#include "base/memory/raw_ptr.h"
 #include "third_party/skia/include/core/SkRRect.h"
-#include "ui/base/ozone_buildflags.h"
-#include "ui/gfx/canvas.h"
-#include "ui/gfx/geometry/insets.h"
-#include "ui/linux/linux_ui.h"
+#include "ui/gfx/shadow_value.h"
 #include "ui/linux/window_frame_provider.h"
 
+namespace gfx {
+class Insets;
+class Rect;
+}  // namespace gfx
+
 namespace electron {
 
 class NativeWindowViews;
 
-// Shared helper for CSD layout and frame painting on Linux (shadows, resize
-// regions, titlebars, etc.). Also helps views determine insets and perform
-// bounds conversions between widget and logical coordinates.
+// Shared helper for CSD layout on Linux (shadows, resize regions, titlebars,
+// etc.). Also helps views determine insets and perform bounds conversions
+// between widget and logical coordinates.
+//
+// The base class is concrete and suitable as-is for the undecorated case (X11,
+// translucent windows, or windows without shadows). CSD subclasses override
+// the methods that differ.
 class LinuxFrameLayout {
  public:
-  virtual ~LinuxFrameLayout() = default;
+  enum class CSDStyle {
+    kNativeFrame,
+    kCustom,
+  };
+
+  explicit LinuxFrameLayout(NativeWindowViews* window);
+  virtual ~LinuxFrameLayout();
 
   static std::unique_ptr<LinuxFrameLayout> Create(NativeWindowViews* window,
-                                                  bool wants_shadow);
+                                                  bool wants_shadow,
+                                                  CSDStyle csd_style);
 
-  // Insets from the transparent widget border to the opaque part of the window
-  virtual gfx::Insets RestoredFrameBorderInsets() const = 0;
-  // Insets for parts of the surface that should be counted for user input
-  virtual gfx::Insets GetInputInsets() const = 0;
+  // Insets from the transparent widget border to the opaque part of the window.
+  virtual gfx::Insets RestoredFrameBorderInsets() const;
+  // Insets for parts of the surface that should be counted for user input.
+  virtual gfx::Insets GetInputInsets() const;
+  // Insets to use for non-client resize hit-testing.
+  gfx::Insets GetResizeBorderInsets() const;
 
-  virtual bool SupportsClientFrameShadow() const = 0;
+  bool IsShowingShadow() const;
+  bool SupportsClientFrameShadow() const;
 
-  virtual bool tiled() const = 0;
-  virtual void set_tiled(bool tiled) = 0;
+  bool tiled() const;
+  void set_tiled(bool tiled);
 
-  virtual void PaintWindowFrame(gfx::Canvas* canvas,
-                                gfx::Rect local_bounds,
-                                gfx::Rect titlebar_bounds,
-                                bool active) = 0;
+  // The logical bounds of the window interior.
+  gfx::Rect GetWindowBounds() const;
+  // The logical window bounds as a rounded rect with corner radii applied.
+  SkRRect GetRoundedWindowBounds() const;
+  // The corner radius of the top corners of the window, in DIPs.
+  virtual float GetTopCornerRadiusDip() const;
 
-  // The logical bounds of the window
-  virtual gfx::Rect GetWindowContentBounds() const = 0;
-  // The logical bounds as a rounded rect with corner radii applied
-  virtual SkRRect GetRoundedWindowContentBounds() const = 0;
+  int GetTranslucentTopAreaHeight() const;
 
-  virtual int GetTranslucentTopAreaHeight() const = 0;
+ protected:
+  gfx::Insets NormalizeBorderInsets(const gfx::Insets& frame_insets,
+                                    const gfx::Insets& input_insets) const;
 
-  virtual ui::WindowFrameProvider* GetFrameProvider() const = 0;
-};
-
-// Client-side decoration (CSD) Linux frame layout implementation.
-class LinuxCSDFrameLayout : public LinuxFrameLayout {
- public:
-  explicit LinuxCSDFrameLayout(NativeWindowViews* window);
-  ~LinuxCSDFrameLayout() override = default;
-
-  gfx::Insets RestoredFrameBorderInsets() const override;
-  gfx::Insets GetInputInsets() const override;
-  bool SupportsClientFrameShadow() const override;
-  bool tiled() const override;
-  void set_tiled(bool tiled) override;
-  void PaintWindowFrame(gfx::Canvas* canvas,
-                        gfx::Rect local_bounds,
-                        gfx::Rect titlebar_bounds,
-                        bool active) override;
-  gfx::Rect GetWindowContentBounds() const override;
-  SkRRect GetRoundedWindowContentBounds() const override;
-  int GetTranslucentTopAreaHeight() const override;
-  ui::WindowFrameProvider* GetFrameProvider() const override;
-
- private:
   raw_ptr<NativeWindowViews> window_;
   bool tiled_ = false;
   bool host_supports_client_frame_shadow_ = false;
 };
 
-// No-decoration Linux frame layout implementation.
-//
-// Intended for cases where we do not allocate a transparent inset area around
-// the window (e.g. X11 / server-side decorations, or when insets are disabled).
-// All inset math returns 0 and frame painting is skipped.
-class LinuxUndecoratedFrameLayout : public LinuxFrameLayout {
+// CSD strategy that uses the GTK window frame provider for metrics.
+class LinuxCSDNativeFrameLayout : public LinuxFrameLayout {
  public:
-  explicit LinuxUndecoratedFrameLayout(NativeWindowViews* window);
-  ~LinuxUndecoratedFrameLayout() override = default;
+  explicit LinuxCSDNativeFrameLayout(NativeWindowViews* window);
+  ~LinuxCSDNativeFrameLayout() override;
 
   gfx::Insets RestoredFrameBorderInsets() const override;
   gfx::Insets GetInputInsets() const override;
-  bool SupportsClientFrameShadow() const override;
-  bool tiled() const override;
-  void set_tiled(bool tiled) override;
-  void PaintWindowFrame(gfx::Canvas* canvas,
-                        gfx::Rect local_bounds,
-                        gfx::Rect titlebar_bounds,
-                        bool active) override;
-  gfx::Rect GetWindowContentBounds() const override;
-  SkRRect GetRoundedWindowContentBounds() const override;
-  int GetTranslucentTopAreaHeight() const override;
-  ui::WindowFrameProvider* GetFrameProvider() const override;
-
- private:
-  raw_ptr<NativeWindowViews> window_;
-  bool tiled_ = false;
+  float GetTopCornerRadiusDip() const override;
+  ui::WindowFrameProvider* GetFrameProvider() const;
 };
+
+// CSD strategy that uses custom metrics, similar to those used in Chromium.
+class LinuxCSDCustomFrameLayout : public LinuxFrameLayout {
+ public:
+  explicit LinuxCSDCustomFrameLayout(NativeWindowViews* window);
+  ~LinuxCSDCustomFrameLayout() override;
+
+  gfx::Insets RestoredFrameBorderInsets() const override;
+  gfx::Insets GetInputInsets() const override;
+};
+
+gfx::ShadowValues GetFrameShadowValuesLinux(bool active);
+
 }  // namespace electron
 
 #endif  // ELECTRON_SHELL_BROWSER_UI_VIEWS_LINUX_FRAME_LAYOUT_H_

shell/browser/ui/views/opaque_frame_view.cc

@@ -5,22 +5,24 @@
 #include "shell/browser/ui/views/opaque_frame_view.h"
 
 #include "base/containers/adapters.h"
-#include "base/i18n/rtl.h"
+#include "chrome/browser/ui/views/frame/browser_frame_view_paint_utils_linux.h"  // nogncheck
 #include "chrome/browser/ui/views/frame/opaque_browser_frame_view_layout.h"  // nogncheck
 #include "chrome/grit/generated_resources.h"
 #include "components/strings/grit/components_strings.h"
 #include "shell/browser/native_window_views.h"
 #include "shell/browser/ui/views/caption_button_placeholder_container.h"
+#include "third_party/skia/include/core/SkRRect.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/metadata/metadata_impl_macros.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/font_list.h"
-#include "ui/linux/linux_ui.h"
+#include "ui/gfx/geometry/insets_f.h"
+#include "ui/gfx/geometry/skia_conversions.h"
 #include "ui/views/accessibility/view_accessibility.h"
 #include "ui/views/background.h"
 #include "ui/views/widget/widget.h"
-#include "ui/views/widget/widget_delegate.h"
+#include "ui/views/window/frame_background.h"
 #include "ui/views/window/frame_caption_button.h"
 #include "ui/views/window/vector_icons/vector_icons.h"
 
@@ -55,12 +57,14 @@ const int kCaptionButtonBottomPadding = 3;
 // The content edge images have a shadow built into them.
 const int OpaqueFrameView::kContentEdgeShadowThickness = 2;
 
-OpaqueFrameView::OpaqueFrameView() = default;
+OpaqueFrameView::OpaqueFrameView()
+    : frame_background_(std::make_unique<views::FrameBackground>()) {}
 OpaqueFrameView::~OpaqueFrameView() = default;
 
 void OpaqueFrameView::Init(NativeWindowViews* window, views::Widget* frame) {
   FramelessView::Init(window, frame);
-  linux_frame_layout_ = LinuxFrameLayout::Create(window, window->HasShadow());
+  linux_frame_layout_ = LinuxFrameLayout::Create(
+      window, window->HasShadow(), LinuxFrameLayout::CSDStyle::kCustom);
 
   // Unretained() is safe because the subscription is saved into an instance
   // member and thus will be cancelled upon the instance's destruction.
@@ -98,9 +102,8 @@ void OpaqueFrameView::Init(NativeWindowViews* window, views::Widget* frame) {
 }
 
 int OpaqueFrameView::ResizingBorderHitTest(const gfx::Point& point) {
-  auto insets = RestoredFrameBorderInsets();
   return ResizingBorderHitTestImpl(
-      point, insets.IsEmpty() ? linux_frame_layout_->GetInputInsets() : insets);
+      point, linux_frame_layout_->GetResizeBorderInsets());
 }
 
 void OpaqueFrameView::InvalidateCaptionButtons() {
@@ -200,14 +203,31 @@ void OpaqueFrameView::OnPaint(gfx::Canvas* canvas) {
   if (frame()->IsFullscreen())
     return;
 
-  // Titlebar height must be at least the frame border insets to avoid
-  // a negative height calculation in the GTK frame provider. We add 1 to
-  // ensure it's always positive even when insets are 0.
-  int top_area_height = RestoredFrameBorderInsets().top() + 1;
+  const bool active = ShouldPaintAsActive();
+  const gfx::Insets border = RestoredFrameBorderInsets();
+  const bool showing_shadow = linux_frame_layout_->IsShowingShadow();
+  gfx::RectF bounds_dip(GetLocalBounds());
+  if (showing_shadow) {
+    bounds_dip.Inset(gfx::InsetsF(border));
+  }
 
-  linux_frame_layout_->PaintWindowFrame(
-      canvas, GetLocalBounds(), gfx::Rect(0, 0, width(), top_area_height),
-      ShouldPaintAsActive());
+  // TODO: support roundedCorners.
+  float radius_dip = 0;
+  SkVector radii[4]{{radius_dip, radius_dip}, {radius_dip, radius_dip}, {}, {}};
+  SkRRect clip;
+  clip.setRectRadii(gfx::RectFToSkRect(bounds_dip), radii);
+
+  frame_background_->set_frame_color(GetFrameColor());
+  frame_background_->set_use_custom_frame(true);
+  frame_background_->set_is_active(active);
+  frame_background_->set_top_area_height(GetTopAreaHeight());
+
+  const bool draw_shadow = showing_shadow && !linux_frame_layout_->tiled();
+  auto shadow_values =
+      draw_shadow ? GetFrameShadowValuesLinux(active) : gfx::ShadowValues();
+  ::PaintRestoredFrameBorderLinux(*canvas, *this, frame_background_.get(), clip,
+                                  showing_shadow, active, border, shadow_values,
+                                  linux_frame_layout_->tiled());
 
   if (!window()->IsWindowControlsOverlayEnabled())
     return;

shell/browser/ui/views/opaque_frame_view.h

@@ -20,6 +20,10 @@
 
 class CaptionButtonPlaceholderContainer;
 
+namespace views {
+class FrameBackground;
+}
+
 namespace electron {
 
 class NativeWindowViews;
@@ -166,6 +170,7 @@ class OpaqueFrameView : public FramelessView {
                               bool is_leading_button) const;
 
   std::unique_ptr<LinuxFrameLayout> linux_frame_layout_;
+  std::unique_ptr<views::FrameBackground> frame_background_;
 
   // Window controls.
   raw_ptr<views::Button> minimize_button_;