Changeset 217702 in webkit

Timestamp:

Jun 1, 2017 11:40:36 PM (7 years ago)

Author:

Carlos Garcia Campos

Message:

[GTK] Cache RenderThemeGadget hierarchies for rendering themed elements with GTK+ 3.20+
​https://bugs.webkit.org/show_bug.cgi?id=162673

Reviewed by Michael Catanzaro.

Because of the way the new theming system works in GTK+ >= 3.20 we are currently creating a gadget hierarchy
every time we need to render a styled element or get layout information about it. That's happening on every
repaint, and it's specially problematic for overlay scrollbar indicators that fade in/out when shown/hidden. We
need to cache the gadgets and simply apply the state before every paint or layout query. When using GtkWidgetPath,
calling gtk_style_context_save() breaks the gadget hierarchy, and style classes need to be set when building the
GtkWidgetPath. That means we can't cache RenderThemeGadgets, call save, apply style classes and state, and then
call restore. We need to cache gadget hierarchies with fixed style classes. Fortunately, setting the state does
work, so we don't need to also cache a different hierarchy for every possible state. For example, for the
particular case of scrollbars we would cache VerticalScrollbarRight, VerticalScrollbarLeft, HorizontalScrollbar,
VerticalScrollIndicatorRight, VerticalScrollIndicatorLeft and HorizontalScrollIndicator. In practice, we will
only have 4 of those at the same time in the cache.
This patch adds RenderThemeWidget to represent a hierarchy of gadgets with fixed style classes that can be
cached and reused to render or query style of those "widgets". It also simplifies the RenderThemeGtk and
ScrollbarThemeGtk code by removing a lot of duplicated code to build the gadget hierarchies.

• PlatformGTK.cmake:
• platform/gtk/RenderThemeGadget.cpp:

(WebCore::createStyleContext):
(WebCore::appendElementToPath):
(WebCore::RenderThemeGadget::state):
(WebCore::RenderThemeGadget::setState):

• platform/gtk/RenderThemeGadget.h:
• platform/gtk/RenderThemeWidget.cpp: Added.

(WebCore::widgetMap):
(WebCore::RenderThemeWidget::getOrCreate):
(WebCore::RenderThemeWidget::clearCache):
(WebCore::RenderThemeWidget::~RenderThemeWidget):
(WebCore::RenderThemeScrollbar::RenderThemeScrollbar):
(WebCore::RenderThemeScrollbar::stepper):
(WebCore::RenderThemeToggleButton::RenderThemeToggleButton):
(WebCore::RenderThemeButton::RenderThemeButton):
(WebCore::RenderThemeComboBox::RenderThemeComboBox):
(WebCore::RenderThemeEntry::RenderThemeEntry):
(WebCore::RenderThemeSearchEntry::RenderThemeSearchEntry):
(WebCore::RenderThemeSpinButton::RenderThemeSpinButton):
(WebCore::RenderThemeSlider::RenderThemeSlider):
(WebCore::RenderThemeProgressBar::RenderThemeProgressBar):
(WebCore::RenderThemeListView::RenderThemeListView):
(WebCore::RenderThemeIcon::RenderThemeIcon):

• platform/gtk/RenderThemeWidget.h: Added.

(WebCore::RenderThemeEntry::entry):
(WebCore::RenderThemeEntry::selection):

• platform/gtk/ScrollbarThemeGtk.cpp:

(WebCore::ScrollbarThemeGtk::themeChanged):
(WebCore::ScrollbarThemeGtk::updateThemeProperties):
(WebCore::widgetTypeForScrollbar):
(WebCore::contentsRectangle):
(WebCore::ScrollbarThemeGtk::trackRect):
(WebCore::ScrollbarThemeGtk::backButtonRect):
(WebCore::ScrollbarThemeGtk::forwardButtonRect):
(WebCore::ScrollbarThemeGtk::paint):
(WebCore::ScrollbarThemeGtk::scrollbarThickness):
(WebCore::ScrollbarThemeGtk::minimumThumbLength):

• rendering/RenderThemeGtk.cpp:

(WebCore::createStyleContext):
(WebCore::setToggleSize):
(WebCore::paintToggle):
(WebCore::RenderThemeGtk::paintButton):
(WebCore::menuListColor):
(WebCore::RenderThemeGtk::popupInternalPaddingBox):
(WebCore::RenderThemeGtk::paintMenuList):
(WebCore::RenderThemeGtk::adjustTextFieldStyle):
(WebCore::RenderThemeGtk::paintTextField):
(WebCore::adjustSearchFieldIconStyle):
(WebCore::paintSearchFieldIcon):
(WebCore::RenderThemeGtk::paintSliderTrack):
(WebCore::RenderThemeGtk::adjustSliderThumbSize):
(WebCore::RenderThemeGtk::paintSliderThumb):
(WebCore::RenderThemeGtk::progressBarRectForBounds):
(WebCore::RenderThemeGtk::paintProgressBar):
(WebCore::RenderThemeGtk::adjustInnerSpinButtonStyle):
(WebCore::RenderThemeGtk::paintInnerSpinButton):
(WebCore::styleColor):
(WebCore::RenderThemeGtk::platformActiveSelectionBackgroundColor):
(WebCore::RenderThemeGtk::platformInactiveSelectionBackgroundColor):
(WebCore::RenderThemeGtk::platformActiveSelectionForegroundColor):
(WebCore::RenderThemeGtk::platformInactiveSelectionForegroundColor):
(WebCore::RenderThemeGtk::paintMediaButton):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• PlatformGTK.cmake (modified) (1 diff)
• platform/gtk/RenderThemeGadget.cpp (modified) (3 diffs)
• platform/gtk/RenderThemeGadget.h (modified) (2 diffs)
• platform/gtk/RenderThemeWidget.cpp (added)
• platform/gtk/RenderThemeWidget.h (added)
• platform/gtk/ScrollbarThemeGtk.cpp (modified) (20 diffs)
• rendering/RenderThemeGtk.cpp (modified) (28 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2017-06-01  Carlos Garcia Campos  <cgarcia@igalia.com>
+
+        [GTK] Cache RenderThemeGadget hierarchies for rendering themed elements with GTK+ 3.20+
+        https://bugs.webkit.org/show_bug.cgi?id=162673
+
+        Reviewed by Michael Catanzaro.
+
+        Because of the way the new theming system works in GTK+ >= 3.20 we are currently creating a gadget hierarchy
+        every time we need to render a styled element or get layout information about it. That's happening on every
+        repaint, and it's specially problematic for overlay scrollbar indicators that fade in/out when shown/hidden. We
+        need to cache the gadgets and simply apply the state before every paint or layout query. When using GtkWidgetPath,
+        calling gtk_style_context_save() breaks the gadget hierarchy, and style classes need to be set when building the
+        GtkWidgetPath. That means we can't cache RenderThemeGadgets, call save, apply style classes and state, and then
+        call restore. We need to cache gadget hierarchies with fixed style classes. Fortunately, setting the state does
+        work, so we don't need to also cache a different hierarchy for every possible state. For example, for the
+        particular case of scrollbars we would cache VerticalScrollbarRight, VerticalScrollbarLeft, HorizontalScrollbar,
+        VerticalScrollIndicatorRight, VerticalScrollIndicatorLeft and HorizontalScrollIndicator. In practice, we will
+        only have 4 of those at the same time in the cache.
+        This patch adds RenderThemeWidget to represent a hierarchy of gadgets with fixed style classes that can be
+        cached and reused to render or query style of those "widgets". It also simplifies the RenderThemeGtk and
+        ScrollbarThemeGtk code by removing a lot of duplicated code to build the gadget hierarchies.
+
+        * PlatformGTK.cmake:
+        * platform/gtk/RenderThemeGadget.cpp:
+        (WebCore::createStyleContext):
+        (WebCore::appendElementToPath):
+        (WebCore::RenderThemeGadget::state):
+        (WebCore::RenderThemeGadget::setState):
+        * platform/gtk/RenderThemeGadget.h:
+        * platform/gtk/RenderThemeWidget.cpp: Added.
+        (WebCore::widgetMap):
+        (WebCore::RenderThemeWidget::getOrCreate):
+        (WebCore::RenderThemeWidget::clearCache):
+        (WebCore::RenderThemeWidget::~RenderThemeWidget):
+        (WebCore::RenderThemeScrollbar::RenderThemeScrollbar):
+        (WebCore::RenderThemeScrollbar::stepper):
+        (WebCore::RenderThemeToggleButton::RenderThemeToggleButton):
+        (WebCore::RenderThemeButton::RenderThemeButton):
+        (WebCore::RenderThemeComboBox::RenderThemeComboBox):
+        (WebCore::RenderThemeEntry::RenderThemeEntry):
+        (WebCore::RenderThemeSearchEntry::RenderThemeSearchEntry):
+        (WebCore::RenderThemeSpinButton::RenderThemeSpinButton):
+        (WebCore::RenderThemeSlider::RenderThemeSlider):
+        (WebCore::RenderThemeProgressBar::RenderThemeProgressBar):
+        (WebCore::RenderThemeListView::RenderThemeListView):
+        (WebCore::RenderThemeIcon::RenderThemeIcon):
+        * platform/gtk/RenderThemeWidget.h: Added.
+        (WebCore::RenderThemeEntry::entry):
+        (WebCore::RenderThemeEntry::selection):
+        * platform/gtk/ScrollbarThemeGtk.cpp:
+        (WebCore::ScrollbarThemeGtk::themeChanged):
+        (WebCore::ScrollbarThemeGtk::updateThemeProperties):
+        (WebCore::widgetTypeForScrollbar):
+        (WebCore::contentsRectangle):
+        (WebCore::ScrollbarThemeGtk::trackRect):
+        (WebCore::ScrollbarThemeGtk::backButtonRect):
+        (WebCore::ScrollbarThemeGtk::forwardButtonRect):
+        (WebCore::ScrollbarThemeGtk::paint):
+        (WebCore::ScrollbarThemeGtk::scrollbarThickness):
+        (WebCore::ScrollbarThemeGtk::minimumThumbLength):
+        * rendering/RenderThemeGtk.cpp:
+        (WebCore::createStyleContext):
+        (WebCore::setToggleSize):
+        (WebCore::paintToggle):
+        (WebCore::RenderThemeGtk::paintButton):
+        (WebCore::menuListColor):
+        (WebCore::RenderThemeGtk::popupInternalPaddingBox):
+        (WebCore::RenderThemeGtk::paintMenuList):
+        (WebCore::RenderThemeGtk::adjustTextFieldStyle):
+        (WebCore::RenderThemeGtk::paintTextField):
+        (WebCore::adjustSearchFieldIconStyle):
+        (WebCore::paintSearchFieldIcon):
+        (WebCore::RenderThemeGtk::paintSliderTrack):
+        (WebCore::RenderThemeGtk::adjustSliderThumbSize):
+        (WebCore::RenderThemeGtk::paintSliderThumb):
+        (WebCore::RenderThemeGtk::progressBarRectForBounds):
+        (WebCore::RenderThemeGtk::paintProgressBar):
+        (WebCore::RenderThemeGtk::adjustInnerSpinButtonStyle):
+        (WebCore::RenderThemeGtk::paintInnerSpinButton):
+        (WebCore::styleColor):
+        (WebCore::RenderThemeGtk::platformActiveSelectionBackgroundColor):
+        (WebCore::RenderThemeGtk::platformInactiveSelectionBackgroundColor):
+        (WebCore::RenderThemeGtk::platformActiveSelectionForegroundColor):
+        (WebCore::RenderThemeGtk::platformInactiveSelectionForegroundColor):
+        (WebCore::RenderThemeGtk::paintMediaButton):
+
 2017-06-01  Andreas Kling  <akling@apple.com>
 

trunk/Source/WebCore/PlatformGTK.cmake

@@ -174 +174 @@
     platform/gtk/PlatformWheelEventGtk.cpp
     platform/gtk/RenderThemeGadget.cpp
+    platform/gtk/RenderThemeWidget.cpp
     platform/gtk/ScrollbarThemeGtk.cpp
     platform/gtk/SoundGtk.cpp

trunk/Source/WebCore/platform/gtk/RenderThemeGadget.cpp

@@ -61 +61 @@
     gtk_style_context_set_path(context.get(), path);
     gtk_style_context_set_parent(context.get(), parent);
-    // Unfortunately, we have to explicitly set the state again here for it to take effect.
-    gtk_style_context_set_state(context.get(), gtk_widget_path_iter_get_state(path, -1));
     return context;
 }
@@ -73 +71 @@
     for (const auto* className : info.classList)
         gtk_widget_path_iter_add_class(path, -1, className);
-    gtk_widget_path_iter_set_state(path, -1, static_cast<GtkStateFlags>(gtk_widget_path_iter_get_state(path, -1) | info.state));
 }
 
@@ -145 +142 @@
     gtk_style_context_get(m_context.get(), gtk_style_context_get_state(m_context.get()), "opacity", &returnValue, nullptr);
     return returnValue;
+}
+
+GtkStateFlags RenderThemeGadget::state() const
+{
+    return gtk_style_context_get_state(m_context.get());
+}
+
+void RenderThemeGadget::setState(GtkStateFlags state)
+{
+    gtk_style_context_set_state(m_context.get(), state);
 }
 

trunk/Source/WebCore/platform/gtk/RenderThemeGadget.h

@@ -57 +57 @@
         Type type;
         const char* name;
-        GtkStateFlags state;
         Vector<const char*> classList;
     };
@@ -77 +76 @@
 
     GtkStyleContext* context() const { return m_context.get(); }
+
+    GtkStateFlags state() const;
+    void setState(GtkStateFlags);
 
 protected:

trunk/Source/WebCore/platform/gtk/ScrollbarThemeGtk.cpp

@@ -31 +31 @@
 #include "PlatformContextCairo.h"
 #include "PlatformMouseEvent.h"
-#include "RenderThemeGadget.h"
+#include "RenderThemeWidget.h"
 #include "ScrollView.h"
 #include "Scrollbar.h"
@@ -97 +97 @@
 void ScrollbarThemeGtk::themeChanged()
 {
+#if GTK_CHECK_VERSION(3, 20, 0)
+    RenderThemeWidget::clearCache();
+#endif
     updateThemeProperties();
 }
@@ -103 +106 @@
 void ScrollbarThemeGtk::updateThemeProperties()
 {
-    auto steppers = static_cast<RenderThemeScrollbarGadget*>(RenderThemeGadget::create({ RenderThemeGadget::Type::Scrollbar, "scrollbar", GTK_STATE_FLAG_NORMAL, { } }).get())->steppers();
-    m_hasBackButtonStartPart = steppers.contains(RenderThemeScrollbarGadget::Steppers::Backward);
-    m_hasForwardButtonEndPart = steppers.contains(RenderThemeScrollbarGadget::Steppers::Forward);
-    m_hasBackButtonEndPart = steppers.contains(RenderThemeScrollbarGadget::Steppers::SecondaryBackward);
-    m_hasForwardButtonStartPart = steppers.contains(RenderThemeScrollbarGadget::Steppers::SecondaryForward);
+    auto& scrollbar = static_cast<RenderThemeScrollbar&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::VerticalScrollbarRight));
+    m_hasBackButtonStartPart = scrollbar.stepper(RenderThemeScrollbarGadget::Steppers::Backward);
+    m_hasForwardButtonEndPart = scrollbar.stepper(RenderThemeScrollbarGadget::Steppers::Forward);
+    m_hasBackButtonEndPart = scrollbar.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryBackward);
+    m_hasForwardButtonStartPart = scrollbar.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryForward);
 }
 #else
@@ -169 +172 @@
 }
 
-static std::unique_ptr<RenderThemeGadget> scrollbarGadgetForLayout(Scrollbar& scrollbar)
-{
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Scrollbar, "scrollbar", scrollbarPartStateFlags(scrollbar, AllParts), { } };
+static RenderThemeWidget::Type widgetTypeForScrollbar(Scrollbar& scrollbar, GtkStateFlags scrollbarState)
+{
     if (scrollbar.orientation() == VerticalScrollbar) {
-        info.classList.append("vertical");
-        info.classList.append("right");
-    } else {
-        info.classList.append("horizontal");
-        info.classList.append("bottom");
-    }
-    if (scrollbar.isOverlayScrollbar())
-        info.classList.append("overlay-indicator");
-    if (info.state & GTK_STATE_FLAG_PRELIGHT)
-        info.classList.append("hovering");
-
-    return RenderThemeGadget::create(info);
-}
-
-static std::unique_ptr<RenderThemeBoxGadget> contentsGadgetForLayout(Scrollbar& scrollbar, RenderThemeGadget* parent, IntRect& contentsRect, Vector<int, 4>& steppersPosition)
-{
-    Vector<RenderThemeGadget::Info> children;
-    auto steppers = static_cast<RenderThemeScrollbarGadget*>(parent)->steppers();
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::Backward)) {
-        steppersPosition[0] = 0;
-        children.append({ RenderThemeGadget::Type::Generic, "button", scrollbarPartStateFlags(scrollbar, BackButtonStartPart), { "up" } });
-    }
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::SecondaryForward)) {
-        steppersPosition[1] = children.size();
-        children.append({ RenderThemeGadget::Type::Generic, "button", scrollbarPartStateFlags(scrollbar, ForwardButtonStartPart), { "down" } });
-    }
-    children.append({ RenderThemeGadget::Type::Generic, "trough", scrollbarPartStateFlags(scrollbar, BackTrackPart), { } });
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::SecondaryBackward)) {
-        steppersPosition[2] = children.size();
-        children.append({ RenderThemeGadget::Type::Generic, "button", scrollbarPartStateFlags(scrollbar, BackButtonEndPart), { "up" } });
-    }
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::Forward)) {
-        steppersPosition[3] = children.size();
-        children.append({ RenderThemeGadget::Type::Generic, "button", scrollbarPartStateFlags(scrollbar, ForwardButtonEndPart), { "down" } });
-    }
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Generic, "contents", GTK_STATE_FLAG_NORMAL, { } };
-    auto contentsGadget = std::make_unique<RenderThemeBoxGadget>(info, scrollbar.orientation() == VerticalScrollbar ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL,
-        children, parent);
-
-    GtkBorder scrollbarContentsBox = parent->contentsBox();
-    GtkBorder contentsContentsBox = contentsGadget->contentsBox();
+        if (scrollbar.scrollableArea().shouldPlaceBlockDirectionScrollbarOnLeft())
+            return scrollbarState & GTK_STATE_FLAG_PRELIGHT ? RenderThemeWidget::Type::VerticalScrollbarLeft : RenderThemeWidget::Type::VerticalScrollIndicatorLeft;
+        return scrollbarState & GTK_STATE_FLAG_PRELIGHT ? RenderThemeWidget::Type::VerticalScrollbarRight : RenderThemeWidget::Type::VerticalScrollIndicatorRight;
+    }
+    return scrollbarState & GTK_STATE_FLAG_PRELIGHT ? RenderThemeWidget::Type::HorizontalScrollbar : RenderThemeWidget::Type::HorizontalScrollIndicator;
+}
+
+static IntRect contentsRectangle(Scrollbar& scrollbar, RenderThemeScrollbar& scrollbarWidget)
+{
+    GtkBorder scrollbarContentsBox = scrollbarWidget.scrollbar().contentsBox();
+    GtkBorder contentsContentsBox = scrollbarWidget.contents().contentsBox();
     GtkBorder padding;
     padding.left = scrollbarContentsBox.left + contentsContentsBox.left;
@@ -219 +191 @@
     padding.top = scrollbarContentsBox.top + contentsContentsBox.top;
     padding.bottom = scrollbarContentsBox.bottom + contentsContentsBox.bottom;
-    contentsRect = scrollbar.frameRect();
+    IntRect contentsRect = scrollbar.frameRect();
     contentsRect.move(padding.left, padding.top);
     contentsRect.contract(padding.left + padding.right, padding.top + padding.bottom);
-    return contentsGadget;
+    return contentsRect;
 }
 
 IntRect ScrollbarThemeGtk::trackRect(Scrollbar& scrollbar, bool /*painting*/)
 {
-    auto scrollbarGadget = scrollbarGadgetForLayout(scrollbar);
-    IntRect rect;
-    Vector<int, 4> steppersPosition(4, -1);
-    auto contentsGadget = contentsGadgetForLayout(scrollbar, scrollbarGadget.get(), rect, steppersPosition);
-
-    if (steppersPosition[0] != -1) {
-        IntSize stepperSize = contentsGadget->child(steppersPosition[0])->preferredSize();
+    auto scrollbarState = scrollbarPartStateFlags(scrollbar, AllParts);
+    auto& scrollbarWidget = static_cast<RenderThemeScrollbar&>(RenderThemeWidget::getOrCreate(widgetTypeForScrollbar(scrollbar, scrollbarState)));
+    scrollbarWidget.scrollbar().setState(scrollbarState);
+
+    IntRect rect = contentsRectangle(scrollbar, scrollbarWidget);
+    if (auto* backwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Backward)) {
+        backwardStepper->setState(scrollbarPartStateFlags(scrollbar, BackButtonStartPart));
+        IntSize stepperSize = backwardStepper->preferredSize();
         if (scrollbar.orientation() == VerticalScrollbar) {
             rect.move(0, stepperSize.height());
@@ -242 +215 @@
         }
     }
-    if (steppersPosition[1] != -1) {
-        IntSize stepperSize = contentsGadget->child(steppersPosition[1])->preferredSize();
+    if (auto* secondaryForwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryForward)) {
+        secondaryForwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonStartPart));
+        IntSize stepperSize = secondaryForwardStepper->preferredSize();
         if (scrollbar.orientation() == VerticalScrollbar) {
             rect.move(0, stepperSize.height());
@@ -252 +226 @@
         }
     }
-    if (steppersPosition[2] != -1) {
+    if (auto* secondaryBackwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryBackward)) {
+        secondaryBackwardStepper->setState(scrollbarPartStateFlags(scrollbar, BackButtonEndPart));
         if (scrollbar.orientation() == VerticalScrollbar)
-            rect.contract(0, contentsGadget->child(steppersPosition[2])->preferredSize().height());
+            rect.contract(0, secondaryBackwardStepper->preferredSize().height());
         else
-            rect.contract(contentsGadget->child(steppersPosition[2])->preferredSize().width(), 0);
-    }
-    if (steppersPosition[3] != -1) {
+            rect.contract(secondaryBackwardStepper->preferredSize().width(), 0);
+    }
+    if (auto* forwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Forward)) {
+        forwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonEndPart));
         if (scrollbar.orientation() == VerticalScrollbar)
-            rect.contract(0, contentsGadget->child(steppersPosition[3])->preferredSize().height());
+            rect.contract(0, forwardStepper->preferredSize().height());
         else
-            rect.contract(contentsGadget->child(steppersPosition[3])->preferredSize().width(), 0);
+            rect.contract(forwardStepper->preferredSize().width(), 0);
     }
 
@@ -328 +304 @@
         return IntRect();
 
-    auto scrollbarGadget = scrollbarGadgetForLayout(scrollbar);
-    IntRect rect;
-    Vector<int, 4> steppersPosition(4, -1);
-    auto contentsGadget = contentsGadgetForLayout(scrollbar, scrollbarGadget.get(), rect, steppersPosition);
-
-    if (part == BackButtonStartPart)
-        return IntRect(rect.location(), contentsGadget->child(0)->preferredSize());
-
-    // Secondary back.
-    if (steppersPosition[1] != -1) {
-        IntSize preferredSize = contentsGadget->child(steppersPosition[1])->preferredSize();
+    auto scrollbarState = scrollbarPartStateFlags(scrollbar, AllParts);
+    auto& scrollbarWidget = static_cast<RenderThemeScrollbar&>(RenderThemeWidget::getOrCreate(widgetTypeForScrollbar(scrollbar, scrollbarState)));
+    scrollbarWidget.scrollbar().setState(scrollbarState);
+
+    IntRect rect = contentsRectangle(scrollbar, scrollbarWidget);
+    if (part == BackButtonStartPart) {
+        auto* backwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Backward);
+        ASSERT(backwardStepper);
+        backwardStepper->setState(scrollbarPartStateFlags(scrollbar, BackButtonStartPart));
+        return IntRect(rect.location(), backwardStepper->preferredSize());
+    }
+
+    if (auto* secondaryForwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryForward)) {
+        secondaryForwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonStartPart));
+        IntSize preferredSize = secondaryForwardStepper->preferredSize();
         if (scrollbar.orientation() == VerticalScrollbar) {
             rect.move(0, preferredSize.height());
@@ -348 +328 @@
     }
 
-    if (steppersPosition[3] != -1) {
+    if (auto* secondaryBackwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryBackward)) {
+        secondaryBackwardStepper->setState(scrollbarPartStateFlags(scrollbar, BackButtonEndPart));
         if (scrollbar.orientation() == VerticalScrollbar)
-            rect.contract(0, contentsGadget->child(steppersPosition[3])->preferredSize().height());
+            rect.contract(0, secondaryBackwardStepper->preferredSize().height());
         else
-            rect.contract(contentsGadget->child(steppersPosition[3])->preferredSize().width(), 0);
-    }
-
-    IntSize preferredSize = contentsGadget->child(steppersPosition[2])->preferredSize();
+            rect.contract(secondaryBackwardStepper->preferredSize().width(), 0);
+    }
+
+    auto* forwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Forward);
+    ASSERT(forwardStepper);
+    forwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonEndPart));
+    IntSize preferredSize = forwardStepper->preferredSize();
     if (scrollbar.orientation() == VerticalScrollbar)
         rect.move(0, rect.height() - preferredSize.height());
@@ -370 +354 @@
         return IntRect();
 
-    auto scrollbarGadget = scrollbarGadgetForLayout(scrollbar);
-    IntRect rect;
-    Vector<int, 4> steppersPosition(4, -1);
-    auto contentsGadget = contentsGadgetForLayout(scrollbar, scrollbarGadget.get(), rect, steppersPosition);
-
-    if (steppersPosition[0] != -1) {
-        IntSize preferredSize = contentsGadget->child(steppersPosition[0])->preferredSize();
+    auto scrollbarState = scrollbarPartStateFlags(scrollbar, AllParts);
+    auto& scrollbarWidget = static_cast<RenderThemeScrollbar&>(RenderThemeWidget::getOrCreate(widgetTypeForScrollbar(scrollbar, scrollbarState)));
+    scrollbarWidget.scrollbar().setState(scrollbarState);
+
+    IntRect rect = contentsRectangle(scrollbar, scrollbarWidget);
+    if (auto* backwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Backward)) {
+        backwardStepper->setState(scrollbarPartStateFlags(scrollbar, BackButtonStartPart));
+        IntSize preferredSize = backwardStepper->preferredSize();
         if (scrollbar.orientation() == VerticalScrollbar) {
             rect.move(0, preferredSize.height());
@@ -386 +371 @@
     }
 
-    if (steppersPosition[1] != -1) {
-        IntSize preferredSize = contentsGadget->child(steppersPosition[1])->preferredSize();
+    if (auto* secondaryForwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryForward)) {
+        secondaryForwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonStartPart));
+        IntSize preferredSize = secondaryForwardStepper->preferredSize();
         if (part == ForwardButtonStartPart)
             return IntRect(rect.location(), preferredSize);
@@ -400 +386 @@
     }
 
-    // Forward button.
-    IntSize preferredSize = contentsGadget->child(steppersPosition[3])->preferredSize();
+    auto* forwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Forward);
+    ASSERT(forwardStepper);
+    forwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonEndPart));
+    IntSize preferredSize = forwardStepper->preferredSize();
     if (scrollbar.orientation() == VerticalScrollbar)
         rect.move(0, rect.height() - preferredSize.height());
@@ -478 +466 @@
         return true;
 
-    bool scrollbarOnLeft = scrollbar.scrollableArea().shouldPlaceBlockDirectionScrollbarOnLeft();
-
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Scrollbar, "scrollbar", scrollbarPartStateFlags(scrollbar, AllParts, true), { } };
-    if (scrollbar.orientation() == VerticalScrollbar) {
-        info.classList.append("vertical");
-        info.classList.append(scrollbarOnLeft ? "left" : "right");
-    } else {
-        info.classList.append("horizontal");
-        info.classList.append("bottom");
-    }
+    auto scrollbarState = scrollbarPartStateFlags(scrollbar, AllParts, true);
+    auto& scrollbarWidget = static_cast<RenderThemeScrollbar&>(RenderThemeWidget::getOrCreate(widgetTypeForScrollbar(scrollbar, scrollbarState)));
+    auto& scrollbarGadget = scrollbarWidget.scrollbar();
+    scrollbarGadget.setState(scrollbarState);
     if (m_usesOverlayScrollbars)
-        info.classList.append("overlay-indicator");
-    if (info.state & GTK_STATE_FLAG_PRELIGHT)
-        info.classList.append("hovering");
-    if (scrollbar.pressedPart() != NoPart)
-        info.classList.append("dragging");
-    auto scrollbarGadget = RenderThemeGadget::create(info);
-    if (m_usesOverlayScrollbars)
-        opacity *= scrollbarGadget->opacity();
+        opacity *= scrollbarGadget.opacity();
     if (!opacity)
         return true;
 
-    info.type = RenderThemeGadget::Type::Generic;
-    info.name = "contents";
-    info.state = GTK_STATE_FLAG_NORMAL;
-    info.classList.clear();
-    Vector<RenderThemeGadget::Info> children;
-    auto steppers = static_cast<RenderThemeScrollbarGadget*>(scrollbarGadget.get())->steppers();
-    unsigned steppersPosition[4] = { 0, 0, 0, 0 };
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::Backward)) {
-        steppersPosition[0] = children.size();
-        children.append({ RenderThemeGadget::Type::Generic, "button", scrollbarPartStateFlags(scrollbar, BackButtonStartPart), { "up" } });
-    }
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::SecondaryForward)) {
-        steppersPosition[1] = children.size();
-        children.append({ RenderThemeGadget::Type::Generic, "button", scrollbarPartStateFlags(scrollbar, ForwardButtonStartPart), { "down" } });
-    }
-    unsigned troughPosition = children.size();
-    children.append({ RenderThemeGadget::Type::Generic, "trough", scrollbarPartStateFlags(scrollbar, BackTrackPart), { } });
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::SecondaryBackward)) {
-        steppersPosition[2] = children.size();
-        children.append({ RenderThemeGadget::Type::Generic, "button", scrollbarPartStateFlags(scrollbar, BackButtonEndPart), { "up" } });
-    }
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::Forward)) {
-        steppersPosition[3] = children.size();
-        children.append({ RenderThemeGadget::Type::Generic, "button", scrollbarPartStateFlags(scrollbar, ForwardButtonEndPart), { "down" } });
-    }
-    auto contentsGadget = std::make_unique<RenderThemeBoxGadget>(info, scrollbar.orientation() == VerticalScrollbar ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL,
-        children, scrollbarGadget.get());
-    RenderThemeGadget* troughGadget = contentsGadget->child(troughPosition);
-
-    IntSize preferredSize = contentsGadget->preferredSize();
-    std::unique_ptr<RenderThemeGadget> sliderGadget;
+    auto& trough = scrollbarWidget.trough();
+    trough.setState(scrollbarPartStateFlags(scrollbar, BackTrackPart));
+
+    auto* backwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Backward);
+    if (backwardStepper)
+        backwardStepper->setState(scrollbarPartStateFlags(scrollbar, BackButtonStartPart));
+    auto* secondaryForwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryForward);
+    if (secondaryForwardStepper)
+        secondaryForwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonStartPart));
+    auto* secondaryBackwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryBackward);
+    if (secondaryBackwardStepper)
+        secondaryBackwardStepper->setState(scrollbarPartStateFlags(scrollbar, BackButtonEndPart));
+    auto* forwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Forward);
+    if (forwardStepper)
+        forwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonEndPart));
+
+    IntSize preferredSize = scrollbarWidget.contents().preferredSize();
     int thumbSize = thumbLength(scrollbar);
     if (thumbSize) {
-        info.name = "slider";
-        info.state = scrollbarPartStateFlags(scrollbar, ThumbPart);
-        sliderGadget = RenderThemeGadget::create(info, troughGadget);
-        preferredSize = preferredSize.expandedTo(sliderGadget->preferredSize());
-    }
-    preferredSize += scrollbarGadget->preferredSize() - scrollbarGadget->minimumSize();
+        scrollbarWidget.slider().setState(scrollbarPartStateFlags(scrollbar, ThumbPart));
+        preferredSize = preferredSize.expandedTo(scrollbarWidget.slider().preferredSize());
+    }
+    preferredSize += scrollbarGadget.preferredSize() - scrollbarGadget.minimumSize();
 
     FloatRect contentsRect(rect);
@@ -545 +504 @@
     if (scrollbar.orientation() == VerticalScrollbar) {
         if (rect.width() != preferredSize.width()) {
-            if (!scrollbarOnLeft)
+            if (!scrollbar.scrollableArea().shouldPlaceBlockDirectionScrollbarOnLeft())
                 contentsRect.move(std::abs(rect.width() - preferredSize.width()), 0);
             contentsRect.setWidth(preferredSize.width());
@@ -562 +521 @@
     }
 
-    scrollbarGadget->render(graphicsContext.platformContext()->cr(), contentsRect, &contentsRect);
-    contentsGadget->render(graphicsContext.platformContext()->cr(), contentsRect, &contentsRect);
-
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::Backward)) {
-        RenderThemeGadget* buttonGadget = contentsGadget->child(steppersPosition[0]);
+    scrollbarGadget.render(graphicsContext.platformContext()->cr(), contentsRect, &contentsRect);
+    scrollbarWidget.contents().render(graphicsContext.platformContext()->cr(), contentsRect, &contentsRect);
+
+    if (backwardStepper) {
         FloatRect buttonRect = contentsRect;
         if (scrollbar.orientation() == VerticalScrollbar)
-            buttonRect.setHeight(buttonGadget->preferredSize().height());
+            buttonRect.setHeight(backwardStepper->preferredSize().height());
         else
-            buttonRect.setWidth(buttonGadget->preferredSize().width());
-        static_cast<RenderThemeScrollbarGadget*>(scrollbarGadget.get())->renderStepper(graphicsContext.platformContext()->cr(), buttonRect, buttonGadget,
+            buttonRect.setWidth(backwardStepper->preferredSize().width());
+        static_cast<RenderThemeScrollbarGadget&>(scrollbarGadget).renderStepper(graphicsContext.platformContext()->cr(), buttonRect, backwardStepper,
             scrollbar.orientation() == VerticalScrollbar ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL, RenderThemeScrollbarGadget::Steppers::Backward);
         if (scrollbar.orientation() == VerticalScrollbar) {
@@ -582 +540 @@
         }
     }
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::SecondaryForward)) {
-        RenderThemeGadget* buttonGadget = contentsGadget->child(steppersPosition[1]);
+    if (secondaryForwardStepper) {
         FloatRect buttonRect = contentsRect;
         if (scrollbar.orientation() == VerticalScrollbar)
-            buttonRect.setHeight(buttonGadget->preferredSize().height());
+            buttonRect.setHeight(secondaryForwardStepper->preferredSize().height());
         else
-            buttonRect.setWidth(buttonGadget->preferredSize().width());
-        static_cast<RenderThemeScrollbarGadget*>(scrollbarGadget.get())->renderStepper(graphicsContext.platformContext()->cr(), buttonRect, buttonGadget,
+            buttonRect.setWidth(secondaryForwardStepper->preferredSize().width());
+        static_cast<RenderThemeScrollbarGadget&>(scrollbarGadget).renderStepper(graphicsContext.platformContext()->cr(), buttonRect, secondaryForwardStepper,
             scrollbar.orientation() == VerticalScrollbar ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL, RenderThemeScrollbarGadget::Steppers::SecondaryForward);
         if (scrollbar.orientation() == VerticalScrollbar) {
@@ -599 +556 @@
         }
     }
-
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::Forward)) {
-        RenderThemeGadget* buttonGadget = contentsGadget->child(steppersPosition[3]);
+    if (secondaryBackwardStepper) {
         FloatRect buttonRect = contentsRect;
         if (scrollbar.orientation() == VerticalScrollbar) {
-            buttonRect.setHeight(buttonGadget->preferredSize().height());
+            buttonRect.setHeight(secondaryBackwardStepper->preferredSize().height());
             buttonRect.move(0, contentsRect.height() - buttonRect.height());
         } else {
-            buttonRect.setWidth(buttonGadget->preferredSize().width());
+            buttonRect.setWidth(secondaryBackwardStepper->preferredSize().width());
             buttonRect.move(contentsRect.width() - buttonRect.width(), 0);
         }
-        static_cast<RenderThemeScrollbarGadget*>(scrollbarGadget.get())->renderStepper(graphicsContext.platformContext()->cr(), buttonRect, buttonGadget,
+        static_cast<RenderThemeScrollbarGadget&>(scrollbarGadget).renderStepper(graphicsContext.platformContext()->cr(), buttonRect, secondaryBackwardStepper,
+            scrollbar.orientation() == VerticalScrollbar ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL, RenderThemeScrollbarGadget::Steppers::SecondaryBackward);
+        if (scrollbar.orientation() == VerticalScrollbar)
+            contentsRect.contract(0, buttonRect.height());
+        else
+            contentsRect.contract(buttonRect.width(), 0);
+    }
+    if (forwardStepper) {
+        FloatRect buttonRect = contentsRect;
+        if (scrollbar.orientation() == VerticalScrollbar) {
+            buttonRect.setHeight(forwardStepper->preferredSize().height());
+            buttonRect.move(0, contentsRect.height() - buttonRect.height());
+        } else {
+            buttonRect.setWidth(forwardStepper->preferredSize().width());
+            buttonRect.move(contentsRect.width() - buttonRect.width(), 0);
+        }
+        static_cast<RenderThemeScrollbarGadget&>(scrollbarGadget).renderStepper(graphicsContext.platformContext()->cr(), buttonRect, forwardStepper,
             scrollbar.orientation() == VerticalScrollbar ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL, RenderThemeScrollbarGadget::Steppers::Forward);
         if (scrollbar.orientation() == VerticalScrollbar)
@@ -617 +588 @@
             contentsRect.contract(buttonRect.width(), 0);
     }
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::SecondaryBackward)) {
-        RenderThemeGadget* buttonGadget = contentsGadget->child(steppersPosition[2]);
-        FloatRect buttonRect = contentsRect;
-        if (scrollbar.orientation() == VerticalScrollbar) {
-            buttonRect.setHeight(buttonGadget->preferredSize().height());
-            buttonRect.move(0, contentsRect.height() - buttonRect.height());
-        } else {
-            buttonRect.setWidth(buttonGadget->preferredSize().width());
-            buttonRect.move(contentsRect.width() - buttonRect.width(), 0);
-        }
-        static_cast<RenderThemeScrollbarGadget*>(scrollbarGadget.get())->renderStepper(graphicsContext.platformContext()->cr(), buttonRect, buttonGadget,
-            scrollbar.orientation() == VerticalScrollbar ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL, RenderThemeScrollbarGadget::Steppers::SecondaryBackward);
-        if (scrollbar.orientation() == VerticalScrollbar)
-            contentsRect.contract(0, buttonRect.height());
-        else
-            contentsRect.contract(buttonRect.width(), 0);
-    }
-
-    troughGadget->render(graphicsContext.platformContext()->cr(), contentsRect, &contentsRect);
-    if (sliderGadget) {
+
+    trough.render(graphicsContext.platformContext()->cr(), contentsRect, &contentsRect);
+
+    if (thumbSize) {
         if (scrollbar.orientation() == VerticalScrollbar) {
             contentsRect.move(0, thumbPosition(scrollbar));
-            contentsRect.setWidth(sliderGadget->preferredSize().width());
+            contentsRect.setWidth(scrollbarWidget.slider().preferredSize().width());
             contentsRect.setHeight(thumbSize);
         } else {
             contentsRect.move(thumbPosition(scrollbar), 0);
             contentsRect.setWidth(thumbSize);
-            contentsRect.setHeight(sliderGadget->preferredSize().height());
+            contentsRect.setHeight(scrollbarWidget.slider().preferredSize().height());
         }
         if (contentsRect.intersects(damageRect))
-            sliderGadget->render(graphicsContext.platformContext()->cr(), contentsRect);
+            scrollbarWidget.slider().render(graphicsContext.platformContext()->cr(), contentsRect);
     }
 
@@ -847 +802 @@
 int ScrollbarThemeGtk::scrollbarThickness(ScrollbarControlSize, ScrollbarExpansionState)
 {
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Scrollbar, "scrollbar", GTK_STATE_FLAG_PRELIGHT, { "vertical", "right", "hovering" } };
-    if (m_usesOverlayScrollbars)
-        info.classList.append("overlay-indicator");
-    auto scrollbarGadget = RenderThemeGadget::create(info);
-    info.type = RenderThemeGadget::Type::Generic;
-    info.name = "contents";
-    info.state = GTK_STATE_FLAG_NORMAL;
-    info.classList.clear();
-    Vector<RenderThemeGadget::Info> children;
-    auto steppers = static_cast<RenderThemeScrollbarGadget*>(scrollbarGadget.get())->steppers();
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::Backward))
-        children.append({ RenderThemeGadget::Type::Generic, "button", GTK_STATE_FLAG_NORMAL, { "up" } });
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::SecondaryForward))
-        children.append({ RenderThemeGadget::Type::Generic, "button", GTK_STATE_FLAG_NORMAL, { "down" } });
-    unsigned troughPositon = children.size();
-    children.append({ RenderThemeGadget::Type::Generic, "trough", GTK_STATE_FLAG_PRELIGHT, { } });
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::SecondaryBackward))
-        children.append({ RenderThemeGadget::Type::Generic, "button", GTK_STATE_FLAG_NORMAL, { "up" } });
-    if (steppers.contains(RenderThemeScrollbarGadget::Steppers::Forward))
-        children.append({ RenderThemeGadget::Type::Generic, "button", GTK_STATE_FLAG_NORMAL, { "down" } });
-    auto contentsGadget = std::make_unique<RenderThemeBoxGadget>(info, GTK_ORIENTATION_VERTICAL, children, scrollbarGadget.get());
-    info.name = "slider";
-    auto sliderGadget = RenderThemeGadget::create(info, contentsGadget->child(troughPositon));
-    IntSize contentsPreferredSize = contentsGadget->preferredSize();
-    contentsPreferredSize = contentsPreferredSize.expandedTo(sliderGadget->preferredSize());
-    IntSize preferredSize = contentsPreferredSize + scrollbarGadget->preferredSize() - scrollbarGadget->minimumSize();
-
+    auto& scrollbarWidget = static_cast<RenderThemeScrollbar&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::VerticalScrollbarRight));
+    scrollbarWidget.scrollbar().setState(GTK_STATE_FLAG_PRELIGHT);
+    IntSize contentsPreferredSize = scrollbarWidget.contents().preferredSize();
+    contentsPreferredSize = contentsPreferredSize.expandedTo(scrollbarWidget.slider().preferredSize());
+    IntSize preferredSize = contentsPreferredSize + scrollbarWidget.scrollbar().preferredSize() - scrollbarWidget.scrollbar().minimumSize();
     return preferredSize.width();
 }
@@ -888 +821 @@
 int ScrollbarThemeGtk::minimumThumbLength(Scrollbar& scrollbar)
 {
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Scrollbar, "scrollbar", GTK_STATE_FLAG_PRELIGHT, { "vertical", "right", "hovering" } };
-    if (m_usesOverlayScrollbars)
-        info.classList.append("overlay-indicator");
-    auto scrollbarGadget = RenderThemeGadget::create(info);
-    info.type = RenderThemeGadget::Type::Generic;
-    info.name = "contents";
-    info.state = GTK_STATE_FLAG_NORMAL;
-    info.classList.clear();
-    Vector<RenderThemeGadget::Info> children = {{ RenderThemeGadget::Type::Generic, "trough", GTK_STATE_FLAG_PRELIGHT, { } } };
-    auto contentsGadget = std::make_unique<RenderThemeBoxGadget>(info, GTK_ORIENTATION_VERTICAL, children, scrollbarGadget.get());
-    info.name = "slider";
-    IntSize minSize = RenderThemeGadget::create(info, contentsGadget->child(0))->minimumSize();
+    auto& scrollbarWidget = static_cast<RenderThemeScrollbar&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::VerticalScrollbarRight));
+    scrollbarWidget.scrollbar().setState(GTK_STATE_FLAG_PRELIGHT);
+    IntSize minSize = scrollbarWidget.slider().minimumSize();
     return scrollbar.orientation() == VerticalScrollbar ? minSize.height() : minSize.width();
 }

trunk/Source/WebCore/rendering/RenderThemeGtk.cpp

@@ -45 +45 @@
 #include "RenderObject.h"
 #include "RenderProgress.h"
-#include "RenderThemeGadget.h"
+#include "RenderThemeWidget.h"
 #include "ScrollbarThemeGtk.h"
 #include "StringTruncator.h"
@@ -186 +186 @@
     switch (themePart) {
     case Entry:
+    case EntrySelection:
         gtk_widget_path_append_type(path.get(), GTK_TYPE_ENTRY);
         gtk_widget_path_iter_add_class(path.get(), -1, GTK_STYLE_CLASS_ENTRY);
@@ -528 +529 @@
         return;
 
-    RenderThemeGadget::Info info = {
-        .type = RenderThemeGadget::Type::Generic,
-        .name = themePart == CheckButton ? "checkbutton" : "radiobutton",
-        .state = GTK_STATE_FLAG_NORMAL,
-        .classList = { }
-    };
-    auto parentGadget = RenderThemeGadget::create(info);
-    if (themePart == CheckButton) {
-        info.type = RenderThemeGadget::Type::Check;
-        info.name = "check";
-    } else {
-        info.type = RenderThemeGadget::Type::Radio;
-        info.name = "radio";
-    }
-    auto gadget = RenderThemeToggleGadget::create(info);
-    IntSize preferredSize = parentGadget->preferredSize();
-    preferredSize = preferredSize.expandedTo(gadget->preferredSize());
+    auto& toggleWidget = static_cast<RenderThemeToggleButton&>(RenderThemeWidget::getOrCreate(themePart == CheckButton ? RenderThemeWidget::Type::CheckButton : RenderThemeWidget::Type::RadioButton));
+    toggleWidget.button().setState(GTK_STATE_FLAG_NORMAL);
+    toggleWidget.toggle().setState(GTK_STATE_FLAG_NORMAL);
+    IntSize preferredSize = toggleWidget.button().preferredSize();
+    preferredSize = preferredSize.expandedTo(toggleWidget.toggle().preferredSize());
 
     if (style.width().isIntrinsicOrAuto())
@@ -557 +546 @@
     ASSERT(themePart == CheckButton || themePart == RadioButton);
 
-    RenderThemeGadget::Info parentInfo = {
-        .type = RenderThemeGadget::Type::Generic,
-        .name = themePart == CheckButton ? "checkbutton" : "radiobutton",
-        .state = themePartStateFlags(*theme, themePart, renderObject),
-        .classList = { "text-button" }
-    };
-    auto parentGadget = RenderThemeGadget::create(parentInfo);
-    RenderThemeGadget::Info info;
-    info.state = parentInfo.state;
-    if (themePart == CheckButton) {
-        info.type = RenderThemeGadget::Type::Check;
-        info.name = "check";
-    } else {
-        info.type = RenderThemeGadget::Type::Radio;
-        info.name = "radio";
-    }
-    auto gadget = RenderThemeGadget::create(info, parentGadget.get());
+    auto& toggleWidget = static_cast<RenderThemeToggleButton&>(RenderThemeWidget::getOrCreate(themePart == CheckButton ? RenderThemeWidget::Type::CheckButton : RenderThemeWidget::Type::RadioButton));
+    auto toggleState = themePartStateFlags(*theme, themePart, renderObject);
+    toggleWidget.button().setState(toggleState);
+    toggleWidget.toggle().setState(toggleState);
 
     FloatRect rect = fullRect;
@@ -580 +556 @@
     // in the full toggle button region. The reason for not simply forcing toggle
     // buttons to be a smaller size is that we don't want to break site layouts.
-    IntSize preferredSize = parentGadget->preferredSize();
-    preferredSize = preferredSize.expandedTo(gadget->preferredSize());
+    IntSize preferredSize = toggleWidget.button().preferredSize();
+    preferredSize = preferredSize.expandedTo(toggleWidget.toggle().preferredSize());
     shrinkToMinimumSizeAndCenterRectangle(rect, preferredSize);
-    parentGadget->render(paintInfo.context().platformContext()->cr(), rect);
-    gadget->render(paintInfo.context().platformContext()->cr(), rect);
+    toggleWidget.button().render(paintInfo.context().platformContext()->cr(), rect);
+    toggleWidget.toggle().render(paintInfo.context().platformContext()->cr(), rect);
 
     if (theme->isFocused(renderObject))
-        parentGadget->renderFocus(paintInfo.context().platformContext()->cr(), rect);
+        toggleWidget.button().renderFocus(paintInfo.context().platformContext()->cr(), rect);
 }
 #else
@@ -684 +660 @@
 bool RenderThemeGtk::paintButton(const RenderObject& renderObject, const PaintInfo& paintInfo, const IntRect& rect)
 {
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Generic, "button", themePartStateFlags(*this, Button, renderObject), { "text-button" } };
-    if (isDefault(renderObject))
-        info.classList.append("default");
-    auto gadget = RenderThemeGadget::create(info);
-    gadget->render(paintInfo.context().platformContext()->cr(), rect);
+    auto& buttonWidget = static_cast<RenderThemeButton&>(RenderThemeWidget::getOrCreate(isDefault(renderObject) ? RenderThemeWidget::Type::ButtonDefault : RenderThemeWidget::Type::Button));
+    buttonWidget.button().setState(themePartStateFlags(*this, Button, renderObject));
+    buttonWidget.button().render(paintInfo.context().platformContext()->cr(), rect);
     if (isFocused(renderObject))
-        gadget->renderFocus(paintInfo.context().platformContext()->cr(), rect);
+        buttonWidget.button().renderFocus(paintInfo.context().platformContext()->cr(), rect);
     return false;
 }
@@ -772 +746 @@
 {
 #if GTK_CHECK_VERSION(3, 20, 0)
-    RenderThemeGadget::Info info { RenderThemeGadget::Type::Generic, "combobox", element->isDisabledFormControl() ? GTK_STATE_FLAG_INSENSITIVE : GTK_STATE_FLAG_NORMAL, { } };
-    auto comboGadget = RenderThemeGadget::create(info);
-    Vector<RenderThemeGadget::Info> children {
-        { RenderThemeGadget::Type::Generic, "button", info.state, { "combo" } }
-    };
-    info.name = "box";
-    info.classList = { "horizontal", "linked" };
-    return RenderThemeBoxGadget(info, GTK_ORIENTATION_HORIZONTAL, children, comboGadget.get()).child(0)->color();
+    auto& comboWidget = static_cast<RenderThemeComboBox&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::ComboBox));
+    GtkStateFlags state = element->isDisabledFormControl() ? GTK_STATE_FLAG_INSENSITIVE : GTK_STATE_FLAG_NORMAL;
+    comboWidget.comboBox().setState(state);
+    comboWidget.button().setState(state);
+    return comboWidget.button().color();
 #else
     GRefPtr<GtkStyleContext> parentStyleContext = createStyleContext(ComboBox);
@@ -825 +796 @@
         return LengthBox(0);
 
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Generic, "combobox", GTK_STATE_FLAG_NORMAL, { } };
-    auto comboGadget = RenderThemeGadget::create(info);
-    Vector<RenderThemeGadget::Info> children = {
-        { RenderThemeGadget::Type::Generic, "button", GTK_STATE_FLAG_NORMAL, { "combo" } }
-    };
-    info.name = "box";
-    info.classList = { "horizontal", "linked" };
-    auto boxGadget = std::make_unique<RenderThemeBoxGadget>(info, GTK_ORIENTATION_HORIZONTAL, children, comboGadget.get());
-    RenderThemeGadget* buttonGadget = boxGadget->child(0);
-    info.classList.removeLast();
-    auto buttonBoxGadget = RenderThemeGadget::create(info, buttonGadget);
-    info.name = "arrow";
-    info.classList = { };
-    auto arrowGadget = RenderThemeGadget::create(info, buttonBoxGadget.get());
-    GtkBorder comboContentsBox = comboGadget->contentsBox();
-    GtkBorder boxContentsBox = boxGadget->contentsBox();
-    GtkBorder buttonContentsBox = buttonGadget->contentsBox();
-    GtkBorder buttonBoxContentsBox = buttonBoxGadget->contentsBox();
+    auto& comboWidget = static_cast<RenderThemeComboBox&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::ComboBox));
+    comboWidget.comboBox().setState(GTK_STATE_FLAG_NORMAL);
+    comboWidget.button().setState(GTK_STATE_FLAG_NORMAL);
+    comboWidget.arrow().setState(GTK_STATE_FLAG_NORMAL);
+    GtkBorder comboContentsBox = comboWidget.comboBox().contentsBox();
+    GtkBorder boxContentsBox = comboWidget.box().contentsBox();
+    GtkBorder buttonContentsBox = comboWidget.button().contentsBox();
+    GtkBorder buttonBoxContentsBox = comboWidget.buttonBox().contentsBox();
     GtkBorder padding;
     padding.left = comboContentsBox.left + boxContentsBox.left + buttonContentsBox.left + buttonBoxContentsBox.left;
@@ -849 +810 @@
     padding.bottom = comboContentsBox.bottom + boxContentsBox.bottom + buttonContentsBox.bottom + buttonBoxContentsBox.bottom;
 
-    auto arrowSize = arrowGadget->preferredSize();
+    auto arrowSize = comboWidget.arrow().preferredSize();
     return LengthBox(padding.top, padding.right + (style.direction() == LTR ? arrowSize.width() : 0),
         padding.bottom, padding.left + (style.direction() == RTL ? arrowSize.width() : 0));
@@ -856 +817 @@
 bool RenderThemeGtk::paintMenuList(const RenderObject& renderObject, const PaintInfo& paintInfo, const FloatRect& rect)
 {
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Generic, "combobox", themePartStateFlags(*this, ComboBoxButton, renderObject), { } };
-    auto comboGadget = RenderThemeGadget::create(info);
-    Vector<RenderThemeGadget::Info> children = {
-        { RenderThemeGadget::Type::Generic, "button", info.state, { "combo" } }
-    };
-    info.name = "box";
-    info.classList = { "horizontal", "linked" };
-    auto boxGadget = std::make_unique<RenderThemeBoxGadget>(info, GTK_ORIENTATION_HORIZONTAL, children, comboGadget.get());
-    RenderThemeGadget* buttonGadget = boxGadget->child(0);
-    info.classList.removeLast();
-    auto buttonBoxGadget = RenderThemeGadget::create(info, buttonGadget);
-    info.type = RenderThemeGadget::Type::Arrow;
-    info.name = "arrow";
-    info.classList = { };
-    auto arrowGadget = RenderThemeGadget::create(info, buttonBoxGadget.get());
+    auto& comboWidget = static_cast<RenderThemeComboBox&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::ComboBox));
+    auto comboState = themePartStateFlags(*this, ComboBoxButton, renderObject);
+    comboWidget.comboBox().setState(comboState);
+    comboWidget.button().setState(comboState);
+    comboWidget.arrow().setState(comboState);
 
     cairo_t* cr = paintInfo.context().platformContext()->cr();
-    comboGadget->render(cr, rect);
-    boxGadget->render(cr, rect);
+    comboWidget.comboBox().render(cr, rect);
+    comboWidget.box().render(cr, rect);
     FloatRect contentsRect;
-    buttonGadget->render(cr, rect, &contentsRect);
-    buttonBoxGadget->render(cr, contentsRect);
-    arrowGadget->render(cr, contentsRect);
+    comboWidget.button().render(cr, rect, &contentsRect);
+    comboWidget.buttonBox().render(cr, contentsRect);
+    comboWidget.arrow().render(cr, contentsRect);
     if (isFocused(renderObject))
-        buttonGadget->renderFocus(cr, rect);
+        comboWidget.button().renderFocus(cr, rect);
 
     return false;
@@ -987 +938 @@
 
     // Spinbuttons need a minimum height to be rendered correctly.
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Generic, "spinbutton", GTK_STATE_FLAG_NORMAL, { "horizontal" } };
-    auto spinbuttonGadget = RenderThemeGadget::create(info);
-    info.type = RenderThemeGadget::Type::TextField;
-    info.name = "entry";
-    info.classList.clear();
-    auto entryGadget = RenderThemeGadget::create(info, spinbuttonGadget.get());
-    info.type = RenderThemeGadget::Type::Icon;
-    info.name = "button";
-    info.classList.append("up");
-    auto buttonUpGadget = RenderThemeGadget::create(info, spinbuttonGadget.get());
-    static_cast<RenderThemeIconGadget*>(buttonUpGadget.get())->setIconSize(RenderThemeIconGadget::IconSizeGtk::Menu);
-    info.classList[0] = "down";
-    auto buttonDownGadget = RenderThemeGadget::create(info, spinbuttonGadget.get());
-    static_cast<RenderThemeIconGadget*>(buttonDownGadget.get())->setIconSize(RenderThemeIconGadget::IconSizeGtk::Menu);
-    IntSize preferredSize = spinbuttonGadget->preferredSize();
-    preferredSize = preferredSize.expandedTo(entryGadget->preferredSize());
-    IntSize upPreferredSize = preferredSize.expandedTo(buttonUpGadget->preferredSize());
-    IntSize downPreferredSize = preferredSize.expandedTo(buttonDownGadget->preferredSize());
+    auto& spinButtonWidget = static_cast<RenderThemeSpinButton&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::SpinButton));
+    spinButtonWidget.spinButton().setState(GTK_STATE_FLAG_NORMAL);
+    spinButtonWidget.entry().setState(GTK_STATE_FLAG_NORMAL);
+    spinButtonWidget.up().setState(GTK_STATE_FLAG_NORMAL);
+    spinButtonWidget.down().setState(GTK_STATE_FLAG_NORMAL);
+
+    IntSize preferredSize = spinButtonWidget.spinButton().preferredSize();
+    preferredSize = preferredSize.expandedTo(spinButtonWidget.entry().preferredSize());
+    IntSize upPreferredSize = preferredSize.expandedTo(spinButtonWidget.up().preferredSize());
+    IntSize downPreferredSize = preferredSize.expandedTo(spinButtonWidget.down().preferredSize());
     int height = std::max(upPreferredSize.height(), downPreferredSize.height());
     style.setMinHeight(Length(height, Fixed));
@@ -1011 +954 @@
 bool RenderThemeGtk::paintTextField(const RenderObject& renderObject, const PaintInfo& paintInfo, const FloatRect& rect)
 {
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::TextField, "entry", themePartStateFlags(*this, Entry, renderObject), { } };
-    std::unique_ptr<RenderThemeGadget> parentGadget;
     if (is<HTMLInputElement>(renderObject.node()) && shouldHaveSpinButton(downcast<HTMLInputElement>(*renderObject.node()))) {
-        info.name = "spinbutton";
-        info.classList.append("horizontal");
-        parentGadget = RenderThemeTextFieldGadget::create(info);
-        info.name = "entry";
-        info.classList.clear();
-    }
-
-    auto entryGadget = RenderThemeTextFieldGadget::create(info, parentGadget.get());
-    if (parentGadget)
-        parentGadget->render(paintInfo.context().platformContext()->cr(), rect);
-    entryGadget->render(paintInfo.context().platformContext()->cr(), rect);
+        auto& spinButtonWidget = static_cast<RenderThemeSpinButton&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::SpinButton));
+        auto spinButtonState = themePartStateFlags(*this, Entry, renderObject);
+        spinButtonWidget.spinButton().setState(spinButtonState);
+        spinButtonWidget.entry().setState(spinButtonState);
+        spinButtonWidget.spinButton().render(paintInfo.context().platformContext()->cr(), rect);
+        spinButtonWidget.entry().render(paintInfo.context().platformContext()->cr(), rect);
+    } else {
+        auto& entryWidget = static_cast<RenderThemeEntry&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::Entry));
+        entryWidget.entry().setState(themePartStateFlags(*this, Entry, renderObject));
+        entryWidget.entry().render(paintInfo.context().platformContext()->cr(), rect);
+    }
     return false;
 }
@@ -1066 +1007 @@
 {
     ASSERT(themePart == EntryIconLeft || themePart == EntryIconRight);
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::TextField, "entry", GTK_STATE_FLAG_NORMAL, { } };
-    auto parentGadget = RenderThemeGadget::create(info);
-    info.type = RenderThemeGadget::Type::Icon;
-    info.name = "image";
-    if (themePart == EntryIconLeft)
-        info.classList.append("left");
-    else
-        info.classList.append("right");
-    auto gadget = RenderThemeIconGadget::create(info, parentGadget.get());
+    auto& searchEntryWidget = static_cast<RenderThemeSearchEntry&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::SearchEntry));
+    searchEntryWidget.entry().setState(GTK_STATE_FLAG_NORMAL);
+    searchEntryWidget.leftIcon().setState(GTK_STATE_FLAG_NORMAL);
+    searchEntryWidget.rightIcon().setState(GTK_STATE_FLAG_NORMAL);
 
     // Get the icon size based on the font size.
-    static_cast<RenderThemeIconGadget*>(gadget.get())->setIconSize(style.fontSize());
-    IntSize preferredSize = gadget->preferredSize();
-    GtkBorder contentsBox = parentGadget->contentsBox();
+    auto& icon = static_cast<RenderThemeIconGadget&>(themePart == EntryIconLeft ? searchEntryWidget.leftIcon() : searchEntryWidget.rightIcon());
+    icon.setIconSize(style.fontSize());
+    IntSize preferredSize = icon.preferredSize();
+    GtkBorder contentsBox = searchEntryWidget.entry().contentsBox();
     if (themePart == EntryIconLeft)
         preferredSize.expand(contentsBox.left, contentsBox.top + contentsBox.bottom);
@@ -1166 +1103 @@
 {
     ASSERT(themePart == EntryIconLeft || themePart == EntryIconRight);
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::TextField, "entry", themePartStateFlags(*theme, Entry, renderObject), { } };
-    auto parentGadget = RenderThemeGadget::create(info);
-    info.type = RenderThemeGadget::Type::Icon;
-    info.state = themePartStateFlags(*theme, themePart, renderObject);
-    info.name = "image";
-    if (themePart == EntryIconLeft)
-        info.classList.append("left");
-    else
-        info.classList.append("right");
-    auto gadget = RenderThemeGadget::create(info, parentGadget.get());
-    auto* gadgetIcon = static_cast<RenderThemeIconGadget*>(gadget.get());
-    gadgetIcon->setIconSize(renderObject.style().fontSize());
-    if (themePart == EntryIconLeft)
-        gadgetIcon->setIconName("edit-find-symbolic");
-    else
-        gadgetIcon->setIconName("edit-clear-symbolic");
-    GtkBorder contentsBox = parentGadget->contentsBox();
+    auto& searchEntryWidget = static_cast<RenderThemeSearchEntry&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::SearchEntry));
+    searchEntryWidget.entry().setState(themePartStateFlags(*theme, Entry, renderObject));
+    auto& icon = static_cast<RenderThemeIconGadget&>(themePart == EntryIconLeft ? searchEntryWidget.leftIcon() : searchEntryWidget.rightIcon());
+    icon.setState(themePartStateFlags(*theme, themePart, renderObject));
+    icon.setIconSize(renderObject.style().fontSize());
+    GtkBorder contentsBox = searchEntryWidget.entry().contentsBox();
     IntRect iconRect = rect;
     if (themePart == EntryIconLeft) {
@@ -1189 +1115 @@
     } else
         iconRect.contract(contentsBox.right, contentsBox.top + contentsBox.bottom);
-    return !gadget->render(paintInfo.context().platformContext()->cr(), iconRect);
+    return !icon.render(paintInfo.context().platformContext()->cr(), iconRect);
 }
 bool RenderThemeGtk::paintSearchFieldResultsDecorationPart(const RenderBox& renderObject, const PaintInfo& paintInfo, const IntRect& rect)
@@ -1310 +1236 @@
     ASSERT(part == SliderHorizontalPart || part == SliderVerticalPart);
 
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Generic, "scale", themePartStateFlags(*this, Scale, renderObject), { } };
-    if (part == SliderHorizontalPart)
-        info.classList.append("horizontal");
-    else
-        info.classList.append("vertical");
-    auto scaleGadget = RenderThemeGadget::create(info);
-    info.name = "contents";
-    info.classList.clear();
-    auto contentsGadget = RenderThemeGadget::create(info, scaleGadget.get());
-    info.name = "trough";
-    auto troughGadget = RenderThemeGadget::create(info, contentsGadget.get());
-    info.name = "slider";
-    auto sliderGadget = RenderThemeGadget::create(info, troughGadget.get());
-    info.name = "highlight";
-    auto highlightGadget = RenderThemeGadget::create(info, troughGadget.get());
+    auto& sliderWidget = static_cast<RenderThemeSlider&>(RenderThemeWidget::getOrCreate(part == SliderHorizontalPart ? RenderThemeWidget::Type::HorizontalSlider : RenderThemeWidget::Type::VerticalSlider));
+    auto scaleState = themePartStateFlags(*this, Scale, renderObject);
+    auto& scale = sliderWidget.scale();
+    scale.setState(scaleState);
+    auto& contents = sliderWidget.contents();
+    auto& trough = sliderWidget.trough();
+    trough.setState(scaleState);
+    auto& slider = sliderWidget.slider();
+    auto& highlight = sliderWidget.highlight();
 
     // The given rectangle is not calculated based on the scale size, but all the margins and paddings are based on it.
-    IntSize preferredSize = scaleGadget->preferredSize();
-    preferredSize = preferredSize.expandedTo(contentsGadget->preferredSize());
-    preferredSize = preferredSize.expandedTo(troughGadget->preferredSize());
+    IntSize preferredSize = scale.preferredSize();
+    preferredSize = preferredSize.expandedTo(contents.preferredSize());
+    preferredSize = preferredSize.expandedTo(trough.preferredSize());
     FloatRect trackRect = rect;
     if (part == SliderHorizontalPart) {
@@ -1340 +1260 @@
 
     FloatRect contentsRect;
-    scaleGadget->render(paintInfo.context().platformContext()->cr(), trackRect, &contentsRect);
-    contentsGadget->render(paintInfo.context().platformContext()->cr(), contentsRect, &contentsRect);
+    scale.render(paintInfo.context().platformContext()->cr(), trackRect, &contentsRect);
+    contents.render(paintInfo.context().platformContext()->cr(), contentsRect, &contentsRect);
     // Scale trough defines its size querying slider and highlight.
     if (part == SliderHorizontalPart)
-        contentsRect.setHeight(troughGadget->preferredSize().height() + std::max(sliderGadget->preferredSize().height(), highlightGadget->preferredSize().height()));
+        contentsRect.setHeight(trough.preferredSize().height() + std::max(slider.preferredSize().height(), highlight.preferredSize().height()));
     else
-        contentsRect.setWidth(troughGadget->preferredSize().width() + std::max(sliderGadget->preferredSize().width(), highlightGadget->preferredSize().width()));
+        contentsRect.setWidth(trough.preferredSize().width() + std::max(slider.preferredSize().width(), highlight.preferredSize().width()));
     FloatRect troughRect = contentsRect;
-    troughGadget->render(paintInfo.context().platformContext()->cr(), troughRect, &contentsRect);
+    trough.render(paintInfo.context().platformContext()->cr(), troughRect, &contentsRect);
     if (isFocused(renderObject))
-        troughGadget->renderFocus(paintInfo.context().platformContext()->cr(), troughRect);
+        trough.renderFocus(paintInfo.context().platformContext()->cr(), troughRect);
 
     LayoutPoint thumbLocation;
@@ -1367 +1287 @@
     } else
         contentsRect.setHeight(thumbLocation.y());
-    highlightGadget->render(paintInfo.context().platformContext()->cr(), contentsRect);
+    highlight.render(paintInfo.context().platformContext()->cr(), contentsRect);
 
     return false;
@@ -1378 +1298 @@
         return;
 
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Generic, "scale", GTK_STATE_FLAG_NORMAL, { } };
-    if (part == SliderHorizontalPart)
-        info.classList.append("horizontal");
-    else
-        info.classList.append("vertical");
-    auto scaleGadget = RenderThemeGadget::create(info);
-    info.name = "contents";
-    info.classList.clear();
-    auto contentsGadget = RenderThemeGadget::create(info, scaleGadget.get());
-    info.name = "trough";
-    auto troughGadget = RenderThemeGadget::create(info, contentsGadget.get());
-    info.name = "slider";
-    auto sliderGadget = RenderThemeGadget::create(info, troughGadget.get());
-    info.name = "highlight";
-    auto highlightGadget = RenderThemeGadget::create(info, troughGadget.get());
-
-    IntSize preferredSize = scaleGadget->preferredSize();
-    preferredSize = preferredSize.expandedTo(contentsGadget->preferredSize());
-    preferredSize = preferredSize.expandedTo(troughGadget->preferredSize());
-    preferredSize = preferredSize.expandedTo(sliderGadget->preferredSize());
+    auto& sliderWidget = static_cast<RenderThemeSlider&>(RenderThemeWidget::getOrCreate(part == SliderHorizontalPart ? RenderThemeWidget::Type::HorizontalSlider : RenderThemeWidget::Type::VerticalSlider));
+    sliderWidget.scale().setState(GTK_STATE_FLAG_NORMAL);
+    sliderWidget.trough().setState(GTK_STATE_FLAG_NORMAL);
+
+    IntSize preferredSize = sliderWidget.scale().preferredSize();
+    preferredSize = preferredSize.expandedTo(sliderWidget.contents().preferredSize());
+    preferredSize = preferredSize.expandedTo(sliderWidget.trough().preferredSize());
+    preferredSize = preferredSize.expandedTo(sliderWidget.slider().preferredSize());
     if (part == SliderThumbHorizontalPart) {
         style.setWidth(Length(preferredSize.width(), Fixed));
@@ -1413 +1321 @@
     ASSERT(part == SliderThumbHorizontalPart || part == SliderThumbVerticalPart);
 
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Generic, "scale", themePartStateFlags(*this, Scale, renderObject), { } };
-    if (part == SliderHorizontalPart)
-        info.classList.append("horizontal");
-    else
-        info.classList.append("vertical");
-    auto scaleGadget = RenderThemeGadget::create(info);
-    info.name = "contents";
-    info.classList.clear();
-    auto contentsGadget = RenderThemeGadget::create(info, scaleGadget.get());
-    info.name = "trough";
-    auto troughGadget = RenderThemeGadget::create(info, contentsGadget.get());
-    info.name = "slider";
-    info.state = themePartStateFlags(*this, ScaleSlider, renderObject);
-    auto sliderGadget = RenderThemeGadget::create(info, troughGadget.get());
-    info.name = "highlight";
-    auto highlightGadget = RenderThemeGadget::create(info, troughGadget.get());
-
-    GtkBorder scaleContentsBox = scaleGadget->contentsBox();
-    GtkBorder contentsContentsBox = contentsGadget->contentsBox();
-    GtkBorder troughContentsBox = troughGadget->contentsBox();
+    auto& sliderWidget = static_cast<RenderThemeSlider&>(RenderThemeWidget::getOrCreate(part == SliderThumbHorizontalPart ? RenderThemeWidget::Type::HorizontalSlider : RenderThemeWidget::Type::VerticalSlider));
+    auto scaleState = themePartStateFlags(*this, Scale, renderObject);
+    auto& scale = sliderWidget.scale();
+    scale.setState(scaleState);
+    auto& contents = sliderWidget.contents();
+    auto& trough = sliderWidget.trough();
+    trough.setState(scaleState);
+    auto& slider = sliderWidget.slider();
+    slider.setState(themePartStateFlags(*this, ScaleSlider, renderObject));
+    auto& highlight = sliderWidget.highlight();
+
+    GtkBorder scaleContentsBox = scale.contentsBox();
+    GtkBorder contentsContentsBox = contents.contentsBox();
+    GtkBorder troughContentsBox = trough.contentsBox();
     GtkBorder padding;
     padding.left = scaleContentsBox.left + contentsContentsBox.left + troughContentsBox.left;
@@ -1440 +1342 @@
 
     // Scale trough defines its size querying slider and highlight.
-    int troughHeight = troughGadget->preferredSize().height() + std::max(sliderGadget->preferredSize().height(), highlightGadget->preferredSize().height());
+    int troughHeight = trough.preferredSize().height() + std::max(slider.preferredSize().height(), highlight.preferredSize().height());
     IntRect sliderRect(rect.location(), IntSize(troughHeight, troughHeight));
     sliderRect.move(padding.left, padding.top);
     sliderRect.contract(padding.left + padding.right, padding.top + padding.bottom);
-    sliderGadget->render(paintInfo.context().platformContext()->cr(), sliderRect);
+    slider.render(paintInfo.context().platformContext()->cr(), sliderRect);
     return false;
 }
@@ -1541 +1443 @@
 IntRect RenderThemeGtk::progressBarRectForBounds(const RenderObject& renderObject, const IntRect& bounds) const
 {
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Generic, "progressbar", GTK_STATE_FLAG_NORMAL, { "horizontal" } };
-    auto progressBarGadget = RenderThemeGadget::create(info);
-    info.name = "trough";
-    info.classList.clear();
-    auto troughGadget = RenderThemeGadget::create(info, progressBarGadget.get());
-    info.name = "progress";
-    if (renderObject.style().direction() == RTL)
-        info.classList.append("right");
-    else
-        info.classList.append("left");
     const auto& renderProgress = downcast<RenderProgress>(renderObject);
-    if (renderProgress.isDeterminate())
-        info.classList.append("pulse");
-    auto progressGadget = RenderThemeGadget::create(info, troughGadget.get());
-    IntSize preferredSize = progressBarGadget->preferredSize();
-    preferredSize = preferredSize.expandedTo(troughGadget->preferredSize());
-    preferredSize = preferredSize.expandedTo(progressGadget->preferredSize());
+    auto& progressBarWidget = static_cast<RenderThemeProgressBar&>(RenderThemeWidget::getOrCreate(renderProgress.isDeterminate() ? RenderThemeProgressBar::Type::ProgressBar : RenderThemeProgressBar::Type::IndeterminateProgressBar));
+    IntSize preferredSize = progressBarWidget.progressBar().preferredSize();
+    preferredSize = preferredSize.expandedTo(progressBarWidget.trough().preferredSize());
+    preferredSize = preferredSize.expandedTo(progressBarWidget.progress().preferredSize());
     return IntRect(bounds.x(), bounds.y(), bounds.width(), preferredSize.height());
 }
@@ -1566 +1456 @@
         return true;
 
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Generic, "progressbar", GTK_STATE_FLAG_NORMAL, { "horizontal" } };
-    auto progressBarGadget = RenderThemeGadget::create(info);
-    info.name = "trough";
-    info.classList.clear();
-    auto troughGadget = RenderThemeGadget::create(info, progressBarGadget.get());
-    info.name = "progress";
-    if (renderObject.style().direction() == RTL)
-        info.classList.append("right");
-    else
-        info.classList.append("left");
     const auto& renderProgress = downcast<RenderProgress>(renderObject);
-    if (renderProgress.isDeterminate())
-        info.classList.append("pulse");
-    auto progressGadget = RenderThemeGadget::create(info, troughGadget.get());
-
-    progressBarGadget->render(paintInfo.context().platformContext()->cr(), rect);
-    troughGadget->render(paintInfo.context().platformContext()->cr(), rect);
-    progressGadget->render(paintInfo.context().platformContext()->cr(), calculateProgressRect(renderObject, rect));
+    auto& progressBarWidget = static_cast<RenderThemeProgressBar&>(RenderThemeWidget::getOrCreate(renderProgress.isDeterminate() ? RenderThemeProgressBar::Type::ProgressBar : RenderThemeProgressBar::Type::IndeterminateProgressBar));
+    progressBarWidget.progressBar().render(paintInfo.context().platformContext()->cr(), rect);
+    progressBarWidget.trough().render(paintInfo.context().platformContext()->cr(), rect);
+    progressBarWidget.progress().render(paintInfo.context().platformContext()->cr(), calculateProgressRect(renderObject, rect));
     return false;
 }
@@ -1636 +1513 @@
 void RenderThemeGtk::adjustInnerSpinButtonStyle(StyleResolver&, RenderStyle& style, const Element*) const
 {
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Generic, "spinbutton", GTK_STATE_FLAG_NORMAL, { "horizontal" } };
-    auto spinbuttonGadget = RenderThemeGadget::create(info);
-    info.type = RenderThemeGadget::Type::TextField;
-    info.name = "entry";
-    info.classList.clear();
-    auto entryGadget = RenderThemeGadget::create(info, spinbuttonGadget.get());
-    info.type = RenderThemeGadget::Type::Icon;
-    info.name = "button";
-    info.classList.append("up");
-    auto buttonUpGadget = RenderThemeGadget::create(info, spinbuttonGadget.get());
-    static_cast<RenderThemeIconGadget*>(buttonUpGadget.get())->setIconSize(RenderThemeIconGadget::IconSizeGtk::Menu);
-    info.classList[0] = "down";
-    auto buttonDownGadget = RenderThemeGadget::create(info, spinbuttonGadget.get());
-    static_cast<RenderThemeIconGadget*>(buttonDownGadget.get())->setIconSize(RenderThemeIconGadget::IconSizeGtk::Menu);
-    IntSize upPreferredSize = buttonUpGadget->preferredSize();
-    IntSize downPreferredSize = buttonDownGadget->preferredSize();
+    auto& spinButtonWidget = static_cast<RenderThemeSpinButton&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::SpinButton));
+    spinButtonWidget.spinButton().setState(GTK_STATE_FLAG_NORMAL);
+    spinButtonWidget.entry().setState(GTK_STATE_FLAG_NORMAL);
+    spinButtonWidget.up().setState(GTK_STATE_FLAG_NORMAL);
+    spinButtonWidget.down().setState(GTK_STATE_FLAG_NORMAL);
+
+    IntSize upPreferredSize = spinButtonWidget.up().preferredSize();
+    IntSize downPreferredSize = spinButtonWidget.down().preferredSize();
     int buttonSize = std::max(std::max(upPreferredSize.width(), downPreferredSize.width()), std::max(upPreferredSize.height(), downPreferredSize.height()));
     style.setWidth(Length(buttonSize * 2, Fixed));
@@ -1659 +1528 @@
 bool RenderThemeGtk::paintInnerSpinButton(const RenderObject& renderObject, const PaintInfo& paintInfo, const IntRect& rect)
 {
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Generic, "spinbutton", themePartStateFlags(*this, SpinButton, renderObject), { } };
-    auto spinbuttonGadget = RenderThemeGadget::create(info);
-    info.type = RenderThemeGadget::Type::TextField;
-    info.name = "entry";
-    info.classList.clear();
-    auto entryGadget = RenderThemeGadget::create(info, spinbuttonGadget.get());
-    info.type = RenderThemeGadget::Type::Icon;
-    info.name = "button";
-    info.classList.append("up");
-    info.state = themePartStateFlags(*this, SpinButtonUpButton, renderObject);
-    auto buttonUpGadget = RenderThemeGadget::create(info, spinbuttonGadget.get());
-    auto* gadgetIcon = static_cast<RenderThemeIconGadget*>(buttonUpGadget.get());
-    gadgetIcon->setIconSize(RenderThemeIconGadget::IconSizeGtk::Menu);
-    gadgetIcon->setIconName("list-add-symbolic");
-    info.classList[0] = "down";
-    info.state = themePartStateFlags(*this, SpinButtonDownButton, renderObject);
-    auto buttonDownGadget = RenderThemeGadget::create(info, spinbuttonGadget.get());
-    gadgetIcon = static_cast<RenderThemeIconGadget*>(buttonDownGadget.get());
-    gadgetIcon->setIconSize(RenderThemeIconGadget::IconSizeGtk::Menu);
-    gadgetIcon->setIconName("list-remove-symbolic");
+    auto& spinButtonWidget = static_cast<RenderThemeSpinButton&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::SpinButton));
+    auto spinButtonState = themePartStateFlags(*this, SpinButton, renderObject);
+    spinButtonWidget.spinButton().setState(spinButtonState);
+    spinButtonWidget.entry().setState(spinButtonState);
+    auto& up = spinButtonWidget.up();
+    up.setState(themePartStateFlags(*this, SpinButtonUpButton, renderObject));
+    auto& down = spinButtonWidget.down();
+    down.setState(themePartStateFlags(*this, SpinButtonDownButton, renderObject));
 
     IntRect iconRect = rect;
     iconRect.setWidth(iconRect.width() / 2);
     if (renderObject.style().direction() == RTL)
-        buttonUpGadget->render(paintInfo.context().platformContext()->cr(), iconRect);
+        up.render(paintInfo.context().platformContext()->cr(), iconRect);
     else
-        buttonDownGadget->render(paintInfo.context().platformContext()->cr(), iconRect);
+        down.render(paintInfo.context().platformContext()->cr(), iconRect);
     iconRect.move(iconRect.width(), 0);
     if (renderObject.style().direction() == RTL)
-        buttonDownGadget->render(paintInfo.context().platformContext()->cr(), iconRect);
+        down.render(paintInfo.context().platformContext()->cr(), iconRect);
     else
-        buttonUpGadget->render(paintInfo.context().platformContext()->cr(), iconRect);
+        up.render(paintInfo.context().platformContext()->cr(), iconRect);
 
     return false;
@@ -1823 +1680 @@
 static Color styleColor(RenderThemePart themePart, GtkStateFlags state, StyleColorType colorType)
 {
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Generic, nullptr, state, { } };
-    std::unique_ptr<RenderThemeGadget> parentGadget;
-    RenderThemePart part = themePart;
-    if (themePart == Entry && (state & GTK_STATE_FLAG_SELECTED)) {
-        info.name = "entry";
-        parentGadget = RenderThemeGadget::create(info);
-        part = EntrySelection;
-    }
-
-    switch (part) {
-    case Entry:
-        info.name = "entry";
-        break;
-    case EntrySelection:
-        info.name = "selection";
-        break;
-    case ListBox:
-        info.name = "treeview";
-        info.classList.append("view");
-        break;
-    case Button:
-        info.name = "button";
-        break;
+    RenderThemeGadget* gadget = nullptr;
+    switch (themePart) {
     default:
         ASSERT_NOT_REACHED();
-        info.name = "entry";
-    }
-
-    auto gadget = RenderThemeGadget::create(info, parentGadget.get());
+        FALLTHROUGH;
+    case Entry:
+        gadget = &static_cast<RenderThemeEntry&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::Entry)).entry();
+        break;
+    case EntrySelection:
+        gadget = static_cast<RenderThemeEntry&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::SelectedEntry)).selection();
+        break;
+    case ListBox:
+        gadget = &static_cast<RenderThemeListView&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::ListView)).treeview();
+        break;
+    case Button:
+        gadget = &static_cast<RenderThemeButton&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::Button)).button();
+        break;
+    }
+
+    ASSERT(gadget);
+    gadget->setState(state);
     return colorType == StyleColorBackground ? gadget->backgroundColor() : gadget->color();
 }
@@ -1871 +1720 @@
 Color RenderThemeGtk::platformActiveSelectionBackgroundColor() const
 {
-    return styleColor(Entry, static_cast<GtkStateFlags>(GTK_STATE_FLAG_SELECTED | GTK_STATE_FLAG_FOCUSED), StyleColorBackground);
+    return styleColor(EntrySelection, static_cast<GtkStateFlags>(GTK_STATE_FLAG_SELECTED | GTK_STATE_FLAG_FOCUSED), StyleColorBackground);
 }
 
 Color RenderThemeGtk::platformInactiveSelectionBackgroundColor() const
 {
-    return styleColor(Entry, GTK_STATE_FLAG_SELECTED, StyleColorBackground);
+    return styleColor(EntrySelection, GTK_STATE_FLAG_SELECTED, StyleColorBackground);
 }
 
 Color RenderThemeGtk::platformActiveSelectionForegroundColor() const
 {
-    return styleColor(Entry, static_cast<GtkStateFlags>(GTK_STATE_FLAG_SELECTED | GTK_STATE_FLAG_FOCUSED), StyleColorForeground);
+    return styleColor(EntrySelection, static_cast<GtkStateFlags>(GTK_STATE_FLAG_SELECTED | GTK_STATE_FLAG_FOCUSED), StyleColorForeground);
 }
 
 Color RenderThemeGtk::platformInactiveSelectionForegroundColor() const
 {
-    return styleColor(Entry, GTK_STATE_FLAG_SELECTED, StyleColorForeground);
+    return styleColor(EntrySelection, GTK_STATE_FLAG_SELECTED, StyleColorForeground);
 }
 
@@ -1942 +1791 @@
 bool RenderThemeGtk::paintMediaButton(const RenderObject& renderObject, GraphicsContext& graphicsContext, const IntRect& rect, const char* iconName)
 {
-    RenderThemeGadget::Info info = { RenderThemeGadget::Type::Icon, "image", themePartStateFlags(*this, MediaButton, renderObject), { } };
-    auto gadget = RenderThemeGadget::create(info);
-    auto* gadgetIcon = static_cast<RenderThemeIconGadget*>(gadget.get());
-    gadgetIcon->setIconSize(RenderThemeIconGadget::IconSizeGtk::Menu);
-    gadgetIcon->setIconName(iconName);
-    return !gadget->render(graphicsContext.platformContext()->cr(), rect);
+    auto& iconWidget = static_cast<RenderThemeIcon&>(RenderThemeWidget::getOrCreate(RenderThemeWidget::Type::Icon));
+    auto& icon = static_cast<RenderThemeIconGadget&>(iconWidget.icon());
+    icon.setState(themePartStateFlags(*this, MediaButton, renderObject));
+    icon.setIconSize(RenderThemeIconGadget::IconSizeGtk::Menu);
+    icon.setIconName(iconName);
+    return !icon.render(graphicsContext.platformContext()->cr(), rect);
 }
 #else