Remove usages of XInternAtom

ui/aura/window_tree_host_x11.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.
 
 #include "ui/aura/window_tree_host_x11.h"
 
 #include <strings.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xrandr.h>
@@ skipping 41 matching lines @@
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/events/platform/x11/x11_event_source.h"
 
 using std::max;
 using std::min;
 
 namespace aura {
 
 namespace {
 
-const char* kAtomsToCache[] = {
-  "WM_DELETE_WINDOW",
-  "_NET_WM_PING",
-  "_NET_WM_PID",
-  NULL
-};
-
 constexpr uint32_t kInputEventMask =
     ButtonPressMask | ButtonReleaseMask | FocusChangeMask | KeyPressMask |
     KeyReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask;
 
 constexpr uint32_t kEventMask = kInputEventMask | ExposureMask |
                                 VisibilityChangeMask | StructureNotifyMask |
                                 PropertyChangeMask;
 
 ::Window FindEventTarget(const base::NativeEvent& xev) {
   ::Window target = xev->xany.window;
@@ skipping 36 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeHostX11
 
 WindowTreeHostX11::WindowTreeHostX11(const gfx::Rect& bounds)
     : xdisplay_(gfx::GetXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       current_cursor_(ui::CursorType::kNull),
       window_mapped_(false),
-      bounds_(bounds),
-      atom_cache_(xdisplay_, kAtomsToCache) {
+      bounds_(bounds) {
   XSetWindowAttributes swa;
   memset(&swa, 0, sizeof(swa));
   swa.background_pixmap = None;
   swa.bit_gravity = NorthWestGravity;
   swa.override_redirect = ui::UseTestConfigForPlatformWindows();
   xwindow_ = XCreateWindow(
       xdisplay_, x_root_window_,
       bounds.x(), bounds.y(), bounds.width(), bounds.height(),
       0,               // border width
       CopyFromParent,  // depth
       InputOutput,
       CopyFromParent,  // visual
       CWBackPixmap | CWBitGravity | CWOverrideRedirect,
       &swa);
   if (ui::PlatformEventSource::GetInstance())
     ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
 
   xwindow_events_.reset(new ui::XScopedEventSelector(xwindow_, kEventMask));
   XFlush(xdisplay_);
 
   if (ui::IsXInput2Available()) {
     ui::TouchFactory::GetInstance()->SetupXI2ForXWindow(xwindow_);
     SelectXInput2EventsForRootWindow(xdisplay_, x_root_window_);
   }
 
   // TODO(erg): We currently only request window deletion events. We also
   // should listen for activation events and anything else that GTK+ listens
   // for, and do something useful.
   ::Atom protocols[2];
-  protocols[0] = atom_cache_.GetAtom("WM_DELETE_WINDOW");
-  protocols[1] = atom_cache_.GetAtom("_NET_WM_PING");
+  protocols[0] = ui::GetAtom("WM_DELETE_WINDOW");
+  protocols[1] = ui::GetAtom("_NET_WM_PING");
   XSetWMProtocols(xdisplay_, xwindow_, protocols, 2);
 
   // We need a WM_CLIENT_MACHINE and WM_LOCALE_NAME value so we integrate with
   // the desktop environment.
   XSetWMProperties(xdisplay_, xwindow_, NULL, NULL, NULL, 0, NULL, NULL, NULL);
   ui::SetWindowClassHint(xdisplay_, xwindow_, "chromiumos", "ChromiumOS");
 
   // Likewise, the X server needs to know this window's pid so it knows which
   // program to kill if the window hangs.
   // XChangeProperty() expects "pid" to be long.
   static_assert(sizeof(long) >= sizeof(pid_t),
                 "pid_t should not be larger than long");
   long pid = getpid();
-  XChangeProperty(xdisplay_,
-                  xwindow_,
-                  atom_cache_.GetAtom("_NET_WM_PID"),
-                  XA_CARDINAL,
-                  32,
-                  PropModeReplace,
-                  reinterpret_cast<unsigned char*>(&pid), 1);
-
-  // Allow subclasses to create and cache additional atoms.
-  atom_cache_.allow_uncached_atoms();
+  XChangeProperty(xdisplay_, xwindow_, ui::GetAtom("_NET_WM_PID"), XA_CARDINAL,
+                  32, PropModeReplace, reinterpret_cast<unsigned char*>(&pid),
+                  1);
 
   XRRSelectInput(xdisplay_, x_root_window_,
                  RRScreenChangeNotifyMask | RROutputChangeNotifyMask);
   CreateCompositor();
   OnAcceleratedWidgetAvailable();
 }
 
 WindowTreeHostX11::~WindowTreeHostX11() {
   if (ui::PlatformEventSource::GetInstance())
     ui::PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
@@ skipping 124 matching lines @@
         OnHostResizedInPixels(bounds.size());
       if (origin_changed)
         OnHostMovedInPixels(bounds_.origin());
       break;
     }
     case GenericEvent:
       DispatchXI2Event(xev);
       break;
     case ClientMessage: {
       Atom message_type = static_cast<Atom>(xev->xclient.data.l[0]);
-      if (message_type == atom_cache_.GetAtom("WM_DELETE_WINDOW")) {
+      if (message_type == ui::GetAtom("WM_DELETE_WINDOW")) {
         // We have received a close message from the window manager.
         OnHostCloseRequested();
-      } else if (message_type == atom_cache_.GetAtom("_NET_WM_PING")) {
+      } else if (message_type == ui::GetAtom("_NET_WM_PING")) {
         XEvent reply_event = *xev;
         reply_event.xclient.window = x_root_window_;
 
         XSendEvent(xdisplay_,
                    reply_event.xclient.window,
                    False,
                    SubstructureRedirectMask | SubstructureNotifyMask,
                    &reply_event);
         XFlush(xdisplay_);
       }
@@ skipping 228 matching lines @@
     ui::LocatedEvent* event) {
   SendEventToSink(event);
 }
 
 // static
 WindowTreeHost* WindowTreeHost::Create(const gfx::Rect& bounds_in_pixels) {
   return new WindowTreeHostX11(bounds_in_pixels);
 }
 
 }  // namespace aura