src/ui/views/widget/desktop_aura/x11_topmost_window_finder_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/views/widget/desktop_aura/x11_topmost_window_finder.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9 #include <X11/extensions/shape.h>
  10 #include <X11/Xlib.h>
  11 #include <X11/Xregion.h>
  12
  13 // Get rid of X11 macros which conflict with gtest.
  14 #undef Bool
  15 #undef None
  16
  17 #include "base/memory/scoped_ptr.h"
  18 #include "third_party/skia/include/core/SkRect.h"
  19 #include "third_party/skia/include/core/SkRegion.h"
  20 #include "ui/aura/window.h"
  21 #include "ui/aura/window_tree_host.h"
  22 #include "ui/events/platform/x11/x11_event_source.h"
  23 #include "ui/gfx/path.h"
  24 #include "ui/gfx/path_x11.h"
  25 #include "ui/gfx/x/x11_atom_cache.h"
  26 #include "ui/views/test/views_test_base.h"
  27 #include "ui/views/test/x11_property_change_waiter.h"
  28 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
  29 #include "ui/views/widget/desktop_aura/x11_desktop_handler.h"
  30 #include "ui/views/widget/widget.h"
  31
  32 namespace views {
  33
  34 namespace {
  35
  36 // Waits till |window| is minimized.
  37 class MinimizeWaiter : public X11PropertyChangeWaiter {
  38  public:
  39   explicit MinimizeWaiter(XID window)
  40       : X11PropertyChangeWaiter(window, "_NET_WM_STATE") {
  41     const char* kAtomsToCache[] = { "_NET_WM_STATE_HIDDEN", NULL };
  42     atom_cache_.reset(new ui::X11AtomCache(gfx::GetXDisplay(), kAtomsToCache));
  43   }
  44
  45   virtual ~MinimizeWaiter() {
  46   }
  47
  48  private:
  49   // X11PropertyChangeWaiter:
  50   virtual bool ShouldKeepOnWaiting(const ui::PlatformEvent& event) OVERRIDE {
  51     std::vector<Atom> wm_states;
  52     if (ui::GetAtomArrayProperty(xwindow(), "_NET_WM_STATE", &wm_states)) {
  53       std::vector<Atom>::iterator it = std::find(
  54           wm_states.begin(),
  55           wm_states.end(),
  56           atom_cache_->GetAtom("_NET_WM_STATE_HIDDEN"));
  57       return it == wm_states.end();
  58     }
  59     return true;
  60   }
  61
  62   scoped_ptr<ui::X11AtomCache> atom_cache_;
  63
  64   DISALLOW_COPY_AND_ASSIGN(MinimizeWaiter);
  65 };
  66
  67 // Waits till |_NET_CLIENT_LIST_STACKING| is updated to include
  68 // |expected_windows|.
  69 class StackingClientListWaiter : public X11PropertyChangeWaiter {
  70  public:
  71   StackingClientListWaiter(XID* expected_windows, size_t count)
  72       : X11PropertyChangeWaiter(ui::GetX11RootWindow(),
  73                                 "_NET_CLIENT_LIST_STACKING"),
  74         expected_windows_(expected_windows, expected_windows + count) {
  75   }
  76
  77   virtual ~StackingClientListWaiter() {
  78   }
  79
  80   // X11PropertyChangeWaiter:
  81   virtual void Wait() OVERRIDE {
  82     // StackingClientListWaiter may be created after
  83     // _NET_CLIENT_LIST_STACKING already contains |expected_windows|.
  84     if (!ShouldKeepOnWaiting(NULL))
  85       return;
  86
  87     X11PropertyChangeWaiter::Wait();
  88   }
  89
  90  private:
  91   // X11PropertyChangeWaiter:
  92   virtual bool ShouldKeepOnWaiting(const ui::PlatformEvent& event) OVERRIDE {
  93     std::vector<XID> stack;
  94     ui::GetXWindowStack(ui::GetX11RootWindow(), &stack);
  95     for (size_t i = 0; i < expected_windows_.size(); ++i) {
  96       std::vector<XID>::iterator it = std::find(
  97           stack.begin(), stack.end(), expected_windows_[i]);
  98       if (it == stack.end())
  99         return true;
 100     }
 101     return false;
 102   }
 103
 104   std::vector<XID> expected_windows_;
 105
 106   DISALLOW_COPY_AND_ASSIGN(StackingClientListWaiter);
 107 };
 108
 109 }  // namespace
 110
 111 class X11TopmostWindowFinderTest : public ViewsTestBase {
 112  public:
 113   X11TopmostWindowFinderTest() {
 114   }
 115
 116   virtual ~X11TopmostWindowFinderTest() {
 117   }
 118
 119   // Creates and shows a Widget with |bounds|. The caller takes ownership of
 120   // the returned widget.
 121   scoped_ptr<Widget> CreateAndShowWidget(const gfx::Rect& bounds) {
 122     scoped_ptr<Widget> toplevel(new Widget);
 123     Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_WINDOW);
 124     params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 125     params.native_widget = new DesktopNativeWidgetAura(toplevel.get());
 126     params.bounds = bounds;
 127     params.remove_standard_frame = true;
 128     toplevel->Init(params);
 129     toplevel->Show();
 130     return toplevel.Pass();
 131   }
 132
 133   // Creates and shows an X window with |bounds|.
 134   XID CreateAndShowXWindow(const gfx::Rect& bounds) {
 135     XID root = DefaultRootWindow(xdisplay());
 136     XID xid = XCreateSimpleWindow(xdisplay(),
 137                                   root,
 138                                   0, 0, 1, 1,
 139                                   0,   // border_width
 140                                   0,   // border
 141                                   0);  // background
 142
 143     ui::SetUseOSWindowFrame(xid, false);
 144     ShowAndSetXWindowBounds(xid, bounds);
 145     return xid;
 146   }
 147
 148   // Shows |xid| and sets its bounds.
 149   void ShowAndSetXWindowBounds(XID xid, const gfx::Rect& bounds) {
 150     XMapWindow(xdisplay(), xid);
 151
 152     XWindowChanges changes = {0};
 153     changes.x = bounds.x();
 154     changes.y = bounds.y();
 155     changes.width = bounds.width();
 156     changes.height = bounds.height();
 157     XConfigureWindow(xdisplay(),
 158                      xid,
 159                      CWX | CWY | CWWidth | CWHeight,
 160                      &changes);
 161   }
 162
 163   Display* xdisplay() {
 164     return gfx::GetXDisplay();
 165   }
 166
 167   // Returns the topmost X window at the passed in screen position.
 168   XID FindTopmostXWindowAt(int screen_x, int screen_y) {
 169     X11TopmostWindowFinder finder;
 170     return finder.FindWindowAt(gfx::Point(screen_x, screen_y));
 171   }
 172
 173   // Returns the topmost aura::Window at the passed in screen position. Returns
 174   // NULL if the topmost window does not have an associated aura::Window.
 175   aura::Window* FindTopmostLocalProcessWindowAt(int screen_x, int screen_y) {
 176     X11TopmostWindowFinder finder;
 177     return finder.FindLocalProcessWindowAt(gfx::Point(screen_x, screen_y),
 178                                            std::set<aura::Window*>());
 179   }
 180
 181   // Returns the topmost aura::Window at the passed in screen position ignoring
 182   // |ignore_window|. Returns NULL if the topmost window does not have an
 183   // associated aura::Window.
 184   aura::Window* FindTopmostLocalProcessWindowWithIgnore(
 185       int screen_x,
 186       int screen_y,
 187       aura::Window* ignore_window) {
 188     std::set<aura::Window*> ignore;
 189     ignore.insert(ignore_window);
 190     X11TopmostWindowFinder finder;
 191     return finder.FindLocalProcessWindowAt(gfx::Point(screen_x, screen_y),
 192                                            ignore);
 193   }
 194
 195   // ViewsTestBase:
 196   virtual void SetUp() OVERRIDE {
 197     ViewsTestBase::SetUp();
 198
 199     // Make X11 synchronous for our display connection. This does not force the
 200     // window manager to behave synchronously.
 201     XSynchronize(xdisplay(), True);
 202
 203     // Ensure that the X11DesktopHandler exists. The X11DesktopHandler is
 204     // necessary to properly track menu windows.
 205     X11DesktopHandler::get();
 206   }
 207
 208   virtual void TearDown() OVERRIDE {
 209     XSynchronize(xdisplay(), False);
 210     ViewsTestBase::TearDown();
 211   }
 212
 213  private:
 214   DISALLOW_COPY_AND_ASSIGN(X11TopmostWindowFinderTest);
 215 };
 216
 217 TEST_F(X11TopmostWindowFinderTest, Basic) {
 218   // Avoid positioning test windows at 0x0 because window managers often have a
 219   // panel/launcher along one of the screen edges and do not allow windows to
 220   // position themselves to overlap the panel/launcher.
 221   scoped_ptr<Widget> widget1(
 222       CreateAndShowWidget(gfx::Rect(100, 100, 200, 100)));
 223   aura::Window* window1 = widget1->GetNativeWindow();
 224   XID xid1 = window1->GetHost()->GetAcceleratedWidget();
 225
 226   XID xid2 = CreateAndShowXWindow(gfx::Rect(200, 100, 100, 200));
 227
 228   scoped_ptr<Widget> widget3(
 229       CreateAndShowWidget(gfx::Rect(100, 190, 200, 110)));
 230   aura::Window* window3 = widget3->GetNativeWindow();
 231   XID xid3 = window3->GetHost()->GetAcceleratedWidget();
 232
 233   XID xids[] = { xid1, xid2, xid3 };
 234   StackingClientListWaiter waiter(xids, arraysize(xids));
 235   waiter.Wait();
 236   ui::X11EventSource::GetInstance()->DispatchXEvents();
 237
 238   EXPECT_EQ(xid1, FindTopmostXWindowAt(150, 150));
 239   EXPECT_EQ(window1, FindTopmostLocalProcessWindowAt(150, 150));
 240
 241   EXPECT_EQ(xid2, FindTopmostXWindowAt(250, 150));
 242   EXPECT_EQ(NULL, FindTopmostLocalProcessWindowAt(250, 150));
 243
 244   EXPECT_EQ(xid3, FindTopmostXWindowAt(250, 250));
 245   EXPECT_EQ(window3, FindTopmostLocalProcessWindowAt(250, 250));
 246
 247   EXPECT_EQ(xid3, FindTopmostXWindowAt(150, 250));
 248   EXPECT_EQ(window3, FindTopmostLocalProcessWindowAt(150, 250));
 249
 250   EXPECT_EQ(xid3, FindTopmostXWindowAt(150, 195));
 251   EXPECT_EQ(window3, FindTopmostLocalProcessWindowAt(150, 195));
 252
 253   EXPECT_NE(xid1, FindTopmostXWindowAt(1000, 1000));
 254   EXPECT_NE(xid2, FindTopmostXWindowAt(1000, 1000));
 255   EXPECT_NE(xid3, FindTopmostXWindowAt(1000, 1000));
 256   EXPECT_EQ(NULL, FindTopmostLocalProcessWindowAt(1000, 1000));
 257
 258   EXPECT_EQ(window1,
 259             FindTopmostLocalProcessWindowWithIgnore(150, 150, window3));
 260   EXPECT_EQ(NULL,
 261             FindTopmostLocalProcessWindowWithIgnore(250, 250, window3));
 262   EXPECT_EQ(NULL,
 263             FindTopmostLocalProcessWindowWithIgnore(150, 250, window3));
 264   EXPECT_EQ(window1,
 265             FindTopmostLocalProcessWindowWithIgnore(150, 195, window3));
 266
 267   XDestroyWindow(xdisplay(), xid2);
 268 }
 269
 270 // Test that the minimized state is properly handled.
 271 TEST_F(X11TopmostWindowFinderTest, Minimized) {
 272   scoped_ptr<Widget> widget1(
 273       CreateAndShowWidget(gfx::Rect(100, 100, 100, 100)));
 274   aura::Window* window1 = widget1->GetNativeWindow();
 275   XID xid1 = window1->GetHost()->GetAcceleratedWidget();
 276   XID xid2 = CreateAndShowXWindow(gfx::Rect(300, 100, 100, 100));
 277
 278   XID xids[] = { xid1, xid2 };
 279   StackingClientListWaiter stack_waiter(xids, arraysize(xids));
 280   stack_waiter.Wait();
 281   ui::X11EventSource::GetInstance()->DispatchXEvents();
 282
 283   EXPECT_EQ(xid1, FindTopmostXWindowAt(150, 150));
 284   {
 285     MinimizeWaiter minimize_waiter(xid1);
 286     XIconifyWindow(xdisplay(), xid1, 0);
 287     minimize_waiter.Wait();
 288   }
 289   EXPECT_NE(xid1, FindTopmostXWindowAt(150, 150));
 290   EXPECT_NE(xid2, FindTopmostXWindowAt(150, 150));
 291
 292   // Repeat test for an X window which does not belong to a views::Widget
 293   // because the code path is different.
 294   EXPECT_EQ(xid2, FindTopmostXWindowAt(350, 150));
 295   {
 296     MinimizeWaiter minimize_waiter(xid2);
 297     XIconifyWindow(xdisplay(), xid2, 0);
 298     minimize_waiter.Wait();
 299   }
 300   EXPECT_NE(xid1, FindTopmostXWindowAt(350, 150));
 301   EXPECT_NE(xid2, FindTopmostXWindowAt(350, 150));
 302
 303   XDestroyWindow(xdisplay(), xid2);
 304 }
 305
 306 // Test that non-rectangular windows are properly handled.
 307 TEST_F(X11TopmostWindowFinderTest, NonRectangular) {
 308   if (!ui::IsShapeExtensionAvailable())
 309     return;
 310
 311   scoped_ptr<Widget> widget1(
 312       CreateAndShowWidget(gfx::Rect(100, 100, 100, 100)));
 313   XID xid1 = widget1->GetNativeWindow()->GetHost()->GetAcceleratedWidget();
 314   SkRegion* skregion1 = new SkRegion;
 315   skregion1->op(SkIRect::MakeXYWH(0, 10, 10, 90), SkRegion::kUnion_Op);
 316   skregion1->op(SkIRect::MakeXYWH(10, 0, 90, 100), SkRegion::kUnion_Op);
 317   // Widget takes ownership of |skregion1|.
 318   widget1->SetShape(skregion1);
 319
 320   SkRegion skregion2;
 321   skregion2.op(SkIRect::MakeXYWH(0, 10, 10, 90), SkRegion::kUnion_Op);
 322   skregion2.op(SkIRect::MakeXYWH(10, 0, 90, 100), SkRegion::kUnion_Op);
 323   XID xid2 = CreateAndShowXWindow(gfx::Rect(300, 100, 100, 100));
 324   REGION* region2 = gfx::CreateRegionFromSkRegion(skregion2);
 325   XShapeCombineRegion(xdisplay(), xid2, ShapeBounding, 0, 0, region2,
 326       false);
 327   XDestroyRegion(region2);
 328
 329   XID xids[] = { xid1, xid2 };
 330   StackingClientListWaiter stack_waiter(xids, arraysize(xids));
 331   stack_waiter.Wait();
 332   ui::X11EventSource::GetInstance()->DispatchXEvents();
 333
 334   EXPECT_EQ(xid1, FindTopmostXWindowAt(105, 120));
 335   EXPECT_NE(xid1, FindTopmostXWindowAt(105, 105));
 336   EXPECT_NE(xid2, FindTopmostXWindowAt(105, 105));
 337
 338   // Repeat test for an X window which does not belong to a views::Widget
 339   // because the code path is different.
 340   EXPECT_EQ(xid2, FindTopmostXWindowAt(305, 120));
 341   EXPECT_NE(xid1, FindTopmostXWindowAt(305, 105));
 342   EXPECT_NE(xid2, FindTopmostXWindowAt(305, 105));
 343
 344   XDestroyWindow(xdisplay(), xid2);
 345 }
 346
 347 // Test that the TopmostWindowFinder finds windows which belong to menus
 348 // (which may or may not belong to Chrome).
 349 TEST_F(X11TopmostWindowFinderTest, Menu) {
 350   XID xid = CreateAndShowXWindow(gfx::Rect(100, 100, 100, 100));
 351
 352   XID root = DefaultRootWindow(xdisplay());
 353   XSetWindowAttributes swa;
 354   swa.override_redirect = True;
 355   XID menu_xid = XCreateWindow(xdisplay(),
 356                                root,
 357                                0, 0, 1, 1,
 358                                0,                  // border width
 359                                CopyFromParent,     // depth
 360                                InputOutput,
 361                                CopyFromParent,     // visual
 362                                CWOverrideRedirect,
 363                                &swa);
 364   {
 365     const char* kAtomsToCache[] = { "_NET_WM_WINDOW_TYPE_MENU", NULL };
 366     ui::X11AtomCache atom_cache(gfx::GetXDisplay(), kAtomsToCache);
 367     ui::SetAtomProperty(menu_xid,
 368                         "_NET_WM_WINDOW_TYPE",
 369                         "ATOM",
 370                         atom_cache.GetAtom("_NET_WM_WINDOW_TYPE_MENU"));
 371   }
 372   ui::SetUseOSWindowFrame(menu_xid, false);
 373   ShowAndSetXWindowBounds(menu_xid, gfx::Rect(140, 110, 100, 100));
 374   ui::X11EventSource::GetInstance()->DispatchXEvents();
 375
 376   // |menu_xid| is never added to _NET_CLIENT_LIST_STACKING.
 377   XID xids[] = { xid };
 378   StackingClientListWaiter stack_waiter(xids, arraysize(xids));
 379   stack_waiter.Wait();
 380
 381   EXPECT_EQ(xid, FindTopmostXWindowAt(110, 110));
 382   EXPECT_EQ(menu_xid, FindTopmostXWindowAt(150, 120));
 383   EXPECT_EQ(menu_xid, FindTopmostXWindowAt(210, 120));
 384
 385   XDestroyWindow(xdisplay(), xid);
 386   XDestroyWindow(xdisplay(), menu_xid);
 387 }
 388
 389 }  // namespace views