Move ui::GetAtom to gfx::GetAtom

ui/base/x/selection_owner.cc

 // Copyright (c) 2013 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/base/x/selection_owner.h"
 
 #include <algorithm>
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "ui/base/x/selection_utils.h"
-#include "ui/base/x/x11_util.h"
 #include "ui/base/x/x11_window_event_manager.h"
 #include "ui/events/platform/x11/x11_event_source.h"
+#include "ui/gfx/x/x11_atom_cache.h"
 
 namespace ui {
 
 namespace {
 
 const char kAtomPair[] = "ATOM_PAIR";
 const char kIncr[] = "INCR";
 const char kMultiple[] = "MULTIPLE";
 const char kSaveTargets[] = "SAVE_TARGETS";
 const char kTargets[] = "TARGETS";
@@ skipping 110 matching lines @@
   // Incrementally build our selection. By default this is a refusal, and we'll
   // override the parts indicating success in the different cases.
   XEvent reply;
   reply.xselection.type = SelectionNotify;
   reply.xselection.requestor = requestor;
   reply.xselection.selection = event.xselectionrequest.selection;
   reply.xselection.target = requested_target;
   reply.xselection.property = None;  // Indicates failure
   reply.xselection.time = event.xselectionrequest.time;
 
-  if (requested_target == GetAtom(kMultiple)) {
+  if (requested_target == gfx::GetAtom(kMultiple)) {
     // The contents of |requested_property| should be a list of
     // <target,property> pairs.
     std::vector<std::pair<XAtom,XAtom> > conversions;
     if (GetAtomPairArrayProperty(requestor,
                                  requested_property,
                                  &conversions)) {
       std::vector<XAtom> conversion_results;
       for (size_t i = 0; i < conversions.size(); ++i) {
         bool conversion_successful = ProcessTarget(conversions[i].first,
                                                    requestor,
                                                    conversions[i].second);
         conversion_results.push_back(conversions[i].first);
         conversion_results.push_back(
             conversion_successful ? conversions[i].second : None);
       }
 
       // Set the property to indicate which conversions succeeded. This matches
       // what GTK does.
       XChangeProperty(
-          x_display_, requestor, requested_property, GetAtom(kAtomPair), 32,
-          PropModeReplace,
+          x_display_, requestor, requested_property, gfx::GetAtom(kAtomPair),
+          32, PropModeReplace,
           reinterpret_cast<const unsigned char*>(&conversion_results.front()),
           conversion_results.size());
 
       reply.xselection.property = requested_property;
     }
   } else {
     if (ProcessTarget(requested_target, requestor, requested_property))
       reply.xselection.property = requested_property;
   }
 
@@ skipping 20 matching lines @@
     return;
 
   ProcessIncrementalTransfer(&(*it));
   if (!it->data.get())
     CompleteIncrementalTransfer(it);
 }
 
 bool SelectionOwner::ProcessTarget(XAtom target,
                                    XID requestor,
                                    XAtom property) {
-  XAtom multiple_atom = GetAtom(kMultiple);
-  XAtom save_targets_atom = GetAtom(kSaveTargets);
-  XAtom targets_atom = GetAtom(kTargets);
-  XAtom timestamp_atom = GetAtom(kTimestamp);
+  XAtom multiple_atom = gfx::GetAtom(kMultiple);
+  XAtom save_targets_atom = gfx::GetAtom(kSaveTargets);
+  XAtom targets_atom = gfx::GetAtom(kTargets);
+  XAtom timestamp_atom = gfx::GetAtom(kTimestamp);
 
   if (target == multiple_atom || target == save_targets_atom)
     return false;
 
   if (target == timestamp_atom) {
     XChangeProperty(
         x_display_, requestor, property, XA_INTEGER, 32, PropModeReplace,
         reinterpret_cast<unsigned char*>(&acquired_selection_timestamp_), 1);
     return true;
   }
@@ skipping 16 matching lines @@
   }
 
   // Try to find the data type in map.
   SelectionFormatMap::const_iterator it = format_map_.find(target);
   if (it != format_map_.end()) {
     if (it->second->size() > max_request_size_) {
       // We must send the data back in several chunks due to a limitation in
       // the size of X requests. Notify the selection requestor that the data
       // will be sent incrementally by returning data of type "INCR".
       long length = it->second->size();
-      XChangeProperty(x_display_, requestor, property, GetAtom(kIncr), 32,
+      XChangeProperty(x_display_, requestor, property, gfx::GetAtom(kIncr), 32,
                       PropModeReplace,
                       reinterpret_cast<unsigned char*>(&length), 1);
 
       // Wait for the selection requestor to indicate that it has processed
       // the selection result before sending the first chunk of data. The
       // selection requestor indicates this by deleting |property|.
       base::TimeTicks timeout =
           base::TimeTicks::Now() +
           base::TimeDelta::FromMilliseconds(kIncrementalTransferTimeoutMs);
       incremental_transfers_.push_back(IncrementalTransfer(
@@ skipping 104 matching lines @@
 SelectionOwner::IncrementalTransfer::IncrementalTransfer(
     IncrementalTransfer&& other) = default;
 
 SelectionOwner::IncrementalTransfer& SelectionOwner::IncrementalTransfer::
 operator=(IncrementalTransfer&&) = default;
 
 SelectionOwner::IncrementalTransfer::~IncrementalTransfer() {
 }
 
 }  // namespace ui