Remove usages of XInternAtom

ui/base/clipboard/clipboard_aurax11.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/base/clipboard/clipboard_aurax11.h"
 
 #include <X11/Xatom.h>
 #include <X11/extensions/Xfixes.h>
 #include <stdint.h>
 
@@ skipping 16 matching lines @@
 #include "ui/base/x/selection_owner.h"
 #include "ui/base/x/selection_requestor.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/platform_event_dispatcher.h"
 #include "ui/events/platform/platform_event_observer.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/size.h"
-#include "ui/gfx/x/x11_atom_cache.h"
 
 namespace ui {
 
 namespace {
 
 const char kClipboard[] = "CLIPBOARD";
 const char kClipboardManager[] = "CLIPBOARD_MANAGER";
 const char kMimeTypeFilename[] = "chromium/filename";
 const char kSaveTargets[] = "SAVE_TARGETS";
 const char kTargets[] = "TARGETS";
 
-const char* kAtomsToCache[] = {kClipboard,
-                               kClipboardManager,
-                               Clipboard::kMimeTypePNG,
-                               kMimeTypeFilename,
-                               Clipboard::kMimeTypeMozillaURL,
-                               Clipboard::kMimeTypeWebkitSmartPaste,
-                               kSaveTargets,
-                               kString,
-                               kTargets,
-                               kText,
-                               kUtf8String,
-                               nullptr};
-
 ///////////////////////////////////////////////////////////////////////////////
 
 // Uses the XFixes API to provide sequence numbers for GetSequenceNumber().
 class SelectionChangeObserver : public ui::PlatformEventObserver {
  public:
   static SelectionChangeObserver* GetInstance();
 
   uint64_t clipboard_sequence_number() const {
     return clipboard_sequence_number_;
   }
@@ skipping 17 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SelectionChangeObserver);
 };
 
 SelectionChangeObserver::SelectionChangeObserver()
     : event_base_(-1),
       clipboard_atom_(None),
       clipboard_sequence_number_(0),
       primary_sequence_number_(0) {
   int ignored;
   if (XFixesQueryExtension(gfx::GetXDisplay(), &event_base_, &ignored)) {
-    clipboard_atom_ = XInternAtom(gfx::GetXDisplay(), kClipboard, false);
+    clipboard_atom_ = GetAtom(kClipboard);
     XFixesSelectSelectionInput(gfx::GetXDisplay(), GetX11RootWindow(),
                                clipboard_atom_,
                                XFixesSetSelectionOwnerNotifyMask |
                                XFixesSelectionWindowDestroyNotifyMask |
                                XFixesSelectionClientCloseNotifyMask);
     // This seems to be semi-optional. For some reason, registering for any
     // selection notify events seems to subscribe us to events for both the
     // primary and the clipboard buffers. Register anyway just to be safe.
     XFixesSelectSelectionInput(gfx::GetXDisplay(), GetX11RootWindow(),
                                XA_PRIMARY,
@@ skipping 28 matching lines @@
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Represents a list of possible return types. Copy constructable.
 class TargetList {
  public:
   typedef std::vector< ::Atom> AtomVector;
 
-  TargetList(const AtomVector& target_list, X11AtomCache* atom_cache);
+  explicit TargetList(const AtomVector& target_list);
 
   const AtomVector& target_list() { return target_list_; }
 
   bool ContainsText() const;
   bool ContainsFormat(const Clipboard::FormatType& format_type) const;
   bool ContainsAtom(::Atom atom) const;
 
  private:
   AtomVector target_list_;
-  X11AtomCache* atom_cache_;
 };
 
-TargetList::TargetList(const AtomVector& target_list,
-                       X11AtomCache* atom_cache)
-    : target_list_(target_list),
-      atom_cache_(atom_cache) {
-}
+TargetList::TargetList(const AtomVector& target_list)
+    : target_list_(target_list) {}
 
 bool TargetList::ContainsText() const {
-  std::vector< ::Atom> atoms = GetTextAtomsFrom(atom_cache_);
+  std::vector<::Atom> atoms = GetTextAtomsFrom();
   for (std::vector< ::Atom>::const_iterator it = atoms.begin();
        it != atoms.end(); ++it) {
     if (ContainsAtom(*it))
       return true;
   }
 
   return false;
 }
 
 bool TargetList::ContainsFormat(
     const Clipboard::FormatType& format_type) const {
-  ::Atom atom = atom_cache_->GetAtom(format_type.ToString().c_str());
+  ::Atom atom = GetAtom(format_type.ToString().c_str());
   return ContainsAtom(atom);
 }
 
 bool TargetList::ContainsAtom(::Atom atom) const {
   return find(target_list_.begin(), target_list_.end(), atom)
       != target_list_.end();
 }
 
 }  // namespace
 
@@ skipping 35 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 // ClipboardAuraX11::AuraX11Details
 
 // Private implementation of our X11 integration. Keeps X11 headers out of the
 // majority of chrome, which break badly.
 class ClipboardAuraX11::AuraX11Details : public PlatformEventDispatcher {
  public:
   AuraX11Details();
   ~AuraX11Details() override;
 
-  X11AtomCache* atom_cache() { return &atom_cache_; }
-
   // Returns the X11 type that we pass to various XSelection functions for the
   // given type.
   ::Atom LookupSelectionForClipboardType(ClipboardType type) const;
 
   // Returns the X11 type that we pass to various XSelection functions for
   // CLIPBOARD_TYPE_COPY_PASTE.
   ::Atom GetCopyPasteSelection() const;
 
   // Finds the SelectionFormatMap for the incoming selection atom.
   const SelectionFormatMap& LookupStorageForAtom(::Atom atom);
@@ skipping 50 matching lines @@
   // Our X11 state.
   Display* x_display_;
   ::Window x_root_window_;
 
   // Input-only window used as a selection owner.
   ::Window x_window_;
 
   // Events selected on |x_window_|.
   std::unique_ptr<XScopedEventSelector> x_window_events_;
 
-  X11AtomCache atom_cache_;
-
   // Object which requests and receives selection data.
   SelectionRequestor selection_requestor_;
 
   // Temporary target map that we write to during DispatchObects.
   SelectionFormatMap clipboard_data_;
 
   // Objects which offer selection data to other windows.
   SelectionOwner clipboard_owner_;
   SelectionOwner primary_owner_;
 
   DISALLOW_COPY_AND_ASSIGN(AuraX11Details);
 };
 
 ClipboardAuraX11::AuraX11Details::AuraX11Details()
     : x_display_(gfx::GetXDisplay()),
       x_root_window_(DefaultRootWindow(x_display_)),
       x_window_(XCreateWindow(x_display_,
                               x_root_window_,
                               -100,
                               -100,
                               10,
                               10,              // x, y, width, height
                               0,               // border width
                               CopyFromParent,  // depth
                               InputOnly,
                               CopyFromParent,  // visual
                               0,
                               NULL)),
-      atom_cache_(x_display_, kAtomsToCache),
       selection_requestor_(x_display_, x_window_, this),
-      clipboard_owner_(x_display_, x_window_, atom_cache_.GetAtom(kClipboard)),
+      clipboard_owner_(x_display_, x_window_, GetAtom(kClipboard)),
       primary_owner_(x_display_, x_window_, XA_PRIMARY) {
-  // We don't know all possible MIME types at compile time.
-  atom_cache_.allow_uncached_atoms();
-
   XStoreName(x_display_, x_window_, "Chromium clipboard");
   x_window_events_.reset(
       new XScopedEventSelector(x_window_, PropertyChangeMask));
 
   if (PlatformEventSource::GetInstance())
     PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
 }
 
 ClipboardAuraX11::AuraX11Details::~AuraX11Details() {
   if (PlatformEventSource::GetInstance())
     PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
 
   XDestroyWindow(x_display_, x_window_);
 }
 
 ::Atom ClipboardAuraX11::AuraX11Details::LookupSelectionForClipboardType(
     ClipboardType type) const {
   if (type == CLIPBOARD_TYPE_COPY_PASTE)
     return GetCopyPasteSelection();
 
   return XA_PRIMARY;
 }
 
 ::Atom ClipboardAuraX11::AuraX11Details::GetCopyPasteSelection() const {
-  return atom_cache_.GetAtom(kClipboard);
+  return GetAtom(kClipboard);
 }
 
 const SelectionFormatMap&
 ClipboardAuraX11::AuraX11Details::LookupStorageForAtom(::Atom atom) {
   if (atom == XA_PRIMARY)
     return primary_owner_.selection_format_map();
 
   DCHECK_EQ(GetCopyPasteSelection(), atom);
   return clipboard_owner_.selection_format_map();
 }
 
 void ClipboardAuraX11::AuraX11Details::CreateNewClipboardData() {
   clipboard_data_ = SelectionFormatMap();
 }
 
 void ClipboardAuraX11::AuraX11Details::InsertMapping(
     const std::string& key,
     const scoped_refptr<base::RefCountedMemory>& memory) {
-  ::Atom atom_key = atom_cache_.GetAtom(key.c_str());
+  ::Atom atom_key = GetAtom(key.c_str());
   clipboard_data_.Insert(atom_key, memory);
 }
 
 void ClipboardAuraX11::AuraX11Details::TakeOwnershipOfSelection(
     ClipboardType type) {
   if (type == CLIPBOARD_TYPE_COPY_PASTE)
     return clipboard_owner_.TakeOwnershipOfSelection(clipboard_data_);
   else
     return primary_owner_.TakeOwnershipOfSelection(clipboard_data_);
 }
@@ skipping 37 matching lines @@
     for (SelectionFormatMap::const_iterator it = format_map.begin();
          it != format_map.end(); ++it) {
       out.push_back(it->first);
     }
   } else {
     scoped_refptr<base::RefCountedMemory> data;
     size_t out_data_items = 0;
     ::Atom out_type = None;
 
     if (selection_requestor_.PerformBlockingConvertSelection(
-            selection_name,
-            atom_cache_.GetAtom(kTargets),
-            &data,
-            &out_data_items,
+            selection_name, GetAtom(kTargets), &data, &out_data_items,
             &out_type)) {
       // Some apps return an |out_type| of "TARGETS". (crbug.com/377893)
-      if (out_type == XA_ATOM || out_type == atom_cache_.GetAtom(kTargets)) {
+      if (out_type == XA_ATOM || out_type == GetAtom(kTargets)) {
         const ::Atom* atom_array =
             reinterpret_cast<const ::Atom*>(data->front());
         for (size_t i = 0; i < out_data_items; ++i)
           out.push_back(atom_array[i]);
       }
     } else {
       // There was no target list. Most Java apps doesn't offer a TARGETS list,
       // even though they AWT to. They will offer individual text types if you
       // ask. If this is the case we attempt to make sense of the contents as
       // text. This is pretty unfortunate since it means we have to actually
       // copy the data to see if it is available, but at least this path
       // shouldn't be hit for conforming programs.
       std::vector< ::Atom> types = GetTextAtoms();
       for (std::vector< ::Atom>::const_iterator it = types.begin();
            it != types.end(); ++it) {
         ::Atom type = None;
         if (selection_requestor_.PerformBlockingConvertSelection(selection_name,
                                                                  *it,
                                                                  NULL,
                                                                  NULL,
                                                                  &type) &&
             type == *it) {
           out.push_back(*it);
         }
       }
     }
   }
 
-  return TargetList(out, &atom_cache_);
+  return TargetList(out);
 }
 
 std::vector<::Atom> ClipboardAuraX11::AuraX11Details::GetTextAtoms() const {
-  return GetTextAtomsFrom(&atom_cache_);
+  return GetTextAtomsFrom();
 }
 
 std::vector<::Atom> ClipboardAuraX11::AuraX11Details::GetAtomsForFormat(
     const Clipboard::FormatType& format) {
   std::vector< ::Atom> atoms;
-  atoms.push_back(atom_cache_.GetAtom(format.ToString().c_str()));
+  atoms.push_back(GetAtom(format.ToString().c_str()));
   return atoms;
 }
 
 void ClipboardAuraX11::AuraX11Details::Clear(ClipboardType type) {
   if (type == CLIPBOARD_TYPE_COPY_PASTE)
     clipboard_owner_.ClearSelectionOwner();
   else
     primary_owner_.ClearSelectionOwner();
 }
 
 void ClipboardAuraX11::AuraX11Details::StoreCopyPasteDataAndWait() {
   ::Atom selection = GetCopyPasteSelection();
   if (XGetSelectionOwner(x_display_, selection) != x_window_)
     return;
 
-  ::Atom clipboard_manager_atom = atom_cache_.GetAtom(kClipboardManager);
+  ::Atom clipboard_manager_atom = GetAtom(kClipboardManager);
   if (XGetSelectionOwner(x_display_, clipboard_manager_atom) == None)
     return;
 
   const SelectionFormatMap& format_map = LookupStorageForAtom(selection);
   if (format_map.size() == 0)
     return;
   std::vector<Atom> targets = format_map.GetTypes();
 
   base::TimeTicks start = base::TimeTicks::Now();
   selection_requestor_.PerformBlockingConvertSelectionWithParameter(
-      atom_cache_.GetAtom(kClipboardManager),
-      atom_cache_.GetAtom(kSaveTargets),
-      targets);
+      GetAtom(kClipboardManager), GetAtom(kSaveTargets), targets);
   UMA_HISTOGRAM_TIMES("Clipboard.X11StoreCopyPasteDuration",
                       base::TimeTicks::Now() - start);
 }
 
 bool ClipboardAuraX11::AuraX11Details::CanDispatchEvent(
     const PlatformEvent& event) {
   if (event->xany.window == x_window_)
     return true;
 
   if (event->type == PropertyNotify) {
@@ skipping 414 matching lines @@
   if (format.Equals(GetBitmapFormatType()))
     return;
 
   std::vector<unsigned char> bytes(data_data, data_data + data_len);
   scoped_refptr<base::RefCountedMemory> mem(
       base::RefCountedBytes::TakeVector(&bytes));
   aurax11_details_->InsertMapping(format.ToString(), mem);
 }
 
 }  // namespace ui