Remove usages of XInternAtom

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)
+  WMStateWaiter(XID window, const char* hint, bool wait_till_set)
       : X11PropertyChangeWaiter(window, "_NET_WM_STATE"),
         hint_(hint),
-        wait_till_set_(wait_till_set) {
-    const char* const kAtomsToCache[] = {
-        hint,
-        nullptr
-    };
-    atom_cache_.reset(new ui::X11AtomCache(gfx::GetXDisplay(), kAtomsToCache));
-  }
+        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(),
-                          atom_cache_->GetAtom(hint_));
+      auto it = std::find(hints.cbegin(), hints.cend(), ui::GetAtom(hint_));
       bool hint_set = (it != hints.cend());
       return hint_set != wait_till_set_;
     }
     return true;
   }
 
-  std::unique_ptr<ui::X11AtomCache> atom_cache_;
-
   // 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.
   bool wait_till_set_;
 
   DISALLOW_COPY_AND_ASSIGN(WMStateWaiter);
 };
 
 // A NonClientFrameView with a window mask with the bottom right corner cut out.
@@ skipping 248 matching lines @@
   {
     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.
   {
-    const char* const kAtomsToCache[] = {
-        "_NET_WM_STATE",
-        "_NET_WM_STATE_FULLSCREEN",
-        nullptr
-    };
     Display* display = gfx::GetXDisplay();
-    ui::X11AtomCache atom_cache(display, kAtomsToCache);
 
     XEvent xclient;
     memset(&xclient, 0, sizeof(xclient));
     xclient.type = ClientMessage;
     xclient.xclient.window = xid;
-    xclient.xclient.message_type = atom_cache.GetAtom("_NET_WM_STATE");
+    xclient.xclient.message_type = ui::GetAtom("_NET_WM_STATE");
     xclient.xclient.format = 32;
     xclient.xclient.data.l[0] = 0;
-    xclient.xclient.data.l[1] = atom_cache.GetAtom("_NET_WM_STATE_FULLSCREEN");
+    xclient.xclient.data.l[1] = ui::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 15 matching lines @@
   params.native_widget = new DesktopNativeWidgetAura(&widget);
   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
   {
-    const char* const kAtomsToCache[] = {
-        "_NET_WM_STATE",
-        "_NET_WM_STATE_HIDDEN",
-        nullptr
-    };
-
-    ui::X11AtomCache atom_cache(display, kAtomsToCache);
-
     std::vector< ::Atom> atom_list;
-    atom_list.push_back(atom_cache.GetAtom("_NET_WM_STATE_HIDDEN"));
+    atom_list.push_back(ui::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 = atom_cache.GetAtom("_NET_WM_STATE");
+    xevent.xproperty.atom = ui::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
   {
-    const char* const kAtomsToCache[] = {
-        "_NET_WM_STATE",
-        "_NET_WM_STATE_FOCUSED",
-        nullptr
-    };
-
-    ui::X11AtomCache atom_cache(display, kAtomsToCache);
-
     std::vector< ::Atom> atom_list;
-    atom_list.push_back(atom_cache.GetAtom("_NET_WM_STATE_FOCUSED"));
+    atom_list.push_back(ui::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 = atom_cache.GetAtom("_NET_WM_STATE");
+    xevent.xproperty.atom = ui::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