Move ui::GetAtom to gfx::GetAtom

ui/views/widget/desktop_aura/desktop_window_tree_host_x11_unittest.cc

 // Copyright 2014 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.
 
 #include <stddef.h>
 #include <X11/extensions/shape.h>
 #include <X11/Xlib.h>
 
 #include <memory>
 #include <vector>
@@ skipping 13 matching lines @@
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/display/display_switches.h"
 #include "ui/events/devices/x11/touch_factory_x11.h"
 #include "ui/events/platform/x11/x11_event_source_glib.h"
 #include "ui/events/test/platform_event_source_test_api.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/path.h"
+#include "ui/gfx/x/x11_atom_cache.h"
 #include "ui/views/test/views_test_base.h"
 #include "ui/views/test/x11_property_change_waiter.h"
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/views/window/non_client_view.h"
 
 namespace views {
 
 namespace {
 
 const int kPointerDeviceId = 1;
 
 // Blocks till the window state hint, |hint|, is set or unset.
 class WMStateWaiter : public X11PropertyChangeWaiter {
  public:
   WMStateWaiter(XID window, const char* hint, bool wait_till_set)
       : X11PropertyChangeWaiter(window, "_NET_WM_STATE"),
         hint_(hint),
         wait_till_set_(wait_till_set) {}
 
   ~WMStateWaiter() override {}
 
  private:
   // X11PropertyChangeWaiter:
   bool ShouldKeepOnWaiting(const ui::PlatformEvent& event) override {
     std::vector<Atom> hints;
     if (ui::GetAtomArrayProperty(xwindow(), "_NET_WM_STATE", &hints)) {
-      auto it = std::find(hints.cbegin(), hints.cend(), ui::GetAtom(hint_));
+      auto it = std::find(hints.cbegin(), hints.cend(), gfx::GetAtom(hint_));
       bool hint_set = (it != hints.cend());
       return hint_set != wait_till_set_;
     }
     return true;
   }
 
   // The name of the hint to wait to get set or unset.
   const char* hint_;
 
   // Whether we are waiting for |hint| to be set or unset.
@@ skipping 158 matching lines @@
     shape_rects = GetShapeRects(xid1);
     ASSERT_FALSE(shape_rects.empty());
     EXPECT_TRUE(ShapeRectContainsPoint(shape_rects, 85, 5));
     EXPECT_TRUE(ShapeRectContainsPoint(shape_rects, 95, 5));
     EXPECT_TRUE(ShapeRectContainsPoint(shape_rects, 185, 5));
     EXPECT_FALSE(ShapeRectContainsPoint(shape_rects, 195, 5));
     EXPECT_TRUE(ShapeRectContainsPoint(shape_rects, 195, 15));
     EXPECT_FALSE(ShapeRectContainsPoint(shape_rects, 205, 15));
   }
 
-  if (ui::WmSupportsHint(ui::GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"))) {
+  if (ui::WmSupportsHint(gfx::GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"))) {
     // The shape should be changed to a rectangle which fills the entire screen
     // when |widget1| is maximized.
     {
       WMStateWaiter waiter(xid1, "_NET_WM_STATE_MAXIMIZED_VERT", true);
       widget1->Maximize();
       waiter.Wait();
     }
 
     // Ensure that the task which is posted when a window is resized is run.
     RunAllPendingInMessageLoop();
@@ skipping 56 matching lines @@
   EXPECT_TRUE(ShapeRectContainsPoint(shape_rects, 5, 5));
   EXPECT_TRUE(ShapeRectContainsPoint(shape_rects, 15, 5));
   EXPECT_TRUE(ShapeRectContainsPoint(shape_rects, 95, 15));
   EXPECT_TRUE(ShapeRectContainsPoint(shape_rects, 105, 15));
   EXPECT_FALSE(ShapeRectContainsPoint(shape_rects, 500, 500));
 }
 
 // Test that the widget ignores changes in fullscreen state initiated by the
 // window manager (e.g. via a window manager accelerator key).
 TEST_F(DesktopWindowTreeHostX11Test, WindowManagerTogglesFullscreen) {
-  if (!ui::WmSupportsHint(ui::GetAtom("_NET_WM_STATE_FULLSCREEN")))
+  if (!ui::WmSupportsHint(gfx::GetAtom("_NET_WM_STATE_FULLSCREEN")))
     return;
 
   std::unique_ptr<Widget> widget = CreateWidget(new ShapedWidgetDelegate());
   XID xid = widget->GetNativeWindow()->GetHost()->GetAcceleratedWidget();
   widget->Show();
   ui::X11EventSource::GetInstance()->DispatchXEvents();
 
   gfx::Rect initial_bounds = widget->GetWindowBoundsInScreen();
   {
     WMStateWaiter waiter(xid, "_NET_WM_STATE_FULLSCREEN", true);
     widget->SetFullscreen(true);
     waiter.Wait();
   }
   EXPECT_TRUE(widget->IsFullscreen());
 
   // Emulate the window manager exiting fullscreen via a window manager
   // accelerator key. It should not affect the widget's fullscreen state.
   {
     Display* display = gfx::GetXDisplay();
 
     XEvent xclient;
     memset(&xclient, 0, sizeof(xclient));
     xclient.type = ClientMessage;
     xclient.xclient.window = xid;
-    xclient.xclient.message_type = ui::GetAtom("_NET_WM_STATE");
+    xclient.xclient.message_type = gfx::GetAtom("_NET_WM_STATE");
     xclient.xclient.format = 32;
     xclient.xclient.data.l[0] = 0;
-    xclient.xclient.data.l[1] = ui::GetAtom("_NET_WM_STATE_FULLSCREEN");
+    xclient.xclient.data.l[1] = gfx::GetAtom("_NET_WM_STATE_FULLSCREEN");
     xclient.xclient.data.l[2] = 0;
     xclient.xclient.data.l[3] = 1;
     xclient.xclient.data.l[4] = 0;
     XSendEvent(display, DefaultRootWindow(display), False,
                SubstructureRedirectMask | SubstructureNotifyMask,
                &xclient);
 
     WMStateWaiter waiter(xid, "_NET_WM_STATE_FULLSCREEN", false);
     waiter.Wait();
   }
@@ skipping 16 matching lines @@
   widget.Init(params);
   widget.Show();
   ui::X11EventSource::GetInstance()->DispatchXEvents();
 
   XID xid = widget.GetNativeWindow()->GetHost()->GetAcceleratedWidget();
   Display* display = gfx::GetXDisplay();
 
   // Minimize by sending _NET_WM_STATE_HIDDEN
   {
     std::vector< ::Atom> atom_list;
-    atom_list.push_back(ui::GetAtom("_NET_WM_STATE_HIDDEN"));
+    atom_list.push_back(gfx::GetAtom("_NET_WM_STATE_HIDDEN"));
     ui::SetAtomArrayProperty(xid, "_NET_WM_STATE", "ATOM", atom_list);
 
     XEvent xevent;
     memset(&xevent, 0, sizeof(xevent));
     xevent.type = PropertyNotify;
     xevent.xproperty.type = PropertyNotify;
     xevent.xproperty.send_event = 1;
     xevent.xproperty.display = display;
     xevent.xproperty.window = xid;
-    xevent.xproperty.atom = ui::GetAtom("_NET_WM_STATE");
+    xevent.xproperty.atom = gfx::GetAtom("_NET_WM_STATE");
     xevent.xproperty.state = 0;
     XSendEvent(display, DefaultRootWindow(display), False,
         SubstructureRedirectMask | SubstructureNotifyMask,
         &xevent);
 
     WMStateWaiter waiter(xid, "_NET_WM_STATE_HIDDEN", true);
     waiter.Wait();
   }
   EXPECT_FALSE(widget.GetNativeWindow()->IsVisible());
 
   // Show from minimized by sending _NET_WM_STATE_FOCUSED
   {
     std::vector< ::Atom> atom_list;
-    atom_list.push_back(ui::GetAtom("_NET_WM_STATE_FOCUSED"));
+    atom_list.push_back(gfx::GetAtom("_NET_WM_STATE_FOCUSED"));
     ui::SetAtomArrayProperty(xid, "_NET_WM_STATE", "ATOM", atom_list);
 
     XEvent xevent;
     memset(&xevent, 0, sizeof(xevent));
     xevent.type = PropertyNotify;
     xevent.xproperty.type = PropertyNotify;
     xevent.xproperty.send_event = 1;
     xevent.xproperty.display = display;
     xevent.xproperty.window = xid;
-    xevent.xproperty.atom = ui::GetAtom("_NET_WM_STATE");
+    xevent.xproperty.atom = gfx::GetAtom("_NET_WM_STATE");
     xevent.xproperty.state = 0;
     XSendEvent(display, DefaultRootWindow(display), False,
         SubstructureRedirectMask | SubstructureNotifyMask,
         &xevent);
 
     WMStateWaiter waiter(xid, "_NET_WM_STATE_FOCUSED", true);
     waiter.Wait();
   }
   EXPECT_TRUE(widget.GetNativeWindow()->IsVisible());
 }
@@ skipping 182 matching lines @@
   EXPECT_EQ(ui::ET_MOUSEWHEEL, second_recorder.mouse_events()[0].type());
   EXPECT_EQ(gfx::Point(-25, -25).ToString(),
             second_recorder.mouse_events()[0].location().ToString());
 
   PretendCapture(nullptr);
   first.GetNativeWindow()->RemovePreTargetHandler(&first_recorder);
   second.GetNativeWindow()->RemovePreTargetHandler(&second_recorder);
 }
 
 }  // namespace views