[mutter] Rename meta_window_get_outer_rect() to meta_window_get_frame_rect()

[Owen Taylor <otaylor src gnome org>]

commit fbbc32422e30e8e84d62280362826f5d08ce9caa
Author: Owen W. Taylor <otaylor fishsoup net>
Date:   Tue Nov 19 12:24:45 2013 -0500

    Rename meta_window_get_outer_rect() to meta_window_get_frame_rect()
    
    For clarity, rename meta_window_get_outer_rect() to match terminology
    we use elsewhere. The old function is left as a deprecated
    compatibility wrapper.

 doc/reference/meta-sections.txt    |    1 +
 src/compositor/compositor.c        |    2 +-
 src/compositor/meta-window-actor.c |    4 +-
 src/compositor/meta-window-group.c |    2 +-
 src/core/constraints.c             |    8 ++--
 src/core/display.c                 |    4 +-
 src/core/edge-resistance.c         |    8 ++--
 src/core/keybindings.c             |   20 ++++----
 src/core/place.c                   |   86 ++++++++++++++++++------------------
 src/core/screen.c                  |    4 +-
 src/core/stack.c                   |    2 +-
 src/core/window.c                  |   80 +++++++++++++++++++++------------
 src/meta/window.h                  |    4 +-
 13 files changed, 124 insertions(+), 101 deletions(-)
---
diff --git a/doc/reference/meta-sections.txt b/doc/reference/meta-sections.txt
index b87cbfe..90f8152 100644
--- a/doc/reference/meta-sections.txt
+++ b/doc/reference/meta-sections.txt
@@ -541,6 +541,7 @@ meta_window_is_override_redirect
 meta_window_is_skip_taskbar
 meta_window_get_rect
 meta_window_get_input_rect
+meta_window_get_frame_rect
 meta_window_get_outer_rect
 meta_window_client_rect_to_frame_rect
 meta_window_frame_rect_to_client_rect
diff --git a/src/compositor/compositor.c b/src/compositor/compositor.c
index abbe585..daddf77 100644
--- a/src/compositor/compositor.c
+++ b/src/compositor/compositor.c
@@ -749,7 +749,7 @@ meta_shape_cow_for_window (MetaScreen *screen,
       int width, height;
       MetaRectangle rect;
 
-      meta_window_get_outer_rect (metaWindow, &rect);
+      meta_window_get_frame_rect (metaWindow, &rect);
 
       window_bounds.x = rect.x;
       window_bounds.y = rect.y;
diff --git a/src/compositor/meta-window-actor.c b/src/compositor/meta-window-actor.c
index b486be3..f6a8c6e 100644
--- a/src/compositor/meta-window-actor.c
+++ b/src/compositor/meta-window-actor.c
@@ -1939,7 +1939,7 @@ check_needs_pixmap (MetaWindowActor *self)
       if (G_UNLIKELY (!cogl_texture_pixmap_x11_is_using_tfp_extension (COGL_TEXTURE_PIXMAP_X11 (texture))))
         g_warning ("NOTE: Not using GLX TFP!\n");
 
-      /* ::size-changed is supposed to refer to meta_window_get_outer_rect().
+      /* ::size-changed is supposed to refer to meta_window_get_frame_rect().
        * Emitting it here works pretty much OK because a new value of the
        * *input* rect (which is the outer rect with the addition of invisible
        * borders) forces a new pixmap and we get here. In the rare case where
@@ -2035,7 +2035,7 @@ meta_window_actor_process_damage (MetaWindowActor    *self,
   if (meta_window_is_fullscreen (priv->window) && g_list_last (info->windows)->data == self && 
!priv->unredirected)
     {
       MetaRectangle window_rect;
-      meta_window_get_outer_rect (priv->window, &window_rect);
+      meta_window_get_frame_rect (priv->window, &window_rect);
 
       if (window_rect.x == event->area.x &&
           window_rect.y == event->area.y &&
diff --git a/src/compositor/meta-window-group.c b/src/compositor/meta-window-group.c
index 64494e5..7626210 100644
--- a/src/compositor/meta-window-group.c
+++ b/src/compositor/meta-window-group.c
@@ -159,7 +159,7 @@ meta_window_group_paint (ClutterActor *actor)
       cairo_rectangle_int_t unredirected_rect;
       MetaWindow *window = meta_window_actor_get_meta_window (info->unredirected_window);
 
-      meta_window_get_outer_rect (window, (MetaRectangle *)&unredirected_rect);
+      meta_window_get_frame_rect (window, (MetaRectangle *)&unredirected_rect);
       cairo_region_subtract_rectangle (unobscured_region, &unredirected_rect);
       cairo_region_subtract_rectangle (clip_region, &unredirected_rect);
     }
diff --git a/src/core/constraints.c b/src/core/constraints.c
index 97e1e79..302267f 100644
--- a/src/core/constraints.c
+++ b/src/core/constraints.c
@@ -497,7 +497,7 @@ place_window_if_needed(MetaWindow     *window,
       MetaWorkspace *cur_workspace;
       const MetaMonitorInfo *monitor_info;
 
-      meta_window_get_outer_rect (window, &placed_rect);
+      meta_window_get_frame_rect (window, &placed_rect);
       meta_window_place (window, info->orig.x, info->orig.y,
                          &placed_rect.x, &placed_rect.y);
       did_placement = TRUE;
@@ -707,8 +707,8 @@ get_size_limits (MetaWindow    *window,
 
   if (include_frame)
     {
-      meta_window_client_rect_to_outer_rect (window, min_size, min_size);
-      meta_window_client_rect_to_outer_rect (window, max_size, max_size);
+      meta_window_client_rect_to_frame_rect (window, min_size, min_size);
+      meta_window_client_rect_to_frame_rect (window, max_size, max_size);
     }
 }
 
@@ -735,7 +735,7 @@ constrain_modal_dialog (MetaWindow         *window,
   child_rect = info->current;
   extend_by_frame (window, &child_rect);
 
-  meta_window_get_outer_rect (parent, &parent_rect);
+  meta_window_get_frame_rect (parent, &parent_rect);
 
   child_rect.x = parent_rect.x + (parent_rect.width / 2  - child_rect.width / 2);
   child_rect.y = parent_rect.y + (parent_rect.height / 2 - child_rect.height / 2);
diff --git a/src/core/display.c b/src/core/display.c
index 36849a5..33ebc7b 100644
--- a/src/core/display.c
+++ b/src/core/display.c
@@ -1622,7 +1622,7 @@ window_raise_with_delay_callback (void *data)
                                   &root_x, &root_y, &x, &y, &mask);
       meta_error_trap_pop (window->display);
 
-      meta_window_get_outer_rect (window, &frame_rect);
+      meta_window_get_frame_rect (window, &frame_rect);
       point_in_window = POINT_IN_RECT (root_x, root_y, frame_rect);
       if (same_screen && point_in_window)
        meta_window_raise (window);
@@ -2440,7 +2440,7 @@ event_callback (XEvent   *event,
                       MetaRectangle frame_rect;
                       MetaGrabOp op;
 
-                      meta_window_get_outer_rect (window, &frame_rect);
+                      meta_window_get_frame_rect (window, &frame_rect);
 
                       west = device_event->root_x <  (frame_rect.x + 1 * frame_rect.width  / 3);
                       east = device_event->root_x >  (frame_rect.x + 2 * frame_rect.width  / 3);
diff --git a/src/core/edge-resistance.c b/src/core/edge-resistance.c
index 5972002..17cde42 100644
--- a/src/core/edge-resistance.c
+++ b/src/core/edge-resistance.c
@@ -985,7 +985,7 @@ compute_resistance_and_snapping_edges (MetaDisplay *display)
         {
           MetaRectangle *new_rect;
           new_rect = g_new (MetaRectangle, 1);
-          meta_window_get_outer_rect (cur_window, new_rect);
+          meta_window_get_frame_rect (cur_window, new_rect);
           obscuring_windows = g_slist_prepend (obscuring_windows, new_rect);
           window_stacking = 
             g_slist_prepend (window_stacking, GINT_TO_POINTER (stack_position));
@@ -1010,7 +1010,7 @@ compute_resistance_and_snapping_edges (MetaDisplay *display)
     {
       MetaRectangle  cur_rect;
       MetaWindow    *cur_window = cur_window_iter->data;
-      meta_window_get_outer_rect (cur_window, &cur_rect);
+      meta_window_get_frame_rect (cur_window, &cur_rect);
 
       /* Check if we want to use this window's edges for edge
        * resistance (note that dock edges are considered screen edges
@@ -1151,7 +1151,7 @@ meta_window_edge_resistance_for_move (MetaWindow  *window,
   MetaRectangle old_outer, proposed_outer, new_outer;
   gboolean is_resize;
 
-  meta_window_get_outer_rect (window, &old_outer);
+  meta_window_get_frame_rect (window, &old_outer);
 
   proposed_outer = old_outer;
   proposed_outer.x += (*new_x - old_x);
@@ -1237,7 +1237,7 @@ meta_window_edge_resistance_for_resize (MetaWindow  *window,
   int proposed_outer_width, proposed_outer_height;
   gboolean is_resize;
 
-  meta_window_get_outer_rect (window, &old_outer);
+  meta_window_get_frame_rect (window, &old_outer);
   proposed_outer_width  = old_outer.width  + (*new_width  - old_width);
   proposed_outer_height = old_outer.height + (*new_height - old_height);
   meta_rectangle_resize_with_gravity (&old_outer, 
diff --git a/src/core/keybindings.c b/src/core/keybindings.c
index e4355e1..35de8d5 100644
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
@@ -3168,17 +3168,17 @@ handle_move_to_corner_backend (MetaDisplay    *display,
                                gpointer        dummy)
 {
   MetaRectangle work_area;
-  MetaRectangle outer;
+  MetaRectangle frame_rect;
   int orig_x, orig_y;
   int new_x, new_y;
 
   meta_window_get_work_area_all_monitors (window, &work_area);
-  meta_window_get_outer_rect (window, &outer);
+  meta_window_get_frame_rect (window, &frame_rect);
   meta_window_get_position (window, &orig_x, &orig_y);
 
   if (xchange) {
     new_x = work_area.x + (to_right ?
-                           work_area.width - outer.width :
+                           work_area.width - frame_rect.width :
                            0);
   } else {
     new_x = orig_x;
@@ -3186,7 +3186,7 @@ handle_move_to_corner_backend (MetaDisplay    *display,
 
   if (ychange) {
     new_y = work_area.y + (to_bottom ?
-                           work_area.height - outer.height :
+                           work_area.height - frame_rect.height :
                            0);
   } else {
     new_y = orig_y;
@@ -3295,12 +3295,12 @@ handle_move_to_center  (MetaDisplay    *display,
                         gpointer        dummy)
 {
   MetaRectangle work_area;
-  MetaRectangle outer;
+  MetaRectangle frame_rect;
   int orig_x, orig_y;
   int frame_width, frame_height;
 
   meta_window_get_work_area_all_monitors (window, &work_area);
-  meta_window_get_outer_rect (window, &outer);
+  meta_window_get_frame_rect (window, &frame_rect);
   meta_window_get_position (window, &orig_x, &orig_y);
 
   frame_width = (window->frame ? window->frame->child_x : 0);
@@ -3308,8 +3308,8 @@ handle_move_to_center  (MetaDisplay    *display,
 
   meta_window_move_resize (window,
                            TRUE,
-                           work_area.x + (work_area.width +frame_width -outer.width )/2,
-                           work_area.y + (work_area.height+frame_height-outer.height)/2,
+                           work_area.x + (work_area.width +frame_width -frame_rect.width )/2,
+                           work_area.y + (work_area.height+frame_height-frame_rect.height)/2,
                            window->rect.width,
                            window->rect.height);
 }
@@ -4002,8 +4002,8 @@ handle_raise_or_lower (MetaDisplay    *display,
 
       if (above->mapped)
         {
-          meta_window_get_outer_rect (window, &win_rect);
-          meta_window_get_outer_rect (above, &above_rect);
+          meta_window_get_frame_rect (window, &win_rect);
+          meta_window_get_frame_rect (above, &above_rect);
 
           /* Check if obscured */
           if (meta_rectangle_intersect (&win_rect, &above_rect, &tmp))
diff --git a/src/core/place.c b/src/core/place.c
index a2c7df3..821fca0 100644
--- a/src/core/place.c
+++ b/src/core/place.c
@@ -53,8 +53,8 @@ northwestcmp (gconstpointer a, gconstpointer b)
   int from_origin_b;
   int ax, ay, bx, by;
 
-  meta_window_get_outer_rect (aw, &a_frame);
-  meta_window_get_outer_rect (bw, &b_frame);
+  meta_window_get_frame_rect (aw, &a_frame);
+  meta_window_get_frame_rect (bw, &b_frame);
   ax = a_frame.x;
   ay = a_frame.y;
   bx = b_frame.x;
@@ -131,7 +131,7 @@ find_next_cascade (MetaWindow *window,
   
   /* Find first cascade position that's not used. */
 
-  meta_window_get_outer_rect (window, &frame_rect);
+  meta_window_get_frame_rect (window, &frame_rect);
   window_width = frame_rect.width;
   window_height = frame_rect.height;
   
@@ -146,7 +146,7 @@ find_next_cascade (MetaWindow *window,
       w = tmp->data;
 
       /* we want frame position, not window position */
-      meta_window_get_outer_rect (w, &w_frame_rect);
+      meta_window_get_frame_rect (w, &w_frame_rect);
       wx = w_frame_rect.x;
       wy = w_frame_rect.y;
       
@@ -224,23 +224,23 @@ find_most_freespace (MetaWindow *window,
   int left_space, right_space, top_space, bottom_space;
   MetaRectangle work_area;
   MetaRectangle avoid;
-  MetaRectangle outer;
+  MetaRectangle frame_rect;
 
   meta_window_get_work_area_current_monitor (focus_window, &work_area);
-  meta_window_get_outer_rect (focus_window, &avoid);
-  meta_window_get_outer_rect (window, &outer);
+  meta_window_get_frame_rect (focus_window, &avoid);
+  meta_window_get_frame_rect (window, &frame_rect);
 
   /* Find the areas of choosing the various sides of the focus window */
-  max_width  = MIN (avoid.width, outer.width);
-  max_height = MIN (avoid.height, outer.height);
+  max_width  = MIN (avoid.width, frame_rect.width);
+  max_height = MIN (avoid.height, frame_rect.height);
   left_space   = avoid.x - work_area.x;
   right_space  = work_area.width - (avoid.x + avoid.width - work_area.x);
   top_space    = avoid.y - work_area.y;
   bottom_space = work_area.height - (avoid.y + avoid.height - work_area.y);
-  left   = MIN (left_space,   outer.width);
-  right  = MIN (right_space,  outer.width);
-  top    = MIN (top_space,    outer.height);
-  bottom = MIN (bottom_space, outer.height);
+  left   = MIN (left_space,   frame_rect.width);
+  right  = MIN (right_space,  frame_rect.width);
+  top    = MIN (top_space,    frame_rect.height);
+  bottom = MIN (bottom_space, frame_rect.height);
 
   /* Find out which side of the focus_window can show the most of the window */
   side = META_LEFT;
@@ -273,31 +273,31 @@ find_most_freespace (MetaWindow *window,
     {
     case META_LEFT:
       *new_y = avoid.y;
-      if (left_space > outer.width)
-        *new_x = avoid.x - outer.width;
+      if (left_space > frame_rect.width)
+        *new_x = avoid.x - frame_rect.width;
       else
         *new_x = work_area.x;
       break;
     case META_RIGHT:
       *new_y = avoid.y;
-      if (right_space > outer.width)
+      if (right_space > frame_rect.width)
         *new_x = avoid.x + avoid.width;
       else
-        *new_x = work_area.x + work_area.width - outer.width;
+        *new_x = work_area.x + work_area.width - frame_rect.width;
       break;
     case META_TOP:
       *new_x = avoid.x;
-      if (top_space > outer.height)
-        *new_y = avoid.y - outer.height;
+      if (top_space > frame_rect.height)
+        *new_y = avoid.y - frame_rect.height;
       else
         *new_y = work_area.y;
       break;
     case META_BOTTOM:
       *new_x = avoid.x;
-      if (bottom_space > outer.height)
+      if (bottom_space > frame_rect.height)
         *new_y = avoid.y + avoid.height;
       else
-        *new_y = work_area.y + work_area.height - outer.height;
+        *new_y = work_area.y + work_area.height - frame_rect.height;
       break;
     }
 }
@@ -312,8 +312,8 @@ window_overlaps_focus_window (MetaWindow *window)
   if (focus_window == NULL)
     return FALSE;
 
-  meta_window_get_outer_rect (window, &window_frame);
-  meta_window_get_outer_rect (focus_window, &focus_frame);
+  meta_window_get_frame_rect (window, &window_frame);
+  meta_window_get_frame_rect (focus_window, &focus_frame);
 
   return meta_rectangle_intersect (&window_frame,
                                    &focus_frame,
@@ -393,7 +393,7 @@ rectangle_overlaps_some_window (MetaRectangle *rect,
         case META_WINDOW_UTILITY:
         case META_WINDOW_TOOLBAR:
         case META_WINDOW_MENU:
-          meta_window_get_outer_rect (other, &other_rect);
+          meta_window_get_frame_rect (other, &other_rect);
           
           if (meta_rectangle_intersect (rect, &other_rect, &dest))
             return TRUE;
@@ -415,8 +415,8 @@ leftmost_cmp (gconstpointer a, gconstpointer b)
   MetaRectangle b_frame;
   int ax, bx;
 
-  meta_window_get_outer_rect (aw, &a_frame);
-  meta_window_get_outer_rect (bw, &b_frame);
+  meta_window_get_frame_rect (aw, &a_frame);
+  meta_window_get_frame_rect (bw, &b_frame);
   ax = a_frame.x;
   bx = b_frame.x;
 
@@ -437,8 +437,8 @@ topmost_cmp (gconstpointer a, gconstpointer b)
   MetaRectangle b_frame;
   int ay, by;
 
-  meta_window_get_outer_rect (aw, &a_frame);
-  meta_window_get_outer_rect (bw, &b_frame);
+  meta_window_get_frame_rect (aw, &a_frame);
+  meta_window_get_frame_rect (bw, &b_frame);
   ay = a_frame.y;
   by = b_frame.y;
 
@@ -512,7 +512,7 @@ find_first_fit (MetaWindow *window,
   right_sorted = g_list_sort (right_sorted, topmost_cmp);
   right_sorted = g_list_sort (right_sorted, leftmost_cmp);
 
-  meta_window_get_outer_rect (window, &rect);
+  meta_window_get_frame_rect (window, &rect);
 
 #ifdef WITH_VERBOSE_MODE
     {
@@ -545,12 +545,12 @@ find_first_fit (MetaWindow *window,
     while (tmp != NULL)
       {
         MetaWindow *w = tmp->data;
-        MetaRectangle outer_rect;
+        MetaRectangle frame_rect;
 
-        meta_window_get_outer_rect (w, &outer_rect);
+        meta_window_get_frame_rect (w, &frame_rect);
       
-        rect.x = outer_rect.x;
-        rect.y = outer_rect.y + outer_rect.height;
+        rect.x = frame_rect.x;
+        rect.y = frame_rect.y + frame_rect.height;
       
         if (meta_rectangle_contains_rect (&work_area, &rect) &&
             !rectangle_overlaps_some_window (&rect, below_sorted))
@@ -571,12 +571,12 @@ find_first_fit (MetaWindow *window,
     while (tmp != NULL)
       {
         MetaWindow *w = tmp->data;
-        MetaRectangle outer_rect;
+        MetaRectangle frame_rect;
    
-        meta_window_get_outer_rect (w, &outer_rect);
+        meta_window_get_frame_rect (w, &frame_rect);
      
-        rect.x = outer_rect.x + outer_rect.width;
-        rect.y = outer_rect.y;
+        rect.x = frame_rect.x + frame_rect.width;
+        rect.y = frame_rect.y;
    
         if (meta_rectangle_contains_rect (&work_area, &rect) &&
             !rectangle_overlaps_some_window (&rect, right_sorted))
@@ -718,8 +718,8 @@ meta_window_place (MetaWindow        *window,
         {
           MetaRectangle frame_rect, parent_frame_rect;
 
-          meta_window_get_outer_rect (window, &frame_rect);
-          meta_window_get_outer_rect (parent, &parent_frame_rect);
+          meta_window_get_frame_rect (window, &frame_rect);
+          meta_window_get_frame_rect (parent, &parent_frame_rect);
 
           y = parent_frame_rect.y;
 
@@ -754,7 +754,7 @@ meta_window_place (MetaWindow        *window,
       int w, h;
       MetaRectangle frame_rect;
 
-      meta_window_get_outer_rect (window, &frame_rect);
+      meta_window_get_frame_rect (window, &frame_rect);
 
       /* Warning, this function is a round trip! */
       xi = meta_screen_get_current_monitor_info (window->screen);
@@ -820,17 +820,17 @@ meta_window_place (MetaWindow        *window,
       !window->fullscreen)
     {
       MetaRectangle workarea;
-      MetaRectangle outer;
+      MetaRectangle frame_rect;
 
       meta_window_get_work_area_for_monitor (window,
                                              xi->number,
                                              &workarea);      
-      meta_window_get_outer_rect (window, &outer);
+      meta_window_get_frame_rect (window, &frame_rect);
       
       /* If the window is bigger than the screen, then automaximize.  Do NOT
        * auto-maximize the directions independently.  See #419810.
        */
-      if (outer.width >= workarea.width && outer.height >= workarea.height)
+      if (frame_rect.width >= workarea.width && frame_rect.height >= workarea.height)
         {
           window->maximize_horizontally_after_placement = TRUE;
           window->maximize_vertically_after_placement = TRUE;
diff --git a/src/core/screen.c b/src/core/screen.c
index e07e5b3..fc0c3ae 100644
--- a/src/core/screen.c
+++ b/src/core/screen.c
@@ -1528,7 +1528,7 @@ meta_screen_tab_popup_create (MetaScreen      *screen,
       if (show_type == META_TAB_SHOW_INSTANTLY ||
           !entries[i].hidden                   ||
           !meta_window_get_icon_geometry (window, &r))
-        meta_window_get_outer_rect (window, &r);
+        meta_window_get_frame_rect (window, &r);
 
       entries[i].rect = r;
 
@@ -1911,7 +1911,7 @@ meta_screen_get_monitor_for_window (MetaScreen *screen,
 {
   MetaRectangle window_rect;
   
-  meta_window_get_outer_rect (window, &window_rect);
+  meta_window_get_frame_rect (window, &window_rect);
 
   return meta_screen_get_monitor_for_rect (screen, &window_rect);
 }
diff --git a/src/core/stack.c b/src/core/stack.c
index da7445f..26d3c20 100644
--- a/src/core/stack.c
+++ b/src/core/stack.c
@@ -1465,7 +1465,7 @@ window_contains_point (MetaWindow *window,
 {
   MetaRectangle rect;
 
-  meta_window_get_outer_rect (window, &rect);
+  meta_window_get_frame_rect (window, &rect);
 
   return POINT_IN_RECT (root_x, root_y, rect);
 }
diff --git a/src/core/window.c b/src/core/window.c
index 682819f..270f1fa 100644
--- a/src/core/window.c
+++ b/src/core/window.c
@@ -2792,8 +2792,8 @@ static gboolean
 windows_overlap (const MetaWindow *w1, const MetaWindow *w2)
 {
   MetaRectangle w1rect, w2rect;
-  meta_window_get_outer_rect (w1, &w1rect);
-  meta_window_get_outer_rect (w2, &w2rect);
+  meta_window_get_frame_rect (w1, &w1rect);
+  meta_window_get_frame_rect (w2, &w2rect);
   return meta_rectangle_overlap (&w1rect, &w2rect);
 }
 
@@ -3594,11 +3594,11 @@ meta_window_maximize (MetaWindow        *window,
           MetaRectangle old_rect;
          MetaRectangle new_rect;
 
-         meta_window_get_outer_rect (window, &old_rect);
+         meta_window_get_frame_rect (window, &old_rect);
 
           meta_window_move_resize_now (window);
 
-         meta_window_get_outer_rect (window, &new_rect);
+         meta_window_get_frame_rect (window, &new_rect);
           meta_compositor_maximize_window (window->display->compositor,
                                            window,
                                            &old_rect,
@@ -3657,7 +3657,7 @@ meta_window_get_all_monitors (MetaWindow *window, gsize *length)
   int i;
 
   monitors = g_array_new (FALSE, FALSE, sizeof (int));
-  meta_window_get_outer_rect (window, &window_rect);
+  meta_window_get_frame_rect (window, &window_rect);
 
   for (i = 0; i < window->screen->n_monitor_infos; i++)
     {
@@ -3690,7 +3690,7 @@ meta_window_is_screen_sized (MetaWindow *window)
   int screen_width, screen_height;
 
   meta_screen_get_size (window->screen, &screen_width, &screen_height);
-  meta_window_get_outer_rect (window, &window_rect);
+  meta_window_get_frame_rect (window, &window_rect);
 
   if (window_rect.x == 0 && window_rect.y == 0 &&
       window_rect.width == screen_width && window_rect.height == screen_height)
@@ -3719,7 +3719,7 @@ meta_window_is_monitor_sized (MetaWindow *window)
     {
       MetaRectangle window_rect, monitor_rect;
 
-      meta_window_get_outer_rect (window, &window_rect);
+      meta_window_get_frame_rect (window, &window_rect);
       meta_screen_get_monitor_geometry (window->screen, window->monitor->number, &monitor_rect);
 
       if (meta_rectangle_equal (&window_rect, &monitor_rect))
@@ -3787,11 +3787,11 @@ meta_window_tile (MetaWindow *window)
       MetaRectangle old_rect;
       MetaRectangle new_rect;
 
-      meta_window_get_outer_rect (window, &old_rect);
+      meta_window_get_frame_rect (window, &old_rect);
 
       meta_window_move_resize_now (window);
 
-      meta_window_get_outer_rect (window, &new_rect);
+      meta_window_get_frame_rect (window, &new_rect);
       meta_compositor_maximize_window (window->display->compositor,
                                        window,
                                        &old_rect,
@@ -3959,7 +3959,7 @@ meta_window_unmaximize_internal (MetaWindow        *window,
         {
           MetaRectangle old_rect, new_rect;
 
-         meta_window_get_outer_rect (window, &old_rect);
+         meta_window_get_frame_rect (window, &old_rect);
 
           meta_window_move_resize_internal (window,
                                             META_IS_MOVE_ACTION | META_IS_RESIZE_ACTION,
@@ -3969,7 +3969,7 @@ meta_window_unmaximize_internal (MetaWindow        *window,
                                             target_rect.width,
                                             target_rect.height);
 
-         meta_window_get_outer_rect (window, &new_rect);
+         meta_window_get_frame_rect (window, &new_rect);
           meta_compositor_unmaximize_window (window->display->compositor,
                                             window,
                                              &old_rect,
@@ -5856,16 +5856,17 @@ meta_window_frame_rect_to_client_rect (MetaWindow    *window,
 }
 
 /**
- * meta_window_get_outer_rect:
+ * meta_window_get_frame_rect:
  * @window: a #MetaWindow
  * @rect: (out): pointer to an allocated #MetaRectangle
  *
- * Gets the rectangle that bounds @window that is responsive to mouse events.
- * This includes only what is visible; it doesn't include any extra reactive
- * area we add to the edges of windows.
+ * Gets the rectangle that bounds @window that is what the user thinks of
+ * as the edge of the window. This doesn't include any extra reactive
+ * area that we or the client adds to the window, or any area that the
+ * client adds to draw a client-side shadow.
  */
 void
-meta_window_get_outer_rect (const MetaWindow *window,
+meta_window_get_frame_rect (const MetaWindow *window,
                             MetaRectangle    *rect)
 {
   if (window->frame)
@@ -5894,6 +5895,25 @@ meta_window_get_outer_rect (const MetaWindow *window,
     }
 }
 
+/**
+ * meta_window_get_outer_rect:
+ * @window: a #MetaWindow
+ * @rect: (out): pointer to an allocated #MetaRectangle
+ *
+ * Gets the rectangle that bounds @window that is what the user thinks of
+ * as the edge of the window. This doesn't include any extra reactive
+ * area that we or the client adds to the window, or any area that the
+ * client adds to draw a client-side shadow.
+ *
+ * Deprecated: 3.10: Use meta_window_get_frame_rect() instead.
+ */
+void
+meta_window_get_outer_rect (const MetaWindow *window,
+                            MetaRectangle    *rect)
+{
+  meta_window_get_frame_rect (window, rect);
+}
+
 const char*
 meta_window_get_startup_id (MetaWindow *window)
 {
@@ -8962,7 +8982,7 @@ meta_window_show_menu (MetaWindow *window,
 void
 meta_window_shove_titlebar_onscreen (MetaWindow *window)
 {
-  MetaRectangle  outer_rect;
+  MetaRectangle  frame_rect;
   GList         *onscreen_region;
   int            horiz_amount, vert_amount;
   int            newx, newy;
@@ -8974,15 +8994,15 @@ meta_window_shove_titlebar_onscreen (MetaWindow *window)
     return;
 
   /* Get the basic info we need */
-  meta_window_get_outer_rect (window, &outer_rect);
+  meta_window_get_frame_rect (window, &frame_rect);
   onscreen_region = window->screen->active_workspace->screen_region;
 
   /* Extend the region (just in case the window is too big to fit on the
    * screen), then shove the window on screen, then return the region to
    * normal.
    */
-  horiz_amount = outer_rect.width;
-  vert_amount  = outer_rect.height;
+  horiz_amount = frame_rect.width;
+  vert_amount  = frame_rect.height;
   meta_rectangle_expand_region (onscreen_region,
                                 horiz_amount,
                                 horiz_amount,
@@ -8990,15 +9010,15 @@ meta_window_shove_titlebar_onscreen (MetaWindow *window)
                                 vert_amount);
   meta_rectangle_shove_into_region(onscreen_region,
                                    FIXED_DIRECTION_X,
-                                   &outer_rect);
+                                   &frame_rect);
   meta_rectangle_expand_region (onscreen_region,
                                 -horiz_amount,
                                 -horiz_amount,
                                 0,
                                 -vert_amount);
 
-  newx = outer_rect.x + window->frame->child_x;
-  newy = outer_rect.y + window->frame->child_y;
+  newx = frame_rect.x + window->frame->child_x;
+  newy = frame_rect.y + window->frame->child_y;
   meta_window_move_resize (window,
                            FALSE,
                            newx,
@@ -9023,7 +9043,7 @@ meta_window_titlebar_is_onscreen (MetaWindow *window)
     return FALSE;
 
   /* Get the rectangle corresponding to the titlebar */
-  meta_window_get_outer_rect (window, &titlebar_rect);
+  meta_window_get_frame_rect (window, &titlebar_rect);
   titlebar_rect.height = window->frame->child_y;
 
   /* Run through the spanning rectangles for the screen and see if one of
@@ -10325,7 +10345,7 @@ warp_grab_pointer (MetaWindow          *window,
   /* We may not have done begin_grab_op yet, i.e. may not be in a grab
    */
 
-  meta_window_get_outer_rect (window, &rect);
+  meta_window_get_frame_rect (window, &rect);
 
   switch (grab_op)
     {
@@ -10664,7 +10684,7 @@ meta_window_set_demands_attention (MetaWindow *window)
     }
   else
     {
-      meta_window_get_outer_rect (window, &candidate_rect);
+      meta_window_get_frame_rect (window, &candidate_rect);
 
       /* The stack is sorted with the top windows first. */
 
@@ -10675,7 +10695,7 @@ meta_window_set_demands_attention (MetaWindow *window)
 
           if (meta_window_located_on_workspace (other_window, window->workspace))
             {
-              meta_window_get_outer_rect (other_window, &other_rect);
+              meta_window_get_frame_rect (other_window, &other_rect);
 
               if (meta_rectangle_overlap (&candidate_rect, &other_rect))
                 {
@@ -11379,8 +11399,8 @@ meta_window_compute_tile_match (MetaWindow *window)
           bottommost = match;
         }
 
-      meta_window_get_outer_rect (bottommost, &bottommost_rect);
-      meta_window_get_outer_rect (topmost, &topmost_rect);
+      meta_window_get_frame_rect (bottommost, &bottommost_rect);
+      meta_window_get_frame_rect (topmost, &topmost_rect);
       /*
        * If there's a window stacked in between which is partially visible
        * behind the topmost tile we don't consider the tiles to match.
@@ -11394,7 +11414,7 @@ meta_window_compute_tile_match (MetaWindow *window)
               meta_window_get_workspace (above) != meta_window_get_workspace (window))
             continue;
 
-          meta_window_get_outer_rect (above, &above_rect);
+          meta_window_get_frame_rect (above, &above_rect);
 
           if (meta_rectangle_overlap (&above_rect, &bottommost_rect) &&
               meta_rectangle_overlap (&above_rect, &topmost_rect))
diff --git a/src/meta/window.h b/src/meta/window.h
index 3efd261..66cdfad 100644
--- a/src/meta/window.h
+++ b/src/meta/window.h
@@ -100,7 +100,9 @@ gboolean meta_window_is_override_redirect (MetaWindow *window);
 gboolean meta_window_is_skip_taskbar (MetaWindow *window);
 MetaRectangle *meta_window_get_rect (MetaWindow *window);
 void meta_window_get_input_rect (const MetaWindow *window, MetaRectangle *rect);
-void meta_window_get_outer_rect (const MetaWindow *window, MetaRectangle *rect);
+
+void meta_window_get_frame_rect (const MetaWindow *window, MetaRectangle *rect);
+void meta_window_get_outer_rect (const MetaWindow *window, MetaRectangle *rect) G_GNUC_DEPRECATED;
 
 void meta_window_client_rect_to_frame_rect (MetaWindow    *window,
                                             MetaRectangle *frame_rect,