Remove usages of XInternAtom

ui/display/manager/chromeos/x11/native_display_delegate_x11.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/display/manager/chromeos/x11/native_display_delegate_x11.h"
 
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 #include <X11/extensions/dpms.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xrandr.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "ui/base/x/x11_util.h"
 #include "ui/display/manager/chromeos/x11/display_mode_x11.h"
 #include "ui/display/manager/chromeos/x11/display_snapshot_x11.h"
 #include "ui/display/manager/chromeos/x11/display_util_x11.h"
 #include "ui/display/manager/chromeos/x11/native_display_event_dispatcher_x11.h"
 #include "ui/display/types/native_display_observer.h"
 #include "ui/display/util/x11/edid_parser_x11.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/x/x11_error_tracker.h"
 #include "ui/gfx/x/x11_types.h"
@@ skipping 366 matching lines @@
 
 bool NativeDisplayDelegateX11::GetHDCPState(const DisplaySnapshot& output,
                                             HDCPState* state) {
   unsigned char* values = NULL;
   int actual_format = 0;
   unsigned long nitems = 0;
   unsigned long bytes_after = 0;
   Atom actual_type = None;
   int success = 0;
   RROutput output_id = static_cast<const DisplaySnapshotX11&>(output).output();
-  // TODO(kcwu): Use X11AtomCache to save round trip time of XInternAtom.
-  Atom prop = XInternAtom(display_, kContentProtectionAtomName, False);
+  Atom prop = ui::GetAtom(kContentProtectionAtomName);
 
   // TODO(kcwu): Move this to x11_util (similar method calls in this file and
   // output_util.cc)
   success = XRRGetOutputProperty(display_,
                                  output_id,
                                  prop,
                                  0,
                                  100,
                                  False,
                                  False,
                                  AnyPropertyType,
                                  &actual_type,
                                  &actual_format,
                                  &nitems,
                                  &bytes_after,
                                  &values);
   gfx::XScopedPtr<unsigned char> scoped_values(values);
   if (actual_type == None) {
     LOG(ERROR) << "Property '" << kContentProtectionAtomName
                << "' does not exist";
     return false;
   }
 
   if (success == Success && actual_type == XA_ATOM && actual_format == 32 &&
       nitems == 1) {
     Atom value = reinterpret_cast<Atom*>(values)[0];
-    if (value == XInternAtom(display_, kProtectionUndesiredAtomName, False)) {
+    if (value == ui::GetAtom(kProtectionUndesiredAtomName)) {
       *state = HDCP_STATE_UNDESIRED;
-    } else if (value ==
-               XInternAtom(display_, kProtectionDesiredAtomName, False)) {
+    } else if (value == ui::GetAtom(kProtectionDesiredAtomName)) {
       *state = HDCP_STATE_DESIRED;
-    } else if (value ==
-               XInternAtom(display_, kProtectionEnabledAtomName, False)) {
+    } else if (value == ui::GetAtom(kProtectionEnabledAtomName)) {
       *state = HDCP_STATE_ENABLED;
     } else {
       LOG(ERROR) << "Unknown " << kContentProtectionAtomName
                  << " value: " << value;
       return false;
     }
   } else {
     LOG(ERROR) << "XRRGetOutputProperty failed";
     return false;
   }
 
   VLOG(3) << "HDCP state: success," << *state;
   return true;
 }
 
 void NativeDisplayDelegateX11::SetHDCPState(
     const DisplaySnapshot& output,
     HDCPState state,
     const SetHDCPStateCallback& callback) {
   callback.Run(SetHDCPState(output, state));
 }
 
 bool NativeDisplayDelegateX11::SetHDCPState(const DisplaySnapshot& output,
                                             HDCPState state) {
-  Atom name = XInternAtom(display_, kContentProtectionAtomName, False);
+  Atom name = ui::GetAtom(kContentProtectionAtomName);
   Atom value = None;
   switch (state) {
     case HDCP_STATE_UNDESIRED:
-      value = XInternAtom(display_, kProtectionUndesiredAtomName, False);
+      value = ui::GetAtom(kProtectionUndesiredAtomName);
       break;
     case HDCP_STATE_DESIRED:
-      value = XInternAtom(display_, kProtectionDesiredAtomName, False);
+      value = ui::GetAtom(kProtectionDesiredAtomName);
       break;
     default:
       NOTREACHED() << "Invalid HDCP state: " << state;
       return false;
   }
   gfx::X11ErrorTracker err_tracker;
   unsigned char* data = reinterpret_cast<unsigned char*>(&value);
   RROutput output_id = static_cast<const DisplaySnapshotX11&>(output).output();
   XRRChangeOutputProperty(
       display_, output_id, name, XA_ATOM, 32, PropModeReplace, data, 1);
@@ skipping 56 matching lines @@
         output = None;
         mode_info = NULL;
       }
     }
 
     ConfigureCrtc(x11_output->crtc(), mode, output, 0, 0);
   }
 }
 
 bool NativeDisplayDelegateX11::IsOutputAspectPreservingScaling(RROutput id) {
-  Atom scaling_prop = XInternAtom(display_, "scaling mode", False);
-  Atom full_aspect_atom = XInternAtom(display_, "Full aspect", False);
+  Atom scaling_prop = ui::GetAtom("scaling mode");
+  Atom full_aspect_atom = ui::GetAtom("Full aspect");
   if (scaling_prop == None || full_aspect_atom == None)
     return false;
 
   int nprop = 0;
   gfx::XScopedPtr<Atom[]> props(XRRListOutputProperties(display_, id, &nprop));
   for (int j = 0; j < nprop; j++) {
     Atom prop = props[j];
     if (scaling_prop == prop) {
       unsigned char* values = NULL;
       int actual_format;
@@ skipping 89 matching lines @@
   XSetForeground(display_, gc, color.pixel);
   XSetFillStyle(display_, gc, FillSolid);
   int width = DisplayWidth(display_, DefaultScreen(display_));
   int height = DisplayHeight(display_, DefaultScreen(display_));
   XFillRectangle(display_, window_, gc, 0, 0, width, height);
   XFreeGC(display_, gc);
   XFreeColors(display_, colormap, &color.pixel, 1, 0);
 }
 
 }  // namespace display