matplotlib
diff --git a/‎lib/matplotlib/legend.py‎
Lines changed: 6 additions & 1 deletion b/‎lib/matplotlib/legend.py‎
Lines changed: 6 additions & 1 deletion
diff --git a/‎lib/matplotlib/offsetbox.py‎
Lines changed: 23 additions & 14 deletions b/‎lib/matplotlib/offsetbox.py‎
Lines changed: 23 additions & 14 deletions
diff --git a/‎lib/mpl_toolkits/axes_grid1/inset_locator.py‎
Lines changed: 1 addition & 1 deletion b/‎lib/mpl_toolkits/axes_grid1/inset_locator.py‎
Lines changed: 1 addition & 1 deletion
@@ -585,8 +585,11 @@ def _get_loc(self):
 
     _loc = property(_get_loc, _set_loc)
 
-    def _findoffset(self, width, height, xdescent, ydescent, renderer):
+    def _findoffset(self):
         """Helper function to locate the legend."""
+        renderer = self.figure._cachedRenderer or self._cached_renderer
+        width, height, xdescent, ydescent = self._legend_box.get_extent(
+            renderer)
 
         if self._loc == 0:  # "best".
             x, y = self._find_best_position(width, height, renderer)
@@ -883,6 +886,8 @@ def get_window_extent(self, renderer=None):
         # docstring inherited
         if renderer is None:
             renderer = self.figure._cachedRenderer
+        # May not be cached on the figure, so cache it ourselves.
+        self._cached_renderer = renderer
         return self._legend_box.get_window_extent(renderer=renderer)
 
     def get_tightbbox(self, renderer):
 
@@ -263,11 +263,19 @@ def set_offset(self, xy):
         xy : (float, float) or callable
             The (x, y) coordinates of the offset in display units. These can
             either be given explicitly as a tuple (x, y), or by providing a
-            function that converts the extent into the offset. This function
-            must have the signature::
+            function that dynamically computes an offset (taking the arguments
+            passed to `.OffsetBox.get_offset`).  It is recommended to make such
+            functions take no arguments.
+
+            Before version 3.6, the callable had to have the signature::
 
                 def offset(width, height, xdescent, ydescent, renderer) \
 -> (float, float)
+
+            For backwards compatibility, callables with arbitrary signatures
+            are currently accepted as long as compatible arguments are
+            passed in calls to `.set_offset`. This should be considered an
+            implementation detail, and may be deprecated in the future.
         """
         self._offset = xy
         self.stale = True
@@ -276,9 +284,12 @@ def get_offset(self, *args, **kwargs):
         """
         Return the (x, y) offset.
 
-        Parameters must be passed if the offset is dynamically determined by a
-        callable (see `~.OffsetBox.set_offset`), and are forwarded to that
-        callable.
+        Parameters are usually not necessary. The only exception can occur
+        if you have defined a callable to calculate the offset dynamically (see
+        `~.OffsetBox.set_offset`). It is now recommended that such a
+        callable does not take parameters. However, for backward-compatibility,
+        callables with parameters are still supported; these parameters must be
+        provided to `.get_offset` so that we can pass them on.
         """
         return (self._offset(*args, **kwargs) if callable(self._offset)
                 else self._offset)
@@ -340,7 +351,7 @@ def get_extent(self, renderer):
     def get_window_extent(self, renderer):
         # docstring inherited
         w, h, xd, yd = self.get_extent(renderer)
-        px, py = self.get_offset(w, h, xd, yd, renderer)
+        px, py = self.get_offset()
         return mtransforms.Bbox.from_bounds(px - xd, py - yd, w, h)
 
     def draw(self, renderer):
@@ -349,7 +360,7 @@ def draw(self, renderer):
         to the given *renderer*.
         """
         w, h, xdescent, ydescent, offsets = self.get_extent_offsets(renderer)
-        px, py = self.get_offset(w, h, xdescent, ydescent, renderer)
+        px, py = self.get_offset()
         for c, (ox, oy) in zip(self.get_visible_children(), offsets):
             c.set_offset((px + ox, py + oy))
             c.draw(renderer)
@@ -530,7 +541,7 @@ def get_extent_offsets(self, renderer):
     def draw(self, renderer):
         # docstring inherited
         w, h, xdescent, ydescent, offsets = self.get_extent_offsets(renderer)
-        px, py = self.get_offset(w, h, xdescent, ydescent, renderer)
+        px, py = self.get_offset()
         for c, (ox, oy) in zip(self.get_visible_children(), offsets):
             c.set_offset((px + ox, py + oy))
 
@@ -1036,9 +1047,10 @@ def get_window_extent(self, renderer):
         # docstring inherited
         # Update the offset func, which depends on the dpi of the renderer
         # (because of the padding).
+        w, h, xd, yd = self.get_extent(renderer)
         fontsize = renderer.points_to_pixels(self.prop.get_size_in_points())
 
-        def _offset(w, h, xd, yd, renderer):
+        def _offset(*args, **kwargs):  # args are ignored; left for backcompat.
             bbox = Bbox.from_bounds(0, 0, w, h)
             pad = self.borderpad * fontsize
             bbox_to_anchor = self.get_bbox_to_anchor()
@@ -1064,9 +1076,7 @@ def draw(self, renderer):
         self.update_frame(bbox, fontsize)
         self.patch.draw(renderer)
 
-        width, height, xdescent, ydescent = self.get_extent(renderer)
-
-        px, py = self.get_offset(width, height, xdescent, ydescent, renderer)
+        px, py = self.get_offset()
 
         self.get_child().set_offset((px, py))
         self.get_child().draw(renderer)
@@ -1545,8 +1555,7 @@ def __init__(self, ref_artist, offsetbox, use_blit=False):
     def save_offset(self):
         offsetbox = self.offsetbox
         renderer = offsetbox.figure._cachedRenderer
-        w, h, xd, yd = offsetbox.get_extent(renderer)
-        offset = offsetbox.get_offset(w, h, xd, yd, renderer)
+        offset = offsetbox.get_offset()
         self.offsetbox_x, self.offsetbox_y = offset
         self.offsetbox.set_offset(offset)
 
 
@@ -71,7 +71,7 @@ def draw(self, renderer):
     def __call__(self, ax, renderer):
         self.axes = ax
         bbox = self.get_window_extent(renderer)
-        px, py = self.get_offset(bbox.width, bbox.height, 0, 0, renderer)
+        px, py = self.get_offset()
         bbox_canvas = Bbox.from_bounds(px, py, bbox.width, bbox.height)
         tr = ax.figure.transFigure.inverted()
         return TransformedBbox(bbox_canvas, tr)