Move ui::GetAtom to gfx::GetAtom

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";
@@ skipping 28 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_ = GetAtom(kClipboard);
+    clipboard_atom_ = gfx::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 56 matching lines @@
        it != atoms.end(); ++it) {
     if (ContainsAtom(*it))
       return true;
   }
 
   return false;
 }
 
 bool TargetList::ContainsFormat(
     const Clipboard::FormatType& format_type) const {
-  ::Atom atom = GetAtom(format_type.ToString().c_str());
+  ::Atom atom = gfx::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 134 matching lines @@
                               -100,
                               10,
                               10,              // x, y, width, height
                               0,               // border width
                               CopyFromParent,  // depth
                               InputOnly,
                               CopyFromParent,  // visual
                               0,
                               NULL)),
       selection_requestor_(x_display_, x_window_, this),
-      clipboard_owner_(x_display_, x_window_, GetAtom(kClipboard)),
+      clipboard_owner_(x_display_, x_window_, gfx::GetAtom(kClipboard)),
       primary_owner_(x_display_, x_window_, XA_PRIMARY) {
   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 GetAtom(kClipboard);
+  return gfx::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 = GetAtom(key.c_str());
+  ::Atom atom_key = gfx::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 11 matching lines @@
          it != types.end(); ++it) {
       SelectionFormatMap::const_iterator format_map_it = format_map.find(*it);
       if (format_map_it != format_map.end())
         return SelectionData(format_map_it->first, format_map_it->second);
     }
   } else {
     TargetList targets = WaitAndGetTargetsList(type);
 
     ::Atom selection_name = LookupSelectionForClipboardType(type);
     std::vector< ::Atom> intersection;
-    ui::GetAtomIntersection(types, targets.target_list(), &intersection);
+    GetAtomIntersection(types, targets.target_list(), &intersection);
     return selection_requestor_.RequestAndWaitForTypes(selection_name,
                                                        intersection);
   }
 
   return SelectionData();
 }
 
 TargetList ClipboardAuraX11::AuraX11Details::WaitAndGetTargetsList(
     ClipboardType type) {
   ::Atom selection_name = LookupSelectionForClipboardType(type);
   std::vector< ::Atom> out;
   if (XGetSelectionOwner(x_display_, selection_name) == x_window_) {
     // We can local fastpath and return the list of local targets.
     const SelectionFormatMap& format_map = LookupStorageForAtom(selection_name);
 
     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, GetAtom(kTargets), &data, &out_data_items,
+            selection_name, gfx::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 == GetAtom(kTargets)) {
+      if (out_type == XA_ATOM || out_type == gfx::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
@@ skipping 18 matching lines @@
   return TargetList(out);
 }
 
 std::vector<::Atom> ClipboardAuraX11::AuraX11Details::GetTextAtoms() const {
   return GetTextAtomsFrom();
 }
 
 std::vector<::Atom> ClipboardAuraX11::AuraX11Details::GetAtomsForFormat(
     const Clipboard::FormatType& format) {
   std::vector< ::Atom> atoms;
-  atoms.push_back(GetAtom(format.ToString().c_str()));
+  atoms.push_back(gfx::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 = GetAtom(kClipboardManager);
+  ::Atom clipboard_manager_atom = gfx::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(
-      GetAtom(kClipboardManager), GetAtom(kSaveTargets), targets);
+      gfx::GetAtom(kClipboardManager), gfx::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