Remove usages of XInternAtom

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"
 
 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";
 const char kTimestamp[] = "TIMESTAMP";
 
-const char* kAtomsToCache[] = {kAtomPair, kIncr,      kMultiple, kSaveTargets,
-                               kTargets,  kTimestamp, NULL};
-
 // The period of |incremental_transfer_abort_timer_|. Arbitrary but must be <=
 // than kIncrementalTransferTimeoutMs.
 const int kTimerPeriodMs = 1000;
 
 // The amount of time to wait for the selection requestor to process the data
 // sent by the selection owner before aborting an incremental data transfer.
 const int kIncrementalTransferTimeoutMs = 10000;
 
 static_assert(kTimerPeriodMs <= kIncrementalTransferTimeoutMs,
               "timer period must be <= transfer timeout");
@@ skipping 49 matching lines @@
 }
 
 }  // namespace
 
 SelectionOwner::SelectionOwner(XDisplay* x_display,
                                XID x_window,
                                XAtom selection_name)
     : x_display_(x_display),
       x_window_(x_window),
       selection_name_(selection_name),
-      max_request_size_(GetMaxRequestSize(x_display)),
-      atom_cache_(x_display_, kAtomsToCache) {
-}
+      max_request_size_(GetMaxRequestSize(x_display)) {}
 
 SelectionOwner::~SelectionOwner() {
   // If we are the selection owner, we need to release the selection so we
   // don't receive further events. However, we don't call ClearSelectionOwner()
   // because we don't want to do this indiscriminately.
   if (XGetSelectionOwner(x_display_, selection_name_) == x_window_)
     XSetSelectionOwner(x_display_, selection_name_, None, CurrentTime);
 }
 
 void SelectionOwner::RetrieveTargets(std::vector<XAtom>* targets) {
@@ skipping 28 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 == atom_cache_.GetAtom(kMultiple)) {
+  if (requested_target == 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,
-          atom_cache_.GetAtom(kAtomPair),
-          32,
+          x_display_, requestor, requested_property, 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 21 matching lines @@
     return;
 
   ProcessIncrementalTransfer(&(*it));
   if (!it->data.get())
     CompleteIncrementalTransfer(it);
 }
 
 bool SelectionOwner::ProcessTarget(XAtom target,
                                    XID requestor,
                                    XAtom property) {
-  XAtom multiple_atom = atom_cache_.GetAtom(kMultiple);
-  XAtom save_targets_atom = atom_cache_.GetAtom(kSaveTargets);
-  XAtom targets_atom = atom_cache_.GetAtom(kTargets);
-  XAtom timestamp_atom = atom_cache_.GetAtom(kTimestamp);
+  XAtom multiple_atom = GetAtom(kMultiple);
+  XAtom save_targets_atom = GetAtom(kSaveTargets);
+  XAtom targets_atom = GetAtom(kTargets);
+  XAtom timestamp_atom = 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,
-                      atom_cache_.GetAtom(kIncr),
-                      32,
+      XChangeProperty(x_display_, requestor, property, GetAtom(kIncr), 32,
                       PropModeReplace,
-                      reinterpret_cast<unsigned char*>(&length),
-                      1);
+                      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(
           requestor, target, property,
           base::MakeUnique<XScopedEventSelector>(requestor, PropertyChangeMask),
@@ skipping 102 matching lines @@
 SelectionOwner::IncrementalTransfer::IncrementalTransfer(
     IncrementalTransfer&& other) = default;
 
 SelectionOwner::IncrementalTransfer& SelectionOwner::IncrementalTransfer::
 operator=(IncrementalTransfer&&) = default;
 
 SelectionOwner::IncrementalTransfer::~IncrementalTransfer() {
 }
 
 }  // namespace ui