@@ -0,0 +1,10 @@
+No need to specify renderer for get_tightbbox and get_window_extent
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The ``get_tightbbox`` and `~.Artist.get_window_extent` methods
+no longer require the *renderer* kwarg, saving users from having to
+querry it from ``fig.canvas.get_renderer``.  Currently, all Artists are
+aware of their parent figure (``artist.figure``), and if the *renderer*
+kwarg is not supplied these methods first check if there is a cached renderer
+from a previous draw and use that.  If there is no cahched renderer, then
+the methods will use ``fig.canvas.get_renderer()`` as a fallback.
@@ -18,7 +18,6 @@
 import numpy as np
 
 from matplotlib import _api, artist as martist
-from matplotlib._tight_layout import get_renderer
 import matplotlib.transforms as mtransforms
 import matplotlib._layoutgrid as mlayoutgrid
 
@@ -74,8 +73,6 @@ def do_constrained_layout(fig, h_pad, w_pad,
     fig : Figure
         ``Figure`` instance to do the layout in.
 
-    renderer : Renderer
-        Renderer to use.
 
     h_pad, w_pad : float
       Padding around the axes elements in figure-normalized units.
@@ -92,7 +89,6 @@ def do_constrained_layout(fig, h_pad, w_pad,
     layoutgrid : private debugging structure
     """
 
-    renderer = get_renderer(fig)
     # make layoutgrid tree...
     layoutgrids = make_layoutgrids(fig, None)
     if not layoutgrids['hasgrids']:
@@ -109,9 +105,9 @@ def do_constrained_layout(fig, h_pad, w_pad,
 
         # make margins for all the axes and subfigures in the
         # figure.  Add margins for colorbars...
-        make_layout_margins(layoutgrids, fig, renderer, h_pad=h_pad,
+        make_layout_margins(layoutgrids, fig, h_pad=h_pad,
                             w_pad=w_pad, hspace=hspace, wspace=wspace)
-        make_margin_suptitles(layoutgrids, fig, renderer, h_pad=h_pad,
+        make_margin_suptitles(layoutgrids, fig, h_pad=h_pad,
                               w_pad=w_pad)
 
         # if a layout is such that a columns (or rows) margin has no
@@ -123,7 +119,7 @@ def do_constrained_layout(fig, h_pad, w_pad,
         layoutgrids[fig].update_variables()
 
         if check_no_collapsed_axes(layoutgrids, fig):
-            reposition_axes(layoutgrids, fig, renderer, h_pad=h_pad,
+            reposition_axes(layoutgrids, fig, h_pad=h_pad,
                             w_pad=w_pad, hspace=hspace, wspace=wspace)
         else:
             _api.warn_external('constrained_layout not applied because '
@@ -283,7 +279,7 @@ def get_margin_from_padding(obj, *, w_pad=0, h_pad=0,
     return margin
 
 
-def make_layout_margins(layoutgrids, fig, renderer, *, w_pad=0, h_pad=0,
+def make_layout_margins(layoutgrids, fig, *, w_pad=0, h_pad=0,
                         hspace=0, wspace=0):
     """
     For each axes, make a margin between the *pos* layoutbox and the
@@ -294,7 +290,7 @@ def make_layout_margins(layoutgrids, fig, renderer, *, w_pad=0, h_pad=0,
     """
     for sfig in fig.subfigs:  # recursively make child panel margins
         ss = sfig._subplotspec
-        make_layout_margins(layoutgrids, sfig, renderer,
+        make_layout_margins(layoutgrids, sfig,
                             w_pad=w_pad, h_pad=h_pad,
                             hspace=hspace, wspace=wspace)
 
@@ -314,7 +310,7 @@ def make_layout_margins(layoutgrids, fig, renderer, *, w_pad=0, h_pad=0,
 
         margin = get_margin_from_padding(ax, w_pad=w_pad, h_pad=h_pad,
                                          hspace=hspace, wspace=wspace)
-        pos, bbox = get_pos_and_bbox(ax, renderer)
+        pos, bbox = get_pos_and_bbox(ax)
         # the margin is the distance between the bounding box of the axes
         # and its position (plus the padding from above)
         margin['left'] += pos.x0 - bbox.x0
@@ -331,7 +327,7 @@ def make_layout_margins(layoutgrids, fig, renderer, *, w_pad=0, h_pad=0,
             # colorbars can be child of more than one subplot spec:
             cbp_rspan, cbp_cspan = get_cb_parent_spans(cbax)
             loc = cbax._colorbar_info['location']
-            cbpos, cbbbox = get_pos_and_bbox(cbax, renderer)
+            cbpos, cbbbox = get_pos_and_bbox(cbax)
             if loc == 'right':
                 if cbp_cspan.stop == ss.colspan.stop:
                     # only increase if the colorbar is on the right edge
@@ -367,7 +363,7 @@ def make_layout_margins(layoutgrids, fig, renderer, *, w_pad=0, h_pad=0,
         layoutgrids[gs].edit_outer_margin_mins(margin, ss)
 
 
-def make_margin_suptitles(layoutgrids, fig, renderer, *, w_pad=0, h_pad=0):
+def make_margin_suptitles(layoutgrids, fig, *, w_pad=0, h_pad=0):
     # Figure out how large the suptitle is and make the
     # top level figure margin larger.
 
@@ -380,29 +376,29 @@ def make_margin_suptitles(layoutgrids, fig, renderer, *, w_pad=0, h_pad=0):
     w_pad_local = padbox.width
 
     for sfig in fig.subfigs:
-        make_margin_suptitles(layoutgrids, sfig, renderer,
+        make_margin_suptitles(layoutgrids, sfig,
                               w_pad=w_pad, h_pad=h_pad)
 
     if fig._suptitle is not None and fig._suptitle.get_in_layout():
         p = fig._suptitle.get_position()
         if getattr(fig._suptitle, '_autopos', False):
             fig._suptitle.set_position((p[0], 1 - h_pad_local))
-            bbox = inv_trans_fig(fig._suptitle.get_tightbbox(renderer))
+            bbox = inv_trans_fig(fig._suptitle.get_tightbbox())
             layoutgrids[fig].edit_margin_min('top', bbox.height + 2 * h_pad)
 
     if fig._supxlabel is not None and fig._supxlabel.get_in_layout():
         p = fig._supxlabel.get_position()
         if getattr(fig._supxlabel, '_autopos', False):
             fig._supxlabel.set_position((p[0], h_pad_local))
-            bbox = inv_trans_fig(fig._supxlabel.get_tightbbox(renderer))
+            bbox = inv_trans_fig(fig._supxlabel.get_tightbbox())
             layoutgrids[fig].edit_margin_min('bottom',
                                              bbox.height + 2 * h_pad)
 
     if fig._supylabel is not None and fig._supylabel.get_in_layout():
         p = fig._supylabel.get_position()
         if getattr(fig._supylabel, '_autopos', False):
             fig._supylabel.set_position((w_pad_local, p[1]))
-            bbox = inv_trans_fig(fig._supylabel.get_tightbbox(renderer))
+            bbox = inv_trans_fig(fig._supylabel.get_tightbbox())
             layoutgrids[fig].edit_margin_min('left', bbox.width + 2 * w_pad)
 
 
@@ -523,14 +519,14 @@ def get_cb_parent_spans(cbax):
     return rowspan, colspan
 
 
-def get_pos_and_bbox(ax, renderer):
+def get_pos_and_bbox(ax):
     """
     Get the position and the bbox for the axes.
 
     Parameters
     ----------
     ax
-    renderer
+
 
     Returns
     -------
@@ -543,15 +539,15 @@ def get_pos_and_bbox(ax, renderer):
     pos = ax.get_position(original=True)
     # pos is in panel co-ords, but we need in figure for the layout
     pos = pos.transformed(fig.transSubfigure - fig.transFigure)
-    tightbbox = martist._get_tightbbox_for_layout_only(ax, renderer)
+    tightbbox = martist._get_tightbbox_for_layout_only(ax)
     if tightbbox is None:
         bbox = pos
     else:
         bbox = tightbbox.transformed(fig.transFigure.inverted())
     return pos, bbox
 
 
-def reposition_axes(layoutgrids, fig, renderer, *,
+def reposition_axes(layoutgrids, fig, *,
                     w_pad=0, h_pad=0, hspace=0, wspace=0):
     """
     Reposition all the axes based on the new inner bounding box.
@@ -561,7 +557,7 @@ def reposition_axes(layoutgrids, fig, renderer, *,
         bbox = layoutgrids[sfig].get_outer_bbox()
         sfig._redo_transform_rel_fig(
             bbox=bbox.transformed(trans_fig_to_subfig))
-        reposition_axes(layoutgrids, sfig, renderer,
+        reposition_axes(layoutgrids, sfig,
                         w_pad=w_pad, h_pad=h_pad,
                         wspace=wspace, hspace=hspace)
 
@@ -589,11 +585,11 @@ def reposition_axes(layoutgrids, fig, renderer, *,
         offset = {'left': 0, 'right': 0, 'bottom': 0, 'top': 0}
         for nn, cbax in enumerate(ax._colorbars[::-1]):
             if ax == cbax._colorbar_info['parents'][0]:
-                reposition_colorbar(layoutgrids, cbax, renderer,
+                reposition_colorbar(layoutgrids, cbax,
                                     offset=offset)
 
 
-def reposition_colorbar(layoutgrids, cbax, renderer, *, offset=None):
+def reposition_colorbar(layoutgrids, cbax, *, offset=None):
     """
     Place the colorbar in its new place.
 
@@ -602,7 +598,6 @@ def reposition_colorbar(layoutgrids, cbax, renderer, *, offset=None):
     cbax : Axes
         Axes for the colorbar
 
-    renderer :
     w_pad, h_pad : float
         width and height padding (in fraction of figure)
     hspace, wspace : float
@@ -629,7 +624,7 @@ def reposition_colorbar(layoutgrids, cbax, renderer, *, offset=None):
     aspect = cbax._colorbar_info['aspect']
     shrink = cbax._colorbar_info['shrink']
 
-    cbpos, cbbbox = get_pos_and_bbox(cbax, renderer)
+    cbpos, cbbbox = get_pos_and_bbox(cbax)
 
     # Colorbar gets put at extreme edge of outer bbox of the subplotspec
     # It needs to be moved in by: 1) a pad 2) its "margin" 3) by
 
@@ -199,15 +199,7 @@ def auto_adjust_subplotpars(
 
 
 def get_renderer(fig):
-    if fig._cachedRenderer:
-        return fig._cachedRenderer
-    else:
-        canvas = fig.canvas
-        if canvas and hasattr(canvas, "get_renderer"):
-            return canvas.get_renderer()
-        else:
-            from . import backend_bases
-            return backend_bases._get_renderer(fig)
+    fig._get_cached_renderer()
 
 
 def get_subplotspec_list(axes_list, grid_spec=None):
@@ -244,7 +236,7 @@ def get_subplotspec_list(axes_list, grid_spec=None):
     return subplotspec_list
 
 
-def get_tight_layout_figure(fig, axes_list, subplotspec_list, renderer,
+def get_tight_layout_figure(fig, axes_list, subplotspec_list, renderer=None,
                             pad=1.08, h_pad=None, w_pad=None, rect=None):
     """
     Return subplot parameters for tight-layouted-figure with specified padding.
 
@@ -298,7 +298,7 @@ def stale(self, val):
         if val and self.stale_callback is not None:
             self.stale_callback(self, val)
 
-    def get_window_extent(self, renderer):
+    def get_window_extent(self, renderer=None):
         """
         Get the artist's bounding box in display space.
 
@@ -318,7 +318,7 @@ def get_window_extent(self, renderer):
         """
         return Bbox([[0, 0], [0, 0]])
 
-    def get_tightbbox(self, renderer):
+    def get_tightbbox(self, renderer=None):
         """
         Like `.Artist.get_window_extent`, but includes any clipping.
 
 
@@ -4433,7 +4433,7 @@ def get_default_bbox_extra_artists(self):
         return [a for a in artists if a.get_visible() and a.get_in_layout()
                 and (isinstance(a, noclip) or not a._fully_clipped_to_axes())]
 
-    def get_tightbbox(self, renderer, call_axes_locator=True,
+    def get_tightbbox(self, renderer=None, call_axes_locator=True,
                       bbox_extra_artists=None, *, for_layout_only=False):
         """
         Return the tight bounding box of the Axes, including axis and their
@@ -4477,6 +4477,8 @@ def get_tightbbox(self, renderer, call_axes_locator=True,
         """
 
         bb = []
+        if renderer is None:
+            renderer = self.figure._get_cached_renderer()
 
         if not self.get_visible():
             return None
 
@@ -1200,14 +1200,16 @@ def _update_ticks(self):
 
         return ticks_to_draw
 
-    def _get_ticklabel_bboxes(self, ticks, renderer):
+    def _get_ticklabel_bboxes(self, ticks, renderer=None):
         """Return lists of bboxes for ticks' label1's and label2's."""
+        if renderer is None:
+            renderer = self.figure._get_cached_renderer()
         return ([tick.label1.get_window_extent(renderer)
                  for tick in ticks if tick.label1.get_visible()],
                 [tick.label2.get_window_extent(renderer)
                  for tick in ticks if tick.label2.get_visible()])
 
-    def get_tightbbox(self, renderer, *, for_layout_only=False):
+    def get_tightbbox(self, renderer=None, *, for_layout_only=False):
         """
         Return a bounding box that encloses the axis. It only accounts
         tick labels, axis label, and offsetText.
@@ -1219,7 +1221,8 @@ def get_tightbbox(self, renderer, *, for_layout_only=False):
         """
         if not self.get_visible():
             return
-
+        if renderer is None:
+            renderer = self.figure._get_cached_renderer()
         ticks_to_draw = self._update_ticks()
 
         self._update_label_position(renderer)
 
@@ -304,7 +304,7 @@ def get_datalim(self, transData):
                 return bbox
         return transforms.Bbox.null()
 
-    def get_window_extent(self, renderer):
+    def get_window_extent(self, renderer=None):
         # TODO: check to ensure that this does not fail for
         # cases other than scatter plot legend
         return self.get_datalim(transforms.IdentityTransform())
 
@@ -1619,7 +1619,7 @@ def get_default_bbox_extra_artists(self):
                 bbox_artists.extend(ax.get_default_bbox_extra_artists())
         return bbox_artists
 
-    def get_tightbbox(self, renderer, bbox_extra_artists=None):
+    def get_tightbbox(self, renderer=None, bbox_extra_artists=None):
         """
         Return a (tight) bounding box of the figure *in inches*.
 
@@ -1646,6 +1646,9 @@ def get_tightbbox(self, renderer, bbox_extra_artists=None):
             containing the bounding box (in figure inches).
         """
 
+        if renderer is None:
+            renderer = self.figure._get_cached_renderer()
+
         bb = []
         if bbox_extra_artists is None:
             artists = self.get_default_bbox_extra_artists()
@@ -2055,6 +2058,9 @@ def dpi(self):
     def dpi(self, value):
         self._parent.dpi = value
 
+    def _get_cached_renderer(self):
+        return self._parent._get_cached_renderer()
+
     def _redo_transform_rel_fig(self, bbox=None):
         """
         Make the transSubfigure bbox relative to Figure transform.
@@ -2482,6 +2488,14 @@ def axes(self):
 
     get_axes = axes.fget
 
+    def _get_cached_renderer(self):
+        if self._cachedRenderer is not None:
+            return self._cachedRenderer
+        elif hasattr(self.canvas, 'get_renderer'):
+            return self.canvas.get_renderer()
+        else:
+            return _get_renderer(self)
+
     def _get_dpi(self):
         return self._dpi
 
@@ -2630,7 +2644,7 @@ def get_constrained_layout_pads(self, relative=False):
         hspace = info['hspace']
 
         if relative and (w_pad is not None or h_pad is not None):
-            renderer = _get_renderer(self)
+            renderer = self._get_cached_renderer()
             dpi = renderer.dpi
             w_pad = w_pad * dpi / renderer.width
             h_pad = h_pad * dpi / renderer.height
 
@@ -1425,7 +1425,7 @@ def __init__(self, bbox,
 
     def get_window_extent(self, renderer=None):
         if renderer is None:
-            renderer = self.get_figure()._cachedRenderer
+            renderer = self.get_figure()._get_cached_renderer()
 
         if isinstance(self.bbox, BboxBase):
             return self.bbox
 
@@ -22,8 +22,6 @@
 from matplotlib._constrained_layout import do_constrained_layout
 from matplotlib._tight_layout import (get_subplotspec_list,
                                       get_tight_layout_figure)
-# from matplotlib.backend_bases import _get_renderer
-from matplotlib._tight_layout import get_renderer
 
 
 class LayoutEngine:
@@ -154,7 +152,7 @@ def execute(self, fig):
             _api.warn_external("This figure includes Axes that are not "
                                "compatible with tight_layout, so results "
                                "might be incorrect.")
-        renderer = get_renderer(fig)
+        renderer = fig._get_cached_renderer()
         with getattr(renderer, "_draw_disabled", nullcontext)():
             kwargs = get_tight_layout_figure(
                 fig, fig.axes, subplotspec_list, renderer,