Native themes: Add menu separator part

chrome/browser/ui/libgtkui/native_theme_gtk3.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/libgtkui/native_theme_gtk3.h"
 
 #include <gtk/gtk.h>
 
 #include "chrome/browser/ui/libgtkui/chrome_gtk_frame.h"
 #include "chrome/browser/ui/libgtkui/chrome_gtk_menu_subclasses.h"
 #include "chrome/browser/ui/libgtkui/gtk_util.h"
 #include "chrome/browser/ui/libgtkui/skia_utils_gtk.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/native_theme/native_theme_dark_aura.h"
 
 namespace libgtkui {
 
 namespace {
 
+enum BackgroundRenderMode {
+  BG_RENDER_NORMAL,
+  BG_RENDER_NONE,
+  BG_RENDER_RECURSIVE,
+};
+
 SkBitmap GetWidgetBitmap(const gfx::Size& size,
-                         GtkStyleContext* context) {
+                         GtkStyleContext* context,
+                         BackgroundRenderMode bg_mode,
+                         bool render_frame) {
+  DCHECK(bg_mode != BG_RENDER_NONE || render_frame);
   SkBitmap bitmap;
   bitmap.allocN32Pixels(size.width(), size.height());
   bitmap.eraseColor(0);
 
   cairo_surface_t* surface = cairo_image_surface_create_for_data(
       static_cast<unsigned char*>(bitmap.getAddr(0, 0)), CAIRO_FORMAT_ARGB32,
       size.width(), size.height(),
       cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, size.width()));
   cairo_t* cr = cairo_create(surface);
 
-  RenderBackground(size, cr, context);
-  gtk_render_frame(context, cr, 0, 0, size.width(), size.height());
+  switch (bg_mode) {
+    case BG_RENDER_NORMAL:
+      gtk_render_background(context, cr, 0, 0, size.width(), size.height());
+      break;
+    case BG_RENDER_RECURSIVE:
+      RenderBackground(size, cr, context);
+      break;
+    case BG_RENDER_NONE:
+      break;
+  }
+  if (render_frame)
+    gtk_render_frame(context, cr, 0, 0, size.width(), size.height());
   cairo_destroy(cr);
   cairo_surface_destroy(surface);
   return bitmap;
 }
 
 void PaintWidget(SkCanvas* canvas,
                  const gfx::Rect& rect,
-                 GtkStyleContext* context) {
-  canvas->drawBitmap(GetWidgetBitmap(rect.size(), context), rect.x(), rect.y());
+                 GtkStyleContext* context,
+                 BackgroundRenderMode bg_mode,
+                 bool render_frame) {
+  canvas->drawBitmap(
+      GetWidgetBitmap(rect.size(), context, bg_mode, render_frame), rect.x(),
+      rect.y());
 }
 
 GtkStateFlags StateToStateFlags(NativeThemeGtk3::State state) {
   switch (state) {
     case NativeThemeGtk3::kDisabled:
       return GTK_STATE_FLAG_INSENSITIVE;
     case NativeThemeGtk3::kHovered:
       return GTK_STATE_FLAG_PRELIGHT;
     case NativeThemeGtk3::kNormal:
       return GTK_STATE_FLAG_NORMAL;
@@ skipping 36 matching lines @@
     case ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor:
       return GetFgColor(
           "GtkMenu#menu GtkMenuItem#menuitem:selected GtkLabel#label");
     case ui::NativeTheme::kColorId_DisabledMenuItemForegroundColor:
       return GetFgColor(
           "GtkMenu#menu GtkMenuItem#menuitem:disabled GtkLabel#label");
     case ui::NativeTheme::kColorId_MenuItemSubtitleColor:
       return GetFgColor(
           "GtkMenu#menu GtkMenuItem#menuitem GtkLabel#label.accelerator");
     case ui::NativeTheme::kColorId_MenuSeparatorColor:
-    // MenuButton borders are used the same way as menu separators in Chrome.
+    // MenuButton borders are used as vertical menu separators in Chrome.
     case ui::NativeTheme::kColorId_EnabledMenuButtonBorderColor:
     case ui::NativeTheme::kColorId_FocusedMenuButtonBorderColor:
     case ui::NativeTheme::kColorId_HoverMenuButtonBorderColor:
       if (GtkVersionCheck(3, 20))
         return GetBgColor("GtkMenu#menu GtkSeparator#separator");
       else
         return GetFgColor("GtkMenu#menu GtkMenuItem#menuitem.separator");
 
     // Label
     case ui::NativeTheme::kColorId_LabelEnabledColor:
       return GetFgColor("GtkLabel#label");
     case ui::NativeTheme::kColorId_LabelDisabledColor:
       return GetFgColor("GtkLabel#label:disabled");
     case ui::NativeTheme::kColorId_LabelTextSelectionColor:
       return GetFgColor("GtkLabel#label #selection:selected");
     case ui::NativeTheme::kColorId_LabelTextSelectionBackgroundFocused:
       return GetBgColor("GtkLabel#label #selection:selected");
 
     // Link
     case ui::NativeTheme::kColorId_LinkDisabled:
       return SkColorSetA(
           SkColorFromColorId(ui::NativeTheme::kColorId_LinkEnabled), 0xBB);
     case ui::NativeTheme::kColorId_LinkPressed:
       if (GtkVersionCheck(3, 12))
         return GetFgColor("GtkLabel#label.link:link:hover:active");
-      // fallthrough
+    // fallthrough
     case ui::NativeTheme::kColorId_LinkEnabled: {
       if (GtkVersionCheck(3, 12)) {
         return GetFgColor("GtkLabel#label.link:link");
       }
       auto link_context = GetStyleContextFromCss("GtkLabel#label.view");
       GdkColor* color;
       gtk_style_context_get_style(link_context, "link-color", &color, nullptr);
       if (color) {
         SkColor ret_color = SkColorSetRGB(color->red / 255, color->green / 255,
                                           color->blue / 255);
@@ skipping 222 matching lines @@
 
   SkColor color = SkColorFromColorId(color_id);
   color_cache_[color_id] = color;
   return color;
 }
 
 void NativeThemeGtk3::PaintMenuPopupBackground(
     SkCanvas* canvas,
     const gfx::Size& size,
     const MenuBackgroundExtraParams& menu_background) const {
-  PaintWidget(canvas, gfx::Rect(size), GetStyleContextFromCss("GtkMenu#menu"));
+  PaintWidget(canvas, gfx::Rect(size), GetStyleContextFromCss("GtkMenu#menu"),
+              BG_RENDER_RECURSIVE, false);
 }
 
 void NativeThemeGtk3::PaintMenuItemBackground(
     SkCanvas* canvas,
     State state,
     const gfx::Rect& rect,
     const MenuItemExtraParams& menu_item) const {
   auto context = GetStyleContextFromCss("GtkMenu#menu GtkMenuItem#menuitem");
   gtk_style_context_set_state(context, StateToStateFlags(state));
-  PaintWidget(canvas, rect, context);
+  PaintWidget(canvas, rect, context, BG_RENDER_NORMAL, true);
+}
+
+void NativeThemeGtk3::PaintMenuSeparator(
+    SkCanvas* canvas,
+    State state,
+    const gfx::Rect& rect,
+    const MenuSeparatorExtraParams& menu_separator) const {
+  auto separator_offset = [&](int separator_thickness) {
+    switch (menu_separator.type) {
+      case ui::LOWER_SEPARATOR:
+        return rect.height() - separator_thickness;
+      case ui::UPPER_SEPARATOR:
+        return 0;
+      default:
+        return rect.height() / 2;
+    }
+  };
+  if (GtkVersionCheck(3, 20)) {
+    auto context =
+        GetStyleContextFromCss("GtkMenu#menu GtkSeparator#separator");
+    GtkBorder margin, border, padding;
+    GtkStateFlags state = gtk_style_context_get_state(context);
+    gtk_style_context_get_margin(context, state, &margin);
+    gtk_style_context_get_border(context, state, &border);
+    gtk_style_context_get_padding(context, state, &padding);
+    int min_height = 0;
+    gtk_style_context_get(context, state, "min-height", &min_height, NULL);
+    int w = rect.width() - margin.left - margin.right;
+    int h =
+        min_height + padding.top + padding.bottom + border.top + border.bottom;
+    int x = margin.left;
+    int y = separator_offset(h);
+    PaintWidget(canvas, gfx::Rect(x, y, w, h), context, BG_RENDER_NORMAL, true);
+  } else {
+    auto context =
+        GetStyleContextFromCss("GtkMenu#menu GtkMenuItem#menuitem.separator");
+    gboolean wide_separators = false;
+    gint separator_height = 0;
+    gtk_style_context_get_style(context, "wide-separators", &wide_separators,
+                                "separator-height", &separator_height, nullptr);
+    // This code was adapted from gtk/gtkmenuitem.c.  For some reason,
+    // padding is used as the margin.
+    GtkBorder padding;
+    gtk_style_context_get_padding(context, gtk_style_context_get_state(context),
+                                  &padding);
+    int w = rect.width() - padding.left - padding.right;
+    int x = rect.x() + padding.left;
+    int h = wide_separators ? separator_height : 1;
+    int y = rect.y() + separator_offset(h);
+    if (wide_separators) {
+      PaintWidget(canvas, gfx::Rect(x, y, w, h), context, BG_RENDER_NONE, true);
+    } else {
+      SkPaint paint;
+      paint.setColor(SkColorFromStyleContext(context));
+      canvas->drawLine(x, y, x + w, y, paint);
+    }
+  }
 }
 
 void NativeThemeGtk3::PaintFrameTopArea(
     SkCanvas* canvas,
     State state,
     const gfx::Rect& rect,
     const FrameTopAreaExtraParams& frame_top_area) const {
   auto context = GetStyleContextFromCss(frame_top_area.use_custom_frame
                                             ? "#headerbar.header-bar.titlebar"
                                             : "GtkMenuBar#menubar");
   RemoveBorders(context);
-  gtk_style_context_set_state(context,
-                              frame_top_area.is_active
-                                  ? GTK_STATE_FLAG_NORMAL
-                              : GTK_STATE_FLAG_BACKDROP);
+  gtk_style_context_set_state(context, frame_top_area.is_active
+                                           ? GTK_STATE_FLAG_NORMAL
+                                           : GTK_STATE_FLAG_BACKDROP);
 
-  SkBitmap bitmap = GetWidgetBitmap(rect.size(), context);
+  SkBitmap bitmap =
+      GetWidgetBitmap(rect.size(), context, BG_RENDER_RECURSIVE, false);
 
   if (frame_top_area.incognito) {
     bitmap = SkBitmapOperations::CreateHSLShiftedBitmap(
         bitmap, kDefaultTintFrameIncognito);
   }
 
   canvas->drawBitmap(bitmap, rect.x(), rect.y());
 }
 
 }  // namespace libgtkui