diff --git a/src/server/shell/decoration/basic_decoration.cpp b/src/server/shell/decoration/basic_decoration.cpp
index bf4d74a7e3..fb48634862 100644
--- a/src/server/shell/decoration/basic_decoration.cpp
+++ b/src/server/shell/decoration/basic_decoration.cpp
@@ -56,6 +56,15 @@ struct PropertyComparison
     {
     }
 
+    template<typename TYPE>
+    PropertyComparison(TYPE (OBJ::*member))
+        : comp{[=](OBJ const* a, OBJ const* b)
+        {
+            return (a->*member) == (b->*member);
+        }}
+    {
+    }
+
     auto operator()(OBJ const* a, OBJ const* b) const -> bool
     {
         return comp(a, b);
@@ -138,16 +147,15 @@ msd::BasicDecoration::BasicDecoration(
     std::shared_ptr<DecorationStrategy> decoration_strategy)
     : threadsafe_self{std::make_shared<ThreadsafeAccess<BasicDecoration>>(executor)},
       decoration_strategy{decoration_strategy},
-      static_geometry{decoration_strategy->static_geometry()},
       shell{shell},
       buffer_allocator{buffer_allocator},
       cursor_images{cursor_images},
       session{window_surface->session().lock()},
-      buffer_streams{std::make_unique<BufferStreams>(session, static_geometry->buffer_format)},
+      buffer_streams{std::make_unique<BufferStreams>(session, decoration_strategy->buffer_format())},
       renderer{std::make_unique<Renderer>(buffer_allocator, decoration_strategy->render_strategy())},
       window_surface{window_surface},
       decoration_surface{create_surface()},
-      window_state{new_window_state()},
+      window_state{decoration_strategy->new_window_state(window_surface, scale)},
       window_surface_observer_manager{std::make_unique<WindowSurfaceObserverManager>(
           window_surface,
           threadsafe_self)},
@@ -193,7 +201,7 @@ msd::BasicDecoration::~BasicDecoration()
 void msd::BasicDecoration::window_state_updated()
 {
     auto previous_window_state = std::move(window_state);
-    window_state = new_window_state();
+    window_state = decoration_strategy->new_window_state(window_surface, scale);
 
     input_manager->update_window_state(*window_state);
 
@@ -259,11 +267,6 @@ void msd::BasicDecoration::set_scale(float new_scale)
     window_state_updated();
 }
 
-auto msd::BasicDecoration::new_window_state() const -> std::unique_ptr<WindowState>
-{
-    return std::make_unique<WindowState>(static_geometry, window_surface, scale);
-}
-
 auto msd::BasicDecoration::create_surface() const -> std::shared_ptr<scene::Surface>
 {
     msh::SurfaceSpecification params;
@@ -280,7 +283,7 @@ auto msd::BasicDecoration::create_surface() const -> std::shared_ptr<scene::Surf
     params.streams = {{
         session->create_buffer_stream(mg::BufferProperties{
             geom::Size{1, 1},
-            static_geometry->buffer_format,
+            decoration_strategy->buffer_format(),
             mg::BufferUsage::software}),
         {},
         }};
@@ -318,7 +321,7 @@ void msd::BasicDecoration::update(
     if (input_updated({
             &InputState::input_shape}))
     {
-        spec.input_shape = input_state->input_shape();
+        spec.input_shape = input_state->input_shape;
     }
 
     if (window_updated({
diff --git a/src/server/shell/decoration/basic_decoration.h b/src/server/shell/decoration/basic_decoration.h
index fb4bc0dbc6..097b3d1447 100644
--- a/src/server/shell/decoration/basic_decoration.h
+++ b/src/server/shell/decoration/basic_decoration.h
@@ -57,7 +57,6 @@ class StreamSpecification;
 namespace decoration
 {
 template<typename T> class ThreadsafeAccess;
-class StaticGeometry;
 class WindowState;
 class WindowSurfaceObserverManager;
 class InputManager;
@@ -90,9 +89,6 @@ class BasicDecoration
     void set_scale(float scale) override;
 
 protected:
-    /// Creates an up-to-date WindowState object
-    auto new_window_state() const -> std::unique_ptr<WindowState>;
-
     /// Returns paramaters to create the decoration surface
     auto create_surface() const -> std::shared_ptr<scene::Surface>;
 
@@ -106,7 +102,6 @@ class BasicDecoration
 
     std::shared_ptr<ThreadsafeAccess<BasicDecoration>> const threadsafe_self;
     std::shared_ptr<DecorationStrategy> const decoration_strategy;
-    std::shared_ptr<StaticGeometry> const static_geometry;
 
     std::shared_ptr<shell::Shell> const shell;
     std::shared_ptr<graphics::GraphicBufferAllocator> const buffer_allocator;
diff --git a/src/server/shell/decoration/basic_manager.cpp b/src/server/shell/decoration/basic_manager.cpp
index 43ab25f068..4657648f33 100644
--- a/src/server/shell/decoration/basic_manager.cpp
+++ b/src/server/shell/decoration/basic_manager.cpp
@@ -136,22 +136,7 @@ using mir::geometry::Size;
 auto msd::BasicManager::compute_size_with_decorations(Size content_size,
     MirWindowType type, MirWindowState state) -> Size
 {
-    auto const geometry = decoration_strategy->static_geometry();
-
-    switch (border_type_for(type, state))
-    {
-    case msd::BorderType::Full:
-        content_size.width += geometry->side_border_width * 2;
-        content_size.height += geometry->titlebar_height + geometry->bottom_border_height;
-        break;
-    case msd::BorderType::Titlebar:
-        content_size.height += geometry->titlebar_height;
-        break;
-    case msd::BorderType::None:
-        break;
-    }
-
-    return content_size;
+    return decoration_strategy->compute_size_with_decorations(content_size, type, state);
 }
 
 void msd::BasicManager::set_scale(float new_scale)
diff --git a/src/server/shell/decoration/decoration_strategy.cpp b/src/server/shell/decoration/decoration_strategy.cpp
index b025233a19..9faca93461 100644
--- a/src/server/shell/decoration/decoration_strategy.cpp
+++ b/src/server/shell/decoration/decoration_strategy.cpp
@@ -37,13 +37,30 @@ namespace geom = mir::geometry;
 namespace msh = mir::shell;
 namespace msd = mir::shell::decoration;
 
-using msd::StaticGeometry;
 using msd::WindowState;
-using msd::Pixel;
 using msd::InputState;
 
 namespace
 {
+/// Decoration geometry properties that don't change
+struct StaticGeometry
+{
+    geom::Height const titlebar_height;           ///< Visible height of the top titlebar with the window's name and buttons
+    geom::Width const side_border_width;          ///< Visible width of the side borders
+    geom::Height const bottom_border_height;      ///< Visible height of the bottom border
+    geom::Size const resize_corner_input_size;    ///< The size of the input area of a resizable corner
+    ///< (does not effect surface input area, only where in the surface is
+    ///< considered a resize corner)
+    geom::Width const button_width;               ///< The width of window control buttons
+    geom::Width const padding_between_buttons;    ///< The gep between titlebar buttons
+    geom::Height const title_font_height;         ///< Height of the text used to render the window title
+    geom::Point const title_font_top_left;        ///< Where to render the window title
+    geom::Displacement const icon_padding;        ///< Padding inside buttons around icons
+    geom::Width const icon_line_width;            ///< Width for lines in button icons
+
+    MirPixelFormat const buffer_format = mir_pixel_format_argb_8888;
+};
+
 static constexpr auto color(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 0xFF) -> uint32_t
 {
 #if __BYTE_ORDER == __LITTLE_ENDIAN
@@ -213,12 +230,14 @@ struct RendererStrategy : public msd::RendererStrategy
     RendererStrategy(std::shared_ptr<StaticGeometry> const& static_geometry);
 
     void update_state(WindowState const& window_state, InputState const& input_state) override;
-    auto render_titlebar() -> std::optional<RenderedPixels> override;
-    auto render_left_border() -> std::optional<RenderedPixels> override;
-    auto render_right_border() -> std::optional<RenderedPixels> override;
-    auto render_bottom_border() -> std::optional<RenderedPixels> override;
+    auto render_titlebar(msd::BufferMaker const* buffer_maker) -> std::optional<std::shared_ptr<mir::graphics::Buffer>> override;
+    auto render_left_border(msd::BufferMaker const* buffer_maker) -> std::optional<std::shared_ptr<mir::graphics::Buffer>> override;
+    auto render_right_border(msd::BufferMaker const* buffer_maker) -> std::optional<std::shared_ptr<mir::graphics::Buffer>> override;
+    auto render_bottom_border(msd::BufferMaker const* buffer_maker) -> std::optional<std::shared_ptr<mir::graphics::Buffer>> override;
 
 private:
+    using Pixel = msd::BufferMaker::Pixel;
+
     std::shared_ptr<StaticGeometry> const static_geometry;
 
     /// A visual theme for a decoration
@@ -269,7 +288,7 @@ struct RendererStrategy : public msd::RendererStrategy
             geom::Width line_width,
             Pixel color)> const render_icon; ///< Draws button's icon to the given buffer
     };
-    std::map<msd::ButtonFunction, Icon const> button_icons;
+    std::map<msd::Button::Function, Icon const> button_icons;
 
     float scale{1.0f};
     std::string name;
@@ -289,7 +308,7 @@ struct RendererStrategy : public msd::RendererStrategy
     bool needs_titlebar_redraw{true};
     bool needs_titlebar_buttons_redraw{true};
 
-    std::vector<msd::ButtonInfo> buttons;
+    std::vector<msd::Button> buttons;
 
     void update_solid_color_pixels();
 
@@ -298,15 +317,74 @@ struct RendererStrategy : public msd::RendererStrategy
     void redraw_titlebar_background(geom::Size scaled_titlebar_size);
     void redraw_titlebar_text(geom::Size scaled_titlebar_size);
     void redraw_titlebar_buttons(geom::Size scaled_titlebar_size);
+
+    static auto alloc_pixels(geom::Size size) -> std::unique_ptr<Pixel[]>;
 };
 
 class DecorationStrategy : public msd::DecorationStrategy
 {
 public:
-    auto static_geometry() const -> std::shared_ptr<StaticGeometry> override;
+    ~DecorationStrategy() override = default;
+
+    auto static_geometry() const -> std::shared_ptr<StaticGeometry>;
     auto render_strategy() const -> std::unique_ptr<mir::shell::decoration::RendererStrategy> override;
-    auto button_placement(unsigned n, const WindowState& ws) const -> mir::geometry::Rectangle override;
+    auto button_placement(unsigned n, const WindowState& ws) const -> geom::Rectangle override;
+    auto compute_size_with_decorations(geom::Size content_size, MirWindowType type, MirWindowState state) const
+        -> geom::Size override;
+    auto buffer_format() const -> MirPixelFormat override;
+    auto new_window_state(const std::shared_ptr<mir::scene::Surface>& window_surface,
+                          float scale) const -> std::unique_ptr<WindowState> override;
+    auto resize_corner_input_size() const -> geom::Size override;
 };
+
+auto DecorationStrategy::resize_corner_input_size() const -> geom::Size
+{
+    return static_geometry()->resize_corner_input_size;
+}
+
+auto DecorationStrategy::buffer_format() const -> MirPixelFormat
+{
+    return static_geometry()->buffer_format;
+}
+
+auto DecorationStrategy::new_window_state(const std::shared_ptr<mir::scene::Surface>& window_surface,
+                                          float scale) const -> std::unique_ptr<WindowState>
+
+{
+    return std::make_unique<WindowState>(
+        window_surface,
+        static_geometry()->titlebar_height,
+        static_geometry()->side_border_width,
+        static_geometry()->bottom_border_height,
+        scale);
+}
+
+auto DecorationStrategy::compute_size_with_decorations(
+    geom::Size content_size, MirWindowType type, MirWindowState state) const -> geom::Size
+{
+    switch (msd::border_type_for(type, state))
+    {
+    case msd::BorderType::Full:
+        content_size.width += static_geometry()->side_border_width * 2;
+        content_size.height += static_geometry()->titlebar_height + static_geometry()->bottom_border_height;
+        break;
+    case msd::BorderType::Titlebar:
+        content_size.height += static_geometry()->titlebar_height;
+        break;
+    case msd::BorderType::None:
+        break;
+    }
+
+    return content_size;
+}
+
+auto RendererStrategy::alloc_pixels(geom::Size size) -> std::unique_ptr<Pixel[]>
+{
+    if (size_t const buf_size = area(size) * sizeof(Pixel))
+        return std::unique_ptr<Pixel[]>{new Pixel[buf_size]};
+    else
+        return {};
+}
 }
 
 auto msd::border_type_for(MirWindowType type, MirWindowState state) -> msd::BorderType
@@ -354,9 +432,9 @@ auto msd::border_type_for(MirWindowType type, MirWindowState state) -> msd::Bord
     return {};
 }
 
-auto msd::DecorationStrategy::default_decoration_strategy() -> std::unique_ptr<DecorationStrategy>
+auto msd::DecorationStrategy::default_decoration_strategy() -> std::shared_ptr<DecorationStrategy>
 {
-    return std::make_unique<::DecorationStrategy>();
+    return std::make_shared<::DecorationStrategy>();
 }
 
 class RendererStrategy::Text::Impl
@@ -637,17 +715,17 @@ RendererStrategy::RendererStrategy(std::shared_ptr<StaticGeometry> const& static
     current_theme{nullptr},
     text{Text::instance()},
     button_icons{
-        {msd::ButtonFunction::Close, {
+        {msd::Button::Close, {
             default_close_normal_button,
             default_close_active_button,
             default_button_icon,
             render_close_icon}},
-        {msd::ButtonFunction::Maximize, {
+        {msd::Button::Maximize, {
             default_normal_button,
             default_active_button,
             default_button_icon,
             render_maximize_icon}},
-        {msd::ButtonFunction::Minimize, {
+        {msd::Button::Minimize, {
             default_normal_button,
             default_active_button,
             default_button_icon,
@@ -704,11 +782,11 @@ void RendererStrategy::update_state(WindowState const& window_state, InputState
         needs_titlebar_redraw = true;
     }
 
-    if (input_state.buttons() != buttons)
+    if (input_state.buttons != buttons)
     {
         // If the number of buttons or their location changed, redraw the whole titlebar
         // Otherwise if the buttons are in the same place, just redraw them
-        if (input_state.buttons().size() != buttons.size())
+        if (input_state.buttons.size() != buttons.size())
         {
             needs_titlebar_redraw = true;
         }
@@ -716,16 +794,16 @@ void RendererStrategy::update_state(WindowState const& window_state, InputState
         {
             for (unsigned i = 0; i < buttons.size(); i++)
             {
-                if (input_state.buttons()[i].rect != buttons[i].rect)
+                if (input_state.buttons[i].rect != buttons[i].rect)
                     needs_titlebar_redraw = true;
             }
         }
-        buttons = input_state.buttons();
+        buttons = input_state.buttons;
         needs_titlebar_buttons_redraw = true;
     }
 }
 
-auto RendererStrategy::render_titlebar() -> std::optional<RenderedPixels>
+auto RendererStrategy::render_titlebar(msd::BufferMaker const* maker) -> std::optional<std::shared_ptr<mir::graphics::Buffer>>
 {
     auto const scaled_titlebar_size{titlebar_size * scale};
 
@@ -753,34 +831,34 @@ auto RendererStrategy::render_titlebar() -> std::optional<RenderedPixels>
     needs_titlebar_redraw = false;
     needs_titlebar_buttons_redraw = false;
 
-    return RenderedPixels{static_geometry->buffer_format, scaled_titlebar_size, titlebar_pixels.get()};
+    return maker->make_buffer(static_geometry->buffer_format, scaled_titlebar_size, titlebar_pixels.get());
 }
 
-auto RendererStrategy::render_left_border() -> std::optional<RenderedPixels>
+auto RendererStrategy::render_left_border(msd::BufferMaker const* maker) -> std::optional<std::shared_ptr<mir::graphics::Buffer>>
 {
     auto const scaled_left_border_size{left_border_size * scale};
     if (!area(scaled_left_border_size))
         return std::nullopt;
     update_solid_color_pixels();
-    return RenderedPixels{static_geometry->buffer_format, scaled_left_border_size, solid_color_pixels.get()};
+    return maker->make_buffer(static_geometry->buffer_format, scaled_left_border_size, solid_color_pixels.get());
 }
 
-auto RendererStrategy::render_right_border() -> std::optional<RenderedPixels>
+auto RendererStrategy::render_right_border(msd::BufferMaker const* maker) -> std::optional<std::shared_ptr<mir::graphics::Buffer>>
 {
     auto const scaled_right_border_size{right_border_size * scale};
     if (!area(scaled_right_border_size))
         return std::nullopt;
     update_solid_color_pixels();
-    return RenderedPixels{static_geometry->buffer_format, scaled_right_border_size, solid_color_pixels.get()};
+    return maker->make_buffer(static_geometry->buffer_format, scaled_right_border_size, solid_color_pixels.get());
 }
 
-auto RendererStrategy::render_bottom_border() -> std::optional<RenderedPixels>
+auto RendererStrategy::render_bottom_border(msd::BufferMaker const* maker) -> std::optional<std::shared_ptr<mir::graphics::Buffer>>
 {
     auto const scaled_bottom_border_size{bottom_border_size * scale};
     if (!area(scaled_bottom_border_size))
         return std::nullopt;
     update_solid_color_pixels();
-    return RenderedPixels{static_geometry->buffer_format, scaled_bottom_border_size, solid_color_pixels.get()};
+    return maker->make_buffer(static_geometry->buffer_format, scaled_bottom_border_size, solid_color_pixels.get());
 }
 
 void RendererStrategy::update_solid_color_pixels()
@@ -839,7 +917,7 @@ void RendererStrategy::redraw_titlebar_buttons(geom::Size const scaled_titlebar_
         if (icon != button_icons.end())
         {
             Pixel button_color = icon->second.normal_color;
-            if (button.state == msd::ButtonState::Hovered)
+            if (button.state == msd::Button::Hovered)
                 button_color = icon->second.active_color;
             for (geom::Y y{scaled_button_rect.top()}; y < scaled_button_rect.bottom(); y += geom::DeltaY{1})
             {
@@ -906,7 +984,7 @@ auto DecorationStrategy::render_strategy() const -> std::unique_ptr<mir::shell::
     return std::make_unique<::RendererStrategy>(static_geometry());
 }
 
-auto DecorationStrategy::button_placement(unsigned n, const WindowState& ws) const -> mir::geometry::Rectangle
+auto DecorationStrategy::button_placement(unsigned n, const WindowState& ws) const -> geom::Rectangle
 {
     auto const titlebar = ws.titlebar_rect();
     auto const geometry = static_geometry();
diff --git a/src/server/shell/decoration/decoration_strategy.h b/src/server/shell/decoration/decoration_strategy.h
index 98fd260651..903ec8ada0 100644
--- a/src/server/shell/decoration/decoration_strategy.h
+++ b/src/server/shell/decoration/decoration_strategy.h
@@ -28,44 +28,10 @@
 #include <vector>
 
 namespace mir::scene { class Surface; }
+namespace mir::graphics { class Buffer; }
 
 namespace mir::shell::decoration
 {
-using Pixel = uint32_t;
-
-/// Decoration geometry properties that don't change
-struct StaticGeometry
-{
-    geometry::Height const titlebar_height;           ///< Visible height of the top titlebar with the window's name and buttons
-    geometry::Width const side_border_width;          ///< Visible width of the side borders
-    geometry::Height const bottom_border_height;      ///< Visible height of the bottom border
-    geometry::Size const resize_corner_input_size;    ///< The size of the input area of a resizable corner
-    ///< (does not effect surface input area, only where in the surface is
-    ///< considered a resize corner)
-    geometry::Width const button_width;               ///< The width of window control buttons
-    geometry::Width const padding_between_buttons;    ///< The gep between titlebar buttons
-    geometry::Height const title_font_height;         ///< Height of the text used to render the window title
-    geometry::Point const title_font_top_left;        ///< Where to render the window title
-    geometry::Displacement const icon_padding;        ///< Padding inside buttons around icons
-    geometry::Width const icon_line_width;            ///< Width for lines in button icons
-
-    MirPixelFormat const buffer_format = mir_pixel_format_argb_8888;
-};
-
-enum class ButtonState
-{
-    Up,         ///< The user is not interacting with this button
-    Hovered,    ///< The user is hovering over this button
-    Down,       ///< The user is currently pressing this button
-};
-
-enum class ButtonFunction
-{
-    Close,
-    Maximize,
-    Minimize,
-};
-
 enum class BorderType
 {
     Full,       ///< Full titlebar and border (for restored windows)
@@ -75,53 +41,55 @@ enum class BorderType
 
 auto border_type_for(MirWindowType type, MirWindowState state) -> BorderType;
 
-struct ButtonInfo
+/// Minimize, maximize, and close buttons
+struct Button
 {
-    ButtonFunction function;
-    ButtonState state;
-    geometry::Rectangle rect;
-
-    auto operator==(ButtonInfo const& other) const -> bool
+    enum class Function
     {
-        return function == other.function &&
-               state == other.state &&
-               rect == other.rect;
-    }
-};
+        Close,
+        Maximize,
+        Minimize,
+    };
+    using enum Function;
 
-/// Describes the state of the interface (what buttons are pushed, etc)
-class InputState
-{
-public:
-    InputState(
-        std::vector<ButtonInfo> const& buttons,
-        std::vector<geometry::Rectangle> const& input_shape)
-        : buttons_{buttons},
-          input_shape_{input_shape}
+    enum class State
     {
-    }
+        Up,         ///< The user is not interacting with this button
+        Hovered,    ///< The user is hovering over this button
+        Down,       ///< The user is currently pressing this button
+    };
+    using enum State;
 
-    auto buttons() const -> std::vector<ButtonInfo> const& { return buttons_; }
-    auto input_shape() const -> std::vector<geometry::Rectangle> const& { return input_shape_; }
+    Function function;
+    State state;
+    geometry::Rectangle rect;
 
-private:
-    InputState(InputState const&) = delete;
-    InputState& operator=(InputState const&) = delete;
+    auto operator==(Button const& other) const -> bool = default;
+};
 
-    std::vector<ButtonInfo> const buttons_;
-    std::vector<geometry::Rectangle> const input_shape_;
+/// Describes the state of the interface (what buttons are pushed, etc)
+struct InputState
+{
+    std::vector<Button> const buttons;
+    std::vector<geometry::Rectangle> const input_shape;
 };
 
+class DecorationStrategy;
+
 /// Information about the geometry and type of decorations for a given window
 /// Data is pulled from the surface on construction and immutable after that
 class WindowState
 {
 public:
     WindowState(
-        std::shared_ptr<StaticGeometry> const& static_geometry,
         std::shared_ptr<scene::Surface> const& window_surface,
+        geometry::Height fixed_titlebar_height,
+        geometry::Width fixed_side_border_width,
+        geometry::Height fixed_bottom_border_height,
         float scale);
 
+    ~WindowState();
+
     auto window_size() const -> geometry::Size;
     auto border_type() const -> BorderType;
     auto focused_state() const -> MirWindowFocusState;
@@ -145,47 +113,56 @@ class WindowState
 
 private:
     WindowState(WindowState const&) = delete;
-    WindowState& operator=(WindowState const&) = delete;
-
-    std::shared_ptr<StaticGeometry> const static_geometry;
-    geometry::Size const window_size_;
-    BorderType const border_type_;
-    MirWindowFocusState const focus_state_;
-    std::string window_name_;
-    float scale_;
+
+    class Self;
+    std::unique_ptr<Self> const self;
 };
 
-class RendererStrategy
+/// Mixin for creating graphics buffers from raw pixels
+class BufferMaker
 {
 public:
-    static auto alloc_pixels(geometry::Size size) -> std::unique_ptr<Pixel[]>;
+    using Pixel = uint32_t;
 
+    virtual auto make_buffer(MirPixelFormat const format, geometry::Size const size, Pixel const* const pixels) const
+    -> std::optional<std::shared_ptr<graphics::Buffer>> = 0;
+
+protected:
+    BufferMaker() = default;
+    virtual ~BufferMaker() = default;
+    BufferMaker(BufferMaker&) = delete;
+    BufferMaker& operator=(BufferMaker const&) = delete;
+};
+
+/// Customization point for rendering
+class RendererStrategy
+{
+public:
     RendererStrategy() = default;
     virtual ~RendererStrategy() = default;
 
-    struct RenderedPixels
-    {
-        MirPixelFormat const format;
-        geometry::Size const size;
-        Pixel const* const pixels;
-    };
-
     virtual void update_state(WindowState const& window_state, InputState const& input_state) = 0;
-    virtual auto render_titlebar() -> std::optional<RenderedPixels> = 0;
-    virtual auto render_left_border() -> std::optional<RenderedPixels> = 0;
-    virtual auto render_right_border() -> std::optional<RenderedPixels> = 0;
-    virtual auto render_bottom_border() -> std::optional<RenderedPixels> = 0;
+    virtual auto render_titlebar(BufferMaker const* buffer_maker) -> std::optional<std::shared_ptr<graphics::Buffer>> = 0;
+    virtual auto render_left_border(BufferMaker const* buffer_maker) -> std::optional<std::shared_ptr<graphics::Buffer>> = 0;
+    virtual auto render_right_border(BufferMaker const* buffer_maker) -> std::optional<std::shared_ptr<graphics::Buffer>> = 0;
+    virtual auto render_bottom_border(BufferMaker const* buffer_maker) -> std::optional<std::shared_ptr<graphics::Buffer>> = 0;
 };
 
+/// Customization point for decorations
 class DecorationStrategy
 {
 public:
 
-    static auto default_decoration_strategy() -> std::unique_ptr<DecorationStrategy>;
+    static auto default_decoration_strategy() -> std::shared_ptr<DecorationStrategy>;
 
-    virtual auto static_geometry() const -> std::shared_ptr<StaticGeometry> = 0;
     virtual auto render_strategy() const -> std::unique_ptr<RendererStrategy> = 0;
     virtual auto button_placement(unsigned n, WindowState const& ws) const -> geometry::Rectangle = 0;
+    virtual auto compute_size_with_decorations(
+        geometry::Size content_size, MirWindowType type, MirWindowState state) const -> geometry::Size = 0;
+    virtual auto new_window_state(
+        std::shared_ptr<scene::Surface> const& window_surface, float scale) const -> std::unique_ptr<WindowState> = 0;
+    virtual auto buffer_format() const -> MirPixelFormat = 0;
+    virtual auto resize_corner_input_size() const -> geometry::Size = 0;
 
     DecorationStrategy() = default;
     virtual ~DecorationStrategy() = default;
diff --git a/src/server/shell/decoration/input.cpp b/src/server/shell/decoration/input.cpp
index 2ddc9d023a..6c4e748324 100644
--- a/src/server/shell/decoration/input.cpp
+++ b/src/server/shell/decoration/input.cpp
@@ -123,14 +123,13 @@ msd::InputManager::InputManager(
     WindowState const& window_state,
     std::shared_ptr<ThreadsafeAccess<BasicDecoration>> const& decoration) :
     decoration_strategy{decoration_strategy},
-    static_geometry{decoration_strategy->static_geometry()},
     decoration_surface{decoration_surface},
     observer{std::make_shared<Observer>(this)},
     decoration{decoration},
     widgets{
-        std::make_shared<Widget>(ButtonFunction::Close),
-        std::make_shared<Widget>(ButtonFunction::Maximize),
-        std::make_shared<Widget>(ButtonFunction::Minimize),
+        std::make_shared<Widget>(Button::Close),
+        std::make_shared<Widget>(Button::Maximize),
+        std::make_shared<Widget>(Button::Minimize),
         std::make_shared<Widget>(mir_resize_edge_northwest),
         std::make_shared<Widget>(mir_resize_edge_northeast),
         std::make_shared<Widget>(mir_resize_edge_southwest),
@@ -165,7 +164,8 @@ void msd::InputManager::update_window_state(WindowState const& window_state)
         }
         else if (widget->resize_edge)
         {
-            widget->rect = resize_edge_rect(window_state, *static_geometry, widget->resize_edge.value());
+            widget->rect = resize_edge_rect(window_state,
+                decoration_strategy->resize_corner_input_size(), widget->resize_edge.value());
         }
         else
         {
@@ -199,11 +199,11 @@ void msd::InputManager::update_window_state(WindowState const& window_state)
 auto msd::InputManager::state() -> std::unique_ptr<InputState>
 {
     std::lock_guard lock{mutex};
-    std::vector<ButtonInfo> buttons;
+    std::vector<Button> buttons;
     for (auto const& widget : widgets)
     {
         if (widget->button)
-            buttons.push_back(ButtonInfo{
+            buttons.push_back(Button{
                 widget->button.value(),
                 widget->state,
                 widget->rect});
@@ -215,7 +215,7 @@ auto msd::InputManager::state() -> std::unique_ptr<InputState>
 
 auto msd::InputManager::resize_edge_rect(
     WindowState const& window_state,
-    StaticGeometry const& static_geometry,
+    geom::Size const& resize_corner_input_size,
     MirResizeEdge resize_edge) -> geom::Rectangle
 {
     switch (resize_edge)
@@ -240,15 +240,15 @@ auto msd::InputManager::resize_edge_rect(
         return window_state.right_border_rect();
 
     case mir_resize_edge_northwest:
-        return {{}, static_geometry.resize_corner_input_size};
+        return {{}, resize_corner_input_size};
 
     case mir_resize_edge_northeast:
     {
         geom::Point top_left{
             as_x(window_state.window_size().width) -
-                as_delta(static_geometry.resize_corner_input_size.width),
+                as_delta(resize_corner_input_size.width),
             0};
-        return {top_left, static_geometry.resize_corner_input_size};
+        return {top_left, resize_corner_input_size};
     }
 
     case mir_resize_edge_southwest:
@@ -256,18 +256,18 @@ auto msd::InputManager::resize_edge_rect(
         geom::Point top_left{
             0,
             as_y(window_state.window_size().height) -
-                as_delta(static_geometry.resize_corner_input_size.height)};
-        return {top_left, static_geometry.resize_corner_input_size};
+                as_delta(resize_corner_input_size.height)};
+        return {top_left, resize_corner_input_size};
     }
 
     case mir_resize_edge_southeast:
     {
         geom::Point top_left{
             as_x(window_state.window_size().width) -
-                as_delta(static_geometry.resize_corner_input_size.width),
+                as_delta(resize_corner_input_size.width),
             as_y(window_state.window_size().height) -
-                as_delta(static_geometry.resize_corner_input_size.height)};
-        return {top_left, static_geometry.resize_corner_input_size};
+                as_delta(resize_corner_input_size.height)};
+        return {top_left, resize_corner_input_size};
     }
 
     default: return {};
@@ -420,7 +420,7 @@ auto msd::InputManager::widget_at(geom::Point location) -> std::optional<std::sh
 
 void msd::InputManager::widget_enter(Widget& widget)
 {
-    widget.state = ButtonState::Hovered;
+    widget.state = Button::Hovered;
     if (widget.resize_edge)
         set_cursor(widget.resize_edge.value());
     decoration->spawn([](BasicDecoration* decoration)
@@ -431,7 +431,7 @@ void msd::InputManager::widget_enter(Widget& widget)
 
 void msd::InputManager::widget_leave(Widget& widget)
 {
-    widget.state = ButtonState::Up;
+    widget.state = Button::Up;
     set_cursor(mir_resize_edge_none);
     decoration->spawn([](BasicDecoration* decoration)
         {
@@ -441,7 +441,7 @@ void msd::InputManager::widget_leave(Widget& widget)
 
 void msd::InputManager::widget_down(Widget& widget)
 {
-    widget.state = ButtonState::Down;
+    widget.state = Button::Down;
     decoration->spawn([](BasicDecoration* decoration)
         {
             decoration->input_state_updated();
@@ -450,7 +450,7 @@ void msd::InputManager::widget_down(Widget& widget)
 
 void msd::InputManager::widget_up(Widget& widget)
 {
-    if (widget.state == ButtonState::Down)
+    if (widget.state == Button::Down)
     {
         auto const input_ev = mir_event_get_input_event(latest_event.get());
         auto const event_timestamp = std::chrono::nanoseconds{mir_input_event_get_event_time(input_ev)};
@@ -473,21 +473,21 @@ void msd::InputManager::widget_up(Widget& widget)
         {
             switch (widget.button.value())
             {
-            case ButtonFunction::Close:
+            case Button::Close:
                 decoration->spawn([](BasicDecoration* decoration)
                     {
                         decoration->request_close();
                     });
                 break;
 
-            case ButtonFunction::Maximize:
+            case Button::Maximize:
                 decoration->spawn([](BasicDecoration* decoration)
                     {
                         decoration->request_toggle_maximize();
                     });
                 break;
 
-            case ButtonFunction::Minimize:
+            case Button::Minimize:
                 decoration->spawn([](BasicDecoration* decoration)
                     {
                         decoration->request_minimize();
@@ -496,7 +496,7 @@ void msd::InputManager::widget_up(Widget& widget)
             }
         }
     }
-    widget.state = ButtonState::Hovered;
+    widget.state = Button::Hovered;
     decoration->spawn([](BasicDecoration* decoration)
         {
             decoration->input_state_updated();
@@ -505,7 +505,7 @@ void msd::InputManager::widget_up(Widget& widget)
 
 void msd::InputManager::widget_drag(Widget& widget)
 {
-    if (widget.state == ButtonState::Down)
+    if (widget.state == Button::Down)
     {
         if (widget.resize_edge)
         {
@@ -533,7 +533,7 @@ void msd::InputManager::widget_drag(Widget& widget)
                     decoration->request_move(mir_event_get_input_event(event.get()));
                 });
         }
-        widget.state = ButtonState::Up;
+        widget.state = Button::Up;
     }
     decoration->spawn([](BasicDecoration* decoration)
         {
diff --git a/src/server/shell/decoration/input.h b/src/server/shell/decoration/input.h
index a0e8b4e493..cf87af112e 100644
--- a/src/server/shell/decoration/input.h
+++ b/src/server/shell/decoration/input.h
@@ -47,7 +47,6 @@ namespace decoration
 {
 class WindowState;
 class BasicDecoration;
-class StaticGeometry;
 template<typename T> class ThreadsafeAccess;
 
 /// Manages the observer that listens to user input
@@ -72,7 +71,7 @@ class InputManager
 
     static auto resize_edge_rect(
         WindowState const& window_state,
-        StaticGeometry const& static_geometry,
+        geometry::Size const& resize_corner_input_size,
         MirResizeEdge resize_edge) -> geometry::Rectangle;
     void pointer_event(std::shared_ptr<MirEvent const> const& event, geometry::Point location, bool pressed);
     void pointer_leave(std::shared_ptr<MirEvent const> const& event);
@@ -83,7 +82,6 @@ class InputManager
 
     std::mutex mutex;
     std::shared_ptr<DecorationStrategy> const decoration_strategy;
-    std::shared_ptr<StaticGeometry> const static_geometry;
     std::shared_ptr<scene::Surface> decoration_surface;
     std::shared_ptr<Observer> const observer;
     std::shared_ptr<ThreadsafeAccess<BasicDecoration>> decoration;
@@ -96,7 +94,7 @@ class InputManager
 
     struct Widget
     {
-        Widget(ButtonFunction button)
+        Widget(Button::Function button)
             : button{button}
         {
         }
@@ -107,8 +105,8 @@ class InputManager
         }
 
         geometry::Rectangle rect;
-        ButtonState state{ButtonState::Up};
-        std::optional<ButtonFunction> const button;
+        Button::State state{Button::Up};
+        std::optional<Button::Function> const button;
         // mir_resize_edge_none is used to mean the widget moves the window
         std::optional<MirResizeEdge> const resize_edge;
     };
diff --git a/src/server/shell/decoration/renderer.cpp b/src/server/shell/decoration/renderer.cpp
index c816ec76f5..d056b78530 100644
--- a/src/server/shell/decoration/renderer.cpp
+++ b/src/server/shell/decoration/renderer.cpp
@@ -48,11 +48,10 @@ std::shared_ptr<graphics::GraphicBufferAllocator> const& buffer_allocator,
 {
 }
 
-auto msd::Renderer::make_buffer(
-    uint32_t const* pixels,
-    geometry::Size size,
-    MirPixelFormat buffer_format) -> std::optional<std::shared_ptr<mg::Buffer>>
+auto mir::shell::decoration::Renderer::make_buffer(const MirPixelFormat format, const geometry::Size size,
+    Pixel const* const pixels) const -> std::optional<std::shared_ptr<graphics::Buffer>>
 {
+    MirPixelFormat buffer_format = format;
     if (!area(size))
     {
         log_warning("Failed to draw SSD: tried to create zero size buffer");
@@ -83,50 +82,22 @@ auto msd::Renderer::make_buffer(
 
 auto msd::Renderer::render_titlebar() -> std::optional<std::shared_ptr<mg::Buffer>>
 {
-    if (auto const& rendered_pixels = strategy->render_titlebar())
-    {
-        return make_buffer(rendered_pixels->pixels, rendered_pixels->size, rendered_pixels->format);
-    }
-    else
-    {
-        return std::nullopt;
-    }
+    return strategy->render_titlebar(this);
 }
 
 auto msd::Renderer::render_left_border() -> std::optional<std::shared_ptr<mg::Buffer>>
 {
-    if (auto const& rendered_pixels = strategy->render_left_border())
-    {
-        return make_buffer(rendered_pixels->pixels, rendered_pixels->size, rendered_pixels->format);
-    }
-    else
-    {
-        return std::nullopt;
-    }
+    return strategy->render_left_border(this);
 }
 
 auto msd::Renderer::render_right_border() -> std::optional<std::shared_ptr<mg::Buffer>>
 {
-    if (auto const& rendered_pixels = strategy->render_right_border())
-    {
-        return make_buffer(rendered_pixels->pixels, rendered_pixels->size, rendered_pixels->format);
-    }
-    else
-    {
-        return std::nullopt;
-    }
+    return strategy->render_right_border(this);
 }
 
 auto msd::Renderer::render_bottom_border() -> std::optional<std::shared_ptr<mg::Buffer>>
 {
-    if (auto const& rendered_pixels = strategy->render_bottom_border())
-    {
-        return make_buffer(rendered_pixels->pixels, rendered_pixels->size, rendered_pixels->format);
-    }
-    else
-    {
-        return std::nullopt;
-    }
+    return strategy->render_bottom_border(this);
 }
 
 
@@ -134,13 +105,3 @@ void msd::Renderer::update_state(WindowState const& window_state, InputState con
 {
     strategy->update_state(window_state, input_state);
 }
-
-
-auto msd::RendererStrategy::alloc_pixels(geometry::Size size) -> std::unique_ptr<Pixel[]>
-{
-    size_t const buf_size = area(size) * sizeof(Pixel);
-    if (buf_size)
-        return std::unique_ptr<Pixel[]>{new Pixel[buf_size]};
-    else
-        return nullptr;
-}
\ No newline at end of file
diff --git a/src/server/shell/decoration/renderer.h b/src/server/shell/decoration/renderer.h
index 1bc1a703d7..492890c9cb 100644
--- a/src/server/shell/decoration/renderer.h
+++ b/src/server/shell/decoration/renderer.h
@@ -41,7 +41,7 @@ class WindowState;
 class InputState;
 struct StaticGeometry;
 
-class Renderer
+class Renderer : BufferMaker
 {
 public:
     Renderer(
@@ -58,10 +58,8 @@ class Renderer
     std::shared_ptr<graphics::GraphicBufferAllocator> const buffer_allocator;
     std::unique_ptr<RendererStrategy> const strategy;
 
-    auto make_buffer(
-        Pixel const* pixels,
-        geometry::Size size,
-        MirPixelFormat buffer_format) -> std::optional<std::shared_ptr<graphics::Buffer>>;
+    auto make_buffer(const MirPixelFormat format, const geometry::Size size,
+        Pixel const* const pixels) const -> std::optional<std::shared_ptr<graphics::Buffer>> override;
 };
 }
 }
diff --git a/src/server/shell/decoration/window.cpp b/src/server/shell/decoration/window.cpp
index 300d4039be..2802c55527 100644
--- a/src/server/shell/decoration/window.cpp
+++ b/src/server/shell/decoration/window.cpp
@@ -26,42 +26,83 @@ namespace ms = mir::scene;
 namespace geom = mir::geometry;
 namespace msd = mir::shell::decoration;
 
+class msd::WindowState::Self
+{
+public:
+    Self(
+        std::shared_ptr<scene::Surface> const& surface,
+        geometry::Height fixed_titlebar_height,
+        geometry::Width fixed_side_border_width,
+        geometry::Height fixed_bottom_border_height,
+        float scale);
+
+    geometry::Height const fixed_titlebar_height;
+    geometry::Width const fixed_side_border_width;
+    geometry::Height const fixed_bottom_border_height;
+    geometry::Size const window_size;
+    BorderType const border_type;
+    MirWindowFocusState const focus_state;
+    std::string const window_name;
+    float const scale;
+};
+
+msd::WindowState::Self::Self(
+    std::shared_ptr<scene::Surface> const& surface,
+    geometry::Height fixed_titlebar_height,
+    geometry::Width fixed_side_border_width,
+    geometry::Height fixed_bottom_border_height,
+    float scale)
+    : fixed_titlebar_height(fixed_titlebar_height),
+      fixed_side_border_width(fixed_side_border_width),
+      fixed_bottom_border_height(fixed_bottom_border_height),
+      window_size{surface->window_size()},
+      border_type{border_type_for(surface->type(), surface->state())},
+      focus_state{surface->focus_state()},
+      window_name{surface->name()},
+      scale{scale}
+{
+}
+
 msd::WindowState::WindowState(
-    std::shared_ptr<StaticGeometry> const& static_geometry,
     std::shared_ptr<scene::Surface> const& surface,
+    geometry::Height fixed_titlebar_height,
+    geometry::Width fixed_side_border_width,
+    geometry::Height fixed_bottom_border_height,
     float scale)
-    : static_geometry{static_geometry},
-      window_size_{surface->window_size()},
-      border_type_{border_type_for(surface->type(), surface->state())},
-      focus_state_{surface->focus_state()},
-      window_name_{surface->name()},
-      scale_{scale}
+    : self{std::make_unique<Self>(
+        surface,
+        fixed_titlebar_height,
+        fixed_side_border_width,
+        fixed_bottom_border_height,
+        scale)}
 {
 }
 
+mir::shell::decoration::WindowState::~WindowState() = default;
+
 auto msd::WindowState::window_size() const -> geom::Size
 {
-    return window_size_;
+    return self->window_size;
 }
 
 auto msd::WindowState::border_type() const -> BorderType
 {
-    return border_type_;
+    return self->border_type;
 }
 
 auto msd::WindowState::focused_state() const -> MirWindowFocusState
 {
-    return focus_state_;
+    return self->focus_state;
 }
 
 auto msd::WindowState::window_name() const -> std::string
 {
-    return window_name_;
+    return self->window_name;
 }
 
 auto msd::WindowState::titlebar_width() const -> geom::Width
 {
-    switch (border_type_)
+    switch (self->border_type)
     {
     case BorderType::Full:
     case BorderType::Titlebar:
@@ -76,11 +117,11 @@ auto msd::WindowState::titlebar_width() const -> geom::Width
 
 auto msd::WindowState::titlebar_height() const -> geom::Height
 {
-    switch (border_type_)
+    switch (self->border_type)
     {
     case BorderType::Full:
     case BorderType::Titlebar:
-        return static_geometry->titlebar_height;
+        return self->fixed_titlebar_height;
     case BorderType::None:
         return {};
     }
@@ -91,10 +132,10 @@ auto msd::WindowState::titlebar_height() const -> geom::Height
 
 auto msd::WindowState::side_border_width() const -> geom::Width
 {
-    switch (border_type_)
+    switch (self->border_type)
     {
     case BorderType::Full:
-        return static_geometry->side_border_width;
+        return self->fixed_side_border_width;
     case BorderType::Titlebar:
     case BorderType::None:
         return {};
@@ -106,7 +147,7 @@ auto msd::WindowState::side_border_width() const -> geom::Width
 
 auto msd::WindowState::side_border_height() const -> geom::Height
 {
-    switch (border_type_)
+    switch (self->border_type)
     {
     case BorderType::Full:
         return window_size().height - as_delta(titlebar_height()) - as_delta(bottom_border_height());
@@ -126,10 +167,10 @@ auto msd::WindowState::bottom_border_width() const -> geom::Width
 
 auto msd::WindowState::bottom_border_height() const -> geom::Height
 {
-    switch (border_type_)
+    switch (self->border_type)
     {
     case BorderType::Full:
-        return static_geometry->bottom_border_height;
+        return self->fixed_bottom_border_height;
     case BorderType::Titlebar:
     case BorderType::None:
         return {};
@@ -169,7 +210,7 @@ auto msd::WindowState::bottom_border_rect() const -> geom::Rectangle
 
 auto msd::WindowState::scale() const -> float
 {
-    return scale_;
+    return self->scale;
 }
 
 class msd::WindowSurfaceObserverManager::Observer