Remove usages of XInternAtom

ui/events/platform/x11/x11_hotplug_event_handler.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 "ui/events/platform/x11/x11_hotplug_event_handler.h"
 
 #include <stdint.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/process/launch.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
+#include "ui/base/x/x11_util.h"
 #include "ui/events/devices/device_data_manager.h"
 #include "ui/events/devices/device_hotplug_event_observer.h"
 #include "ui/events/devices/device_util_linux.h"
 #include "ui/events/devices/input_device.h"
 #include "ui/events/devices/touchscreen_device.h"
+#include "ui/gfx/x/x11_atom_cache.h"
 #include "ui/gfx/x/x11_types.h"
 
 #ifndef XI_PROP_PRODUCT_ID
 #define XI_PROP_PRODUCT_ID "Device Product ID"
 #endif
 
 namespace ui {
 
 namespace {
 
 // Names of all known internal devices that should not be considered as
 // keyboards.
 // TODO(rsadam@): Identify these devices using udev rules. (Crbug.com/420728.)
 const char* kKnownInvalidKeyboardDeviceNames[] = {"Power Button",
                                                   "Sleep Button",
                                                   "Video Bus",
                                                   "gpio-keys.5",
                                                   "gpio-keys.12",
                                                   "ROCKCHIP-I2S Headset Jack"};
 
-const char* kCachedAtomList[] = {
-  "Abs MT Position X",
-  "Abs MT Position Y",
-  XI_KEYBOARD,
-  XI_MOUSE,
-  XI_TOUCHPAD,
-  XI_TOUCHSCREEN,
-  XI_PROP_PRODUCT_ID,
-  NULL,
-};
-
 enum DeviceType {
   DEVICE_TYPE_KEYBOARD,
   DEVICE_TYPE_MOUSE,
   DEVICE_TYPE_TOUCHPAD,
   DEVICE_TYPE_TOUCHSCREEN,
   DEVICE_TYPE_OTHER
 };
 
 typedef base::Callback<void(const std::vector<InputDevice>&)>
     KeyboardDeviceCallback;
@@ skipping 125 matching lines @@
 }
 
 base::FilePath GetDevicePath(XDisplay* dpy, const XIDeviceInfo& device) {
   // Skip the main pointer and keyboard since XOpenDevice() generates a
   // BadDevice error when passed these devices.
   if (device.use == XIMasterPointer || device.use == XIMasterKeyboard)
     return base::FilePath();
 
   // Input device has a property "Device Node" pointing to its dev input node,
   // e.g.   Device Node (250): "/dev/input/event8"
-  Atom device_node = XInternAtom(dpy, "Device Node", False);
+  Atom device_node = ui::X11AtomCache::GetInstance()->GetAtom("Device Node");
   if (device_node == None)
     return base::FilePath();
 
   Atom actual_type;
   int actual_format;
   unsigned long nitems, bytes_after;
   unsigned char* data;
   XDevice* dev = XOpenDevice(dpy, device.deviceid);
 
   // Sometimes XOpenDevice() doesn't return null but the contents aren't valid.
@@ skipping 182 matching lines @@
 void OnTouchpadDevices(const std::vector<InputDevice>& devices) {
   GetHotplugEventObserver()->OnTouchpadDevicesUpdated(devices);
 }
 
 void OnHotplugFinished() {
   GetHotplugEventObserver()->OnDeviceListsComplete();
 }
 
 }  // namespace
 
-X11HotplugEventHandler::X11HotplugEventHandler()
-    : atom_cache_(gfx::GetXDisplay(), kCachedAtomList) {
-}
+X11HotplugEventHandler::X11HotplugEventHandler() {}
 
 X11HotplugEventHandler::~X11HotplugEventHandler() {
 }
 
 void X11HotplugEventHandler::OnHotplugEvent() {
   Display* display = gfx::GetXDisplay();
   const XDeviceList& device_list_xi =
       DeviceListCacheX11::GetInstance()->GetXDeviceList(display);
   const XIDeviceList& device_list_xi2 =
       DeviceListCacheX11::GetInstance()->GetXI2DeviceList(display);
 
   const int kMaxDeviceNum = 128;
   DeviceType device_types[kMaxDeviceNum];
   for (int i = 0; i < kMaxDeviceNum; ++i)
     device_types[i] = DEVICE_TYPE_OTHER;
 
   for (int i = 0; i < device_list_xi.count; ++i) {
     int id = device_list_xi[i].id;
     if (id < 0 || id >= kMaxDeviceNum)
       continue;
 
     Atom type = device_list_xi[i].type;
-    if (type == atom_cache_.GetAtom(XI_KEYBOARD))
+    if (type == GetAtom(XI_KEYBOARD))
       device_types[id] = DEVICE_TYPE_KEYBOARD;
-    else if (type == atom_cache_.GetAtom(XI_MOUSE))
+    else if (type == GetAtom(XI_MOUSE))
       device_types[id] = DEVICE_TYPE_MOUSE;
-    else if (type == atom_cache_.GetAtom(XI_TOUCHPAD))
+    else if (type == GetAtom(XI_TOUCHPAD))
       device_types[id] = DEVICE_TYPE_TOUCHPAD;
-    else if (type == atom_cache_.GetAtom(XI_TOUCHSCREEN))
+    else if (type == GetAtom(XI_TOUCHSCREEN))
       device_types[id] = DEVICE_TYPE_TOUCHSCREEN;
   }
 
   std::vector<DeviceInfo> device_infos;
   for (int i = 0; i < device_list_xi2.count; ++i) {
     const XIDeviceInfo& device = device_list_xi2[i];
     if (!device.enabled || IsTestDevice(device.name))
       continue;
 
     DeviceType device_type =
         (device.deviceid >= 0 && device.deviceid < kMaxDeviceNum)
             ? device_types[device.deviceid]
             : DEVICE_TYPE_OTHER;
 
     // Obtain the USB-style vendor and product identifiers.
     // (On Linux, XI2 makes this available for all evdev devices.
     uint32_t* product_info;
     Atom type;
     int format_return;
     unsigned long num_items_return;
     unsigned long bytes_after_return;
     uint16_t vendor = 0;
     uint16_t product = 0;
     if (XIGetProperty(gfx::GetXDisplay(), device.deviceid,
-                      atom_cache_.GetAtom(XI_PROP_PRODUCT_ID), 0, 2, 0,
-                      XA_INTEGER, &type, &format_return, &num_items_return,
-                      &bytes_after_return,
+                      GetAtom(XI_PROP_PRODUCT_ID), 0, 2, 0, XA_INTEGER, &type,
+                      &format_return, &num_items_return, &bytes_after_return,
                       reinterpret_cast<unsigned char**>(&product_info)) == 0 &&
         product_info) {
       if (num_items_return == 2) {
         vendor = product_info[0];
         product = product_info[1];
       }
       XFree(product_info);
     }
 
     device_infos.push_back(DeviceInfo(
         device, device_type, GetDevicePath(display, device), vendor, product));
   }
 
   // X11 is not thread safe, so first get all the required state.
   DisplayState display_state;
-  display_state.mt_position_x = atom_cache_.GetAtom("Abs MT Position X");
-  display_state.mt_position_y = atom_cache_.GetAtom("Abs MT Position Y");
+  display_state.mt_position_x = GetAtom("Abs MT Position X");
+  display_state.mt_position_y = GetAtom("Abs MT Position Y");
 
   UiCallbacks callbacks;
   callbacks.keyboard_callback = base::Bind(&OnKeyboardDevices);
   callbacks.touchscreen_callback = base::Bind(&OnTouchscreenDevices);
   callbacks.mouse_callback = base::Bind(&OnMouseDevices);
   callbacks.touchpad_callback = base::Bind(&OnTouchpadDevices);
   callbacks.hotplug_finished_callback = base::Bind(&OnHotplugFinished);
 
   // Parsing the device information may block, so delegate the operation to a
   // worker thread. Once the device information is extracted the parsed devices
   // will be returned via the callbacks.
   base::WorkerPool::PostTask(
       FROM_HERE,
       base::Bind(&HandleHotplugEventInWorker, device_infos, display_state,
                  base::ThreadTaskRunnerHandle::Get(), callbacks),
       true /* task_is_slow */);
 }
 
 }  // namespace ui