x11_util: Added GetInnerWindowBounds and GetWindowExtents.

ui/base/x/x11_util.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file defines utility functions for X11 (Linux only). This code has been
 // ported from XCB since we can't use XCB on Ubuntu while its 32-bit support
 // remains woefully incomplete.
 
 #include "ui/base/x/x11_util.h"
 
@@ skipping 25 matching lines @@
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkPostConfig.h"
 #include "ui/base/x/x11_menu_list.h"
 #include "ui/base/x/x11_util_internal.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #include "ui/events/x/device_data_manager_x11.h"
 #include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/canvas.h"
+#include "ui/gfx/geometry/insets.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/point_conversions.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_rep.h"
-#include "ui/gfx/point.h"
-#include "ui/gfx/point_conversions.h"
-#include "ui/gfx/rect.h"
-#include "ui/gfx/size.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/x/x11_error_tracker.h"
 
 #if defined(OS_FREEBSD)
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #endif
 
 namespace ui {
 
@@ skipping 511 matching lines @@
       32,  // size in bits
       PropModeReplace,
       reinterpret_cast<unsigned char*>(&hide),
       1);
 }
 
 void ClearX11DefaultRootWindow() {
   XDisplay* display = gfx::GetXDisplay();
   XID root_window = GetX11RootWindow();
   gfx::Rect root_bounds;
-  if (!GetWindowRect(root_window, &root_bounds)) {
+  if (!GetOuterWindowBounds(root_window, &root_bounds)) {
     LOG(ERROR) << "Failed to get the bounds of the X11 root window";
     return;
   }
 
   XGCValues gc_values = {0};
   gc_values.foreground = BlackPixel(display, DefaultScreen(display));
   GC gc = XCreateGC(display, root_window, GCForeground, &gc_values);
   XFillRectangle(display, root_window, gc,
                  root_bounds.x(),
                  root_bounds.y(),
@@ skipping 23 matching lines @@
 
   // Some compositing window managers (notably kwin) do not actually unmap
   // windows on desktop switch, so we also must check the current desktop.
   int window_desktop, current_desktop;
   return (!GetWindowDesktop(window, &window_desktop) ||
           !GetCurrentDesktop(&current_desktop) ||
           window_desktop == kAllDesktops ||
           window_desktop == current_desktop);
 }
 
-bool GetWindowRect(XID window, gfx::Rect* rect) {
+bool GetInnerWindowBounds(XID window, gfx::Rect* rect) {
   Window root, child;
   int x, y;
   unsigned int width, height;
   unsigned int border_width, depth;
 
   if (!XGetGeometry(gfx::GetXDisplay(), window, &root, &x, &y,
                     &width, &height, &border_width, &depth))
     return false;
 
   if (!XTranslateCoordinates(gfx::GetXDisplay(), window, root,
                              0, 0, &x, &y, &child))
     return false;
 
   *rect = gfx::Rect(x, y, width, height);
 
+  return true;
+}
+
+bool GetWindowExtents(XID window, gfx::Insets* extents) {
   std::vector<int> insets;
-  if (GetIntArrayProperty(window, "_NET_FRAME_EXTENTS", &insets) &&
-      insets.size() == 4) {
-    rect->Inset(-insets[0], -insets[2], -insets[1], -insets[3]);
-  }
+  if (!GetIntArrayProperty(window, "_NET_FRAME_EXTENTS", &insets))
+    return false;
+  if (insets.size() != 4)
+    return false;
+
+  int left = insets[0];
+  int right = insets[1];
+  int top = insets[2];
+  int bottom = insets[3];
+  extents->Set(-top, -left, -bottom, -right);
+  return true;
+}
+
+bool GetOuterWindowBounds(XID window, gfx::Rect* rect) {
+  if (!GetInnerWindowBounds(window, rect))
+    return false;
+
+  gfx::Insets extents;
+  if (GetWindowExtents(window, &extents))
+    rect->Inset(extents);
   // Not all window managers support _NET_FRAME_EXTENTS so return true even if
   // requesting the property fails.
 
   return true;
 }
 
 
 bool WindowContainsPoint(XID window, gfx::Point screen_loc) {
   TRACE_EVENT0("ui", "WindowContainsPoint");
 
   gfx::Rect window_rect;
-  if (!GetWindowRect(window, &window_rect))
+  if (!GetOuterWindowBounds(window, &window_rect))
     return false;
 
   if (!window_rect.Contains(screen_loc))
     return false;
 
   if (!IsShapeExtensionAvailable())
     return true;
 
   // According to http://www.x.org/releases/X11R7.6/doc/libXext/shapelib.html,
   // if an X display supports the shape extension the bounds of a window are
@@ skipping 620 matching lines @@
                              "_NET_WM_STATE",
                              &atom_properties)) {
       return std::find(atom_properties.begin(),
                        atom_properties.end(),
                        fullscreen_atom) !=
           atom_properties.end();
     }
   }
 
   gfx::Rect window_rect;
-  if (!ui::GetWindowRect(window, &window_rect))
+  if (!ui::GetOuterWindowBounds(window, &window_rect))
     return false;
 
   // We can't use gfx::Screen here because we don't have an aura::Window. So
   // instead just look at the size of the default display.
   //
   // TODO(erg): Actually doing this correctly would require pulling out xrandr,
   // which we don't even do in the desktop screen yet.
   ::XDisplay* display = gfx::GetXDisplay();
   ::Screen* screen = DefaultScreenOfDisplay(display);
   int width = WidthOfScreen(screen);
@@ skipping 161 matching lines @@
       << "request_code " << static_cast<int>(error_event.request_code) << ", "
       << "minor_code " << static_cast<int>(error_event.minor_code)
       << " (" << request_str << ")";
 }
 
 // ----------------------------------------------------------------------------
 // End of x11_util_internal.h
 
 
 }  // namespace ui