Remove usages of XInternAtom

ui/views/widget/desktop_aura/desktop_drag_drop_client_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/views/widget/desktop_aura/desktop_drag_drop_client_aurax11.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <X11/Xatom.h>
 
@@ skipping 57 matching lines @@
 constexpr int kMaxXdndVersion = 5;
 
 constexpr int kWillAcceptDrop = 1;
 constexpr int kWantFurtherPosEvents = 2;
 
 // These actions have the same meaning as in the W3C Drag and Drop spec.
 const char kXdndActionCopy[] = "XdndActionCopy";
 const char kXdndActionMove[] = "XdndActionMove";
 const char kXdndActionLink[] = "XdndActionLink";
 
-// "The target will do something that the source would not understand." The
-// source only needs to provide a copy of the dragged data.
-const char kXdndActionPrivate[] = "XdndActionPrivate";
-
-// The target should ask the user what action it wants to perform. Intended to
-// match Windows' right-click drag and drop, which shows a dropdown.
-const char kXdndActionAsk[] = "XdndActionAsk";
-
 // Triggers the XDS protocol.
 const char kXdndActionDirectSave[] = "XdndActionDirectSave";
 
 // Window property that will receive the drag and drop selection data.
 const char kChromiumDragReciever[] = "_CHROMIUM_DRAG_RECEIVER";
 
 // Window property that contains the possible actions that will be presented to
 // the user when the drag and drop action is kXdndActionAsk.
 const char kXdndActionList[] = "XdndActionList";
 
@@ skipping 52 matching lines @@
 // information.
 // After the target optionally acquires selection information, it must tell the
 // source if it can accept the drop via an XdndStatus message.
 const char kXdndPosition[] = "XdndPosition";
 
 // Message sent by the XDND target in response to an XdndPosition message.
 // The message informs the source if the target will accept the drop, and what
 // action will be taken if the drop is accepted.
 const char kXdndStatus[] = "XdndStatus";
 
-const char* kAtomsToCache[] = {
-  kChromiumDragReciever,
-  kXdndActionAsk,
-  kXdndActionCopy,
-  kXdndActionDirectSave,
-  kXdndActionLink,
-  kXdndActionList,
-  kXdndActionMove,
-  kXdndActionPrivate,
-  kXdndAware,
-  kXdndDirectSave0,
-  kXdndDrop,
-  kXdndEnter,
-  kXdndFinished,
-  kXdndLeave,
-  kXdndPosition,
-  kXdndProxy,
-  kXdndSelection,
-  kXdndStatus,
-  kXdndTypeList,
-  ui::Clipboard::kMimeTypeText,
-  NULL
-};
-
 int XGetModifiers() {
   XDisplay* display = gfx::GetXDisplay();
 
   XID root, child;
   int root_x, root_y, win_x, win_y;
   unsigned int mask;
   XQueryPointer(display,
                 DefaultRootWindow(display),
                 &root,
                 &child,
@@ skipping 43 matching lines @@
 }  // namespace
 
 namespace views {
 
 DesktopDragDropClientAuraX11*
 DesktopDragDropClientAuraX11::g_current_drag_drop_client = NULL;
 
 class DesktopDragDropClientAuraX11::X11DragContext
     : public ui::PlatformEventDispatcher {
  public:
-  X11DragContext(ui::X11AtomCache* atom_cache,
-                 ::Window local_window,
-                 const XClientMessageEvent& event);
+  X11DragContext(::Window local_window, const XClientMessageEvent& event);
   ~X11DragContext() override;
 
   // When we receive an XdndPosition message, we need to have all the data
   // copied from the other window before we process the XdndPosition
   // message. If we have that data already, dispatch immediately. Otherwise,
   // delay dispatching until we do.
   void OnXdndPositionMessage(DesktopDragDropClientAuraX11* client,
                                   ::Atom suggested_action,
                                   ::Window source_window,
                                   ::Time time_stamp,
@@ skipping 22 matching lines @@
   void RequestNextTarget();
 
   // Masks the X11 atom |xdnd_operation|'s views representation onto
   // |drag_operation|.
   void MaskOperation(::Atom xdnd_operation, int* drag_operation) const;
 
   // ui::PlatformEventDispatcher:
   bool CanDispatchEvent(const ui::PlatformEvent& event) override;
   uint32_t DispatchEvent(const ui::PlatformEvent& event) override;
 
-  // The atom cache owned by our parent.
-  ui::X11AtomCache* atom_cache_;
-
   // The XID of our chrome local aura window handling our events.
   ::Window local_window_;
 
   // The XID of the window that's initiated the drag.
   unsigned long source_window_;
 
   // Events that we have selected on |source_window_|.
   std::unique_ptr<ui::XScopedEventSelector> source_window_events_;
 
   // The DesktopDragDropClientAuraX11 for |source_window_| if |source_window_|
@@ skipping 26 matching lines @@
   // use this, instead of the XdndActionList which is backed by |actions_|.
   ::Atom suggested_action_;
 
   // Possible actions.
   std::vector<::Atom> actions_;
 
   DISALLOW_COPY_AND_ASSIGN(X11DragContext);
 };
 
 DesktopDragDropClientAuraX11::X11DragContext::X11DragContext(
-    ui::X11AtomCache* atom_cache,
     ::Window local_window,
     const XClientMessageEvent& event)
-    : atom_cache_(atom_cache),
-      local_window_(local_window),
+    : local_window_(local_window),
       source_window_(event.data.l[0]),
       source_client_(
           DesktopDragDropClientAuraX11::GetForWindow(source_window_)),
       drag_drop_client_(NULL),
       waiting_to_handle_position_(false),
       suggested_action_(None) {
   if (!source_client_) {
     bool get_types_from_property = ((event.data.l[1] & 1) != 0);
 
     if (get_types_from_property) {
@@ skipping 69 matching lines @@
 }
 
 void DesktopDragDropClientAuraX11::X11DragContext::RequestNextTarget() {
   DCHECK(!unfetched_targets_.empty());
   DCHECK(drag_drop_client_);
   DCHECK(waiting_to_handle_position_);
 
   ::Atom target = unfetched_targets_.back();
   unfetched_targets_.pop_back();
 
-  XConvertSelection(gfx::GetXDisplay(),
-                    atom_cache_->GetAtom(kXdndSelection),
-                    target,
-                    atom_cache_->GetAtom(kChromiumDragReciever),
-                    local_window_,
+  XConvertSelection(gfx::GetXDisplay(), ui::GetAtom(kXdndSelection), target,
+                    ui::GetAtom(kChromiumDragReciever), local_window_,
                     position_time_stamp_);
 }
 
 void DesktopDragDropClientAuraX11::X11DragContext::OnSelectionNotify(
     const XSelectionEvent& event) {
   if (!waiting_to_handle_position_) {
     // A misbehaved window may send SelectionNotify without us requesting data
     // via XConvertSelection().
     return;
   }
   DCHECK(drag_drop_client_);
 
   DVLOG(1) << "SelectionNotify, format " << event.target;
 
   if (event.property != None) {
-    DCHECK_EQ(event.property, atom_cache_->GetAtom(kChromiumDragReciever));
+    DCHECK_EQ(event.property, ui::GetAtom(kChromiumDragReciever));
 
     scoped_refptr<base::RefCountedMemory> data;
     ::Atom type = None;
     if (ui::GetRawBytesOfProperty(local_window_, event.property,
                                   &data, NULL, &type)) {
       fetched_targets_.Insert(event.target, data);
     }
   } else {
     // The source failed to convert the drop data to the format (target in X11
     // parlance) that we asked for. This happens, even though we only ask for
@@ skipping 37 matching lines @@
   }
 
   MaskOperation(suggested_action_, &drag_operation);
 
   return drag_operation;
 }
 
 void DesktopDragDropClientAuraX11::X11DragContext::MaskOperation(
     ::Atom xdnd_operation,
     int* drag_operation) const {
-  if (xdnd_operation == atom_cache_->GetAtom(kXdndActionCopy))
+  if (xdnd_operation == ui::GetAtom(kXdndActionCopy))
     *drag_operation |= ui::DragDropTypes::DRAG_COPY;
-  else if (xdnd_operation == atom_cache_->GetAtom(kXdndActionMove))
+  else if (xdnd_operation == ui::GetAtom(kXdndActionMove))
     *drag_operation |= ui::DragDropTypes::DRAG_MOVE;
-  else if (xdnd_operation == atom_cache_->GetAtom(kXdndActionLink))
+  else if (xdnd_operation == ui::GetAtom(kXdndActionLink))
     *drag_operation |= ui::DragDropTypes::DRAG_LINK;
 }
 
 bool DesktopDragDropClientAuraX11::X11DragContext::CanDispatchEvent(
     const ui::PlatformEvent& event) {
   return event->xany.window == source_window_;
 }
 
 uint32_t DesktopDragDropClientAuraX11::X11DragContext::DispatchEvent(
     const ui::PlatformEvent& event) {
   if (event->type == PropertyNotify &&
-      event->xproperty.atom == atom_cache_->GetAtom(kXdndActionList)) {
+      event->xproperty.atom == ui::GetAtom(kXdndActionList)) {
     ReadActions();
     return ui::POST_DISPATCH_STOP_PROPAGATION;
   }
   return ui::POST_DISPATCH_NONE;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 DesktopDragDropClientAuraX11::DesktopDragDropClientAuraX11(
     aura::Window* root_window,
     views::DesktopNativeCursorManager* cursor_manager,
     Display* xdisplay,
     ::Window xwindow)
     : root_window_(root_window),
       cursor_manager_(cursor_manager),
       xdisplay_(xdisplay),
       xwindow_(xwindow),
-      atom_cache_(xdisplay_, kAtomsToCache),
       current_modifier_state_(ui::EF_NONE),
       target_window_(NULL),
       waiting_on_status_(false),
       status_received_since_enter_(false),
       source_provider_(NULL),
       source_current_window_(None),
       source_state_(SOURCE_STATE_OTHER),
       drag_operation_(0),
       negotiated_operation_(ui::DragDropTypes::DRAG_NONE),
       weak_ptr_factory_(this) {
   // Some tests change the DesktopDragDropClientAuraX11 associated with an
   // |xwindow|.
   g_live_client_map.Get()[xwindow] = this;
 
   // Mark that we are aware of drag and drop concepts.
   unsigned long xdnd_version = kMaxXdndVersion;
-  XChangeProperty(xdisplay_, xwindow_, atom_cache_.GetAtom(kXdndAware),
-                  XA_ATOM, 32, PropModeReplace,
+  XChangeProperty(xdisplay_, xwindow_, ui::GetAtom(kXdndAware), XA_ATOM, 32,
+                  PropModeReplace,
                   reinterpret_cast<unsigned char*>(&xdnd_version), 1);
 }
 
 DesktopDragDropClientAuraX11::~DesktopDragDropClientAuraX11() {
   // This is necessary when the parent native widget gets destroyed while a drag
   // operation is in progress.
   move_loop_->EndMoveLoop();
   NotifyDragLeave();
 
   g_live_client_map.Get().erase(xwindow_);
@@ skipping 28 matching lines @@
   if (version > kMaxXdndVersion) {
     // The XDND version used should be the minimum between the versions
     // advertised by the source and the target. We advertise kMaxXdndVersion, so
     // this should never happen when talking to an XDND-compliant application.
     LOG(ERROR) << "XdndEnter message discarded because its version is too new.";
     return;
   }
 
   // Make sure that we've run ~X11DragContext() before creating another one.
   target_current_context_.reset();
-  target_current_context_.reset(
-      new X11DragContext(&atom_cache_, xwindow_, event));
+  target_current_context_.reset(new X11DragContext(xwindow_, event));
 
   // In the Windows implementation, we immediately call DesktopDropTargetWin::
   // Translate(). The XDND specification demands that we wait until we receive
   // an XdndPosition message before we use XConvertSelection or send an
   // XdndStatus message.
 }
 
 void DesktopDragDropClientAuraX11::OnXdndLeave(
     const XClientMessageEvent& event) {
   DVLOG(1) << "OnXdndLeave";
@@ skipping 139 matching lines @@
 
       drag_operation = delegate->OnPerformDrop(event);
     }
 
     target_window_->RemoveObserver(this);
     target_window_ = NULL;
   }
 
   XEvent xev;
   xev.xclient.type = ClientMessage;
-  xev.xclient.message_type = atom_cache_.GetAtom(kXdndFinished);
+  xev.xclient.message_type = ui::GetAtom(kXdndFinished);
   xev.xclient.format = 32;
   xev.xclient.window = source_window;
   xev.xclient.data.l[0] = xwindow_;
   xev.xclient.data.l[1] = (drag_operation != 0) ? 1 : 0;
   xev.xclient.data.l[2] = DragOperationToAtom(drag_operation);
 
   SendXClientEvent(source_window, &xev);
 }
 
 void DesktopDragDropClientAuraX11::OnSelectionNotify(
@@ skipping 28 matching lines @@
   negotiated_operation_ = ui::DragDropTypes::DRAG_NONE;
 
   const ui::OSExchangeData::Provider* provider = &data.provider();
   source_provider_ = static_cast<const ui::OSExchangeDataProviderAuraX11*>(
       provider);
 
   source_provider_->TakeOwnershipOfSelection();
 
   std::vector<::Atom> actions = GetOfferedDragOperations();
   if (!source_provider_->file_contents_name().empty()) {
-    actions.push_back(atom_cache_.GetAtom(kXdndActionDirectSave));
+    actions.push_back(ui::GetAtom(kXdndActionDirectSave));
     ui::SetStringProperty(
-        xwindow_,
-        atom_cache_.GetAtom(kXdndDirectSave0),
-        atom_cache_.GetAtom(ui::Clipboard::kMimeTypeText),
+        xwindow_, ui::GetAtom(kXdndDirectSave0),
+        ui::GetAtom(ui::Clipboard::kMimeTypeText),
         source_provider_->file_contents_name().AsUTF8Unsafe());
   }
   ui::SetAtomArrayProperty(xwindow_, kXdndActionList, "ATOM", actions);
 
   gfx::ImageSkia drag_image = source_provider_->GetDragImage();
   if (IsValidDragImage(drag_image)) {
     CreateDragWidget(drag_image);
     drag_widget_offset_ = source_provider_->GetDragImageOffset();
   }
 
@@ skipping 21 matching lines @@
                                 ui::DragDropTypes::DRAG_EVENT_SOURCE_COUNT);
     } else {
       UMA_HISTOGRAM_ENUMERATION("Event.DragDrop.Drop", source,
                                 ui::DragDropTypes::DRAG_EVENT_SOURCE_COUNT);
     }
     drag_widget_.reset();
 
     source_provider_ = NULL;
     g_current_drag_drop_client = NULL;
     drag_operation_ = 0;
-    XDeleteProperty(xdisplay_, xwindow_, atom_cache_.GetAtom(kXdndActionList));
-    XDeleteProperty(xdisplay_, xwindow_, atom_cache_.GetAtom(kXdndDirectSave0));
+    XDeleteProperty(xdisplay_, xwindow_, ui::GetAtom(kXdndActionList));
+    XDeleteProperty(xdisplay_, xwindow_, ui::GetAtom(kXdndDirectSave0));
 
     return negotiated_operation_;
   }
   UMA_HISTOGRAM_ENUMERATION("Event.DragDrop.Cancel", source,
                             ui::DragDropTypes::DRAG_EVENT_SOURCE_COUNT);
   return ui::DragDropTypes::DRAG_NONE;
 }
 
 void DesktopDragDropClientAuraX11::DragCancel() {
   move_loop_->EndMoveLoop();
@@ skipping 120 matching lines @@
 }
 
 void DesktopDragDropClientAuraX11::SendXClientEvent(::Window xid,
                                                     XEvent* xev) {
   DCHECK_EQ(ClientMessage, xev->type);
 
   // Don't send messages to the X11 message queue if we can help it.
   DesktopDragDropClientAuraX11* short_circuit = GetForWindow(xid);
   if (short_circuit) {
     Atom message_type = xev->xclient.message_type;
-    if (message_type == atom_cache_.GetAtom(kXdndEnter)) {
+    if (message_type == ui::GetAtom(kXdndEnter)) {
       short_circuit->OnXdndEnter(xev->xclient);
       return;
-    } else if (message_type == atom_cache_.GetAtom(kXdndLeave)) {
+    } else if (message_type == ui::GetAtom(kXdndLeave)) {
       short_circuit->OnXdndLeave(xev->xclient);
       return;
-    } else if (message_type == atom_cache_.GetAtom(kXdndPosition)) {
+    } else if (message_type == ui::GetAtom(kXdndPosition)) {
       short_circuit->OnXdndPosition(xev->xclient);
       return;
-    } else if (message_type == atom_cache_.GetAtom(kXdndStatus)) {
+    } else if (message_type == ui::GetAtom(kXdndStatus)) {
       short_circuit->OnXdndStatus(xev->xclient);
       return;
-    } else if (message_type == atom_cache_.GetAtom(kXdndFinished)) {
+    } else if (message_type == ui::GetAtom(kXdndFinished)) {
       short_circuit->OnXdndFinished(xev->xclient);
       return;
-    } else if (message_type == atom_cache_.GetAtom(kXdndDrop)) {
+    } else if (message_type == ui::GetAtom(kXdndDrop)) {
       short_circuit->OnXdndDrop(xev->xclient);
       return;
     }
   }
 
   // I don't understand why the GTK+ code is doing what it's doing here. It
   // goes out of its way to send the XEvent so that it receives a callback on
   // success or failure, and when it fails, it then sends an internal
   // GdkEvent about the failed drag. (And sending this message doesn't appear
   // to go through normal xlib machinery, but instead passes through the low
@@ skipping 117 matching lines @@
       aura::client::GetDragDropDelegate(target_window_);
   if (delegate)
     delegate->OnDragExited();
   target_window_->RemoveObserver(this);
   target_window_ = NULL;
 }
 
 ::Atom DesktopDragDropClientAuraX11::DragOperationToAtom(
     int drag_operation) {
   if (drag_operation & ui::DragDropTypes::DRAG_COPY)
-    return atom_cache_.GetAtom(kXdndActionCopy);
+    return ui::GetAtom(kXdndActionCopy);
   if (drag_operation & ui::DragDropTypes::DRAG_MOVE)
-    return atom_cache_.GetAtom(kXdndActionMove);
+    return ui::GetAtom(kXdndActionMove);
   if (drag_operation & ui::DragDropTypes::DRAG_LINK)
-    return atom_cache_.GetAtom(kXdndActionLink);
+    return ui::GetAtom(kXdndActionLink);
 
   return None;
 }
 
 ui::DragDropTypes::DragOperation
 DesktopDragDropClientAuraX11::AtomToDragOperation(::Atom atom) {
-  if (atom == atom_cache_.GetAtom(kXdndActionCopy))
+  if (atom == ui::GetAtom(kXdndActionCopy))
     return ui::DragDropTypes::DRAG_COPY;
-  if (atom == atom_cache_.GetAtom(kXdndActionMove))
+  if (atom == ui::GetAtom(kXdndActionMove))
     return ui::DragDropTypes::DRAG_MOVE;
-  if (atom == atom_cache_.GetAtom(kXdndActionLink))
+  if (atom == ui::GetAtom(kXdndActionLink))
     return ui::DragDropTypes::DRAG_LINK;
 
   return ui::DragDropTypes::DRAG_NONE;
 }
 
 std::vector<::Atom> DesktopDragDropClientAuraX11::GetOfferedDragOperations() {
   std::vector<::Atom> operations;
   if (drag_operation_ & ui::DragDropTypes::DRAG_COPY)
-    operations.push_back(atom_cache_.GetAtom(kXdndActionCopy));
+    operations.push_back(ui::GetAtom(kXdndActionCopy));
   if (drag_operation_ & ui::DragDropTypes::DRAG_MOVE)
-    operations.push_back(atom_cache_.GetAtom(kXdndActionMove));
+    operations.push_back(ui::GetAtom(kXdndActionMove));
   if (drag_operation_ & ui::DragDropTypes::DRAG_LINK)
-    operations.push_back(atom_cache_.GetAtom(kXdndActionLink));
+    operations.push_back(ui::GetAtom(kXdndActionLink));
   return operations;
 }
 
 ui::SelectionFormatMap DesktopDragDropClientAuraX11::GetFormatMap() const {
   return source_provider_ ? source_provider_->GetFormatMap() :
       ui::SelectionFormatMap();
 }
 
 void DesktopDragDropClientAuraX11::CompleteXdndPosition(
     ::Window source_window,
     const gfx::Point& screen_point) {
   int drag_operation = ui::DragDropTypes::DRAG_NONE;
   std::unique_ptr<ui::OSExchangeData> data;
   std::unique_ptr<ui::DropTargetEvent> drop_target_event;
   DragDropDelegate* delegate = NULL;
   DragTranslate(screen_point, &data, &drop_target_event, &delegate);
   if (delegate)
     drag_operation = delegate->OnDragUpdated(*drop_target_event);
 
   // Sends an XdndStatus message back to the source_window. l[2,3]
   // theoretically represent an area in the window where the current action is
   // the same as what we're returning, but I can't find any implementation that
   // actually making use of this. A client can return (0, 0) and/or set the
   // first bit of l[1] to disable the feature, and it appears that gtk neither
   // sets this nor respects it if set.
   XEvent xev;
   xev.xclient.type = ClientMessage;
-  xev.xclient.message_type = atom_cache_.GetAtom(kXdndStatus);
+  xev.xclient.message_type = ui::GetAtom(kXdndStatus);
   xev.xclient.format = 32;
   xev.xclient.window = source_window;
   xev.xclient.data.l[0] = xwindow_;
   xev.xclient.data.l[1] = (drag_operation != 0) ?
       (kWantFurtherPosEvents | kWillAcceptDrop) : 0;
   xev.xclient.data.l[2] = 0;
   xev.xclient.data.l[3] = 0;
   xev.xclient.data.l[4] = DragOperationToAtom(drag_operation);
 
   SendXClientEvent(source_window, &xev);
 }
 
 void DesktopDragDropClientAuraX11::SendXdndEnter(::Window dest_window) {
   XEvent xev;
   xev.xclient.type = ClientMessage;
-  xev.xclient.message_type = atom_cache_.GetAtom(kXdndEnter);
+  xev.xclient.message_type = ui::GetAtom(kXdndEnter);
   xev.xclient.format = 32;
   xev.xclient.window = dest_window;
   xev.xclient.data.l[0] = xwindow_;
   xev.xclient.data.l[1] = (kMaxXdndVersion << 24);  // The version number.
   xev.xclient.data.l[2] = 0;
   xev.xclient.data.l[3] = 0;
   xev.xclient.data.l[4] = 0;
 
   std::vector<Atom> targets;
   source_provider_->RetrieveTargets(&targets);
 
   if (targets.size() > 3) {
     xev.xclient.data.l[1] |= 1;
     ui::SetAtomArrayProperty(xwindow_, kXdndTypeList, "ATOM", targets);
   } else {
     // Pack the targets into the enter message.
     for (size_t i = 0; i < targets.size(); ++i)
       xev.xclient.data.l[2 + i] = targets[i];
   }
 
   SendXClientEvent(dest_window, &xev);
 }
 
 void DesktopDragDropClientAuraX11::SendXdndLeave(::Window dest_window) {
   XEvent xev;
   xev.xclient.type = ClientMessage;
-  xev.xclient.message_type = atom_cache_.GetAtom(kXdndLeave);
+  xev.xclient.message_type = ui::GetAtom(kXdndLeave);
   xev.xclient.format = 32;
   xev.xclient.window = dest_window;
   xev.xclient.data.l[0] = xwindow_;
   xev.xclient.data.l[1] = 0;
   xev.xclient.data.l[2] = 0;
   xev.xclient.data.l[3] = 0;
   xev.xclient.data.l[4] = 0;
   SendXClientEvent(dest_window, &xev);
 }
 
 void DesktopDragDropClientAuraX11::SendXdndPosition(
     ::Window dest_window,
     const gfx::Point& screen_point,
     unsigned long event_time) {
   waiting_on_status_ = true;
 
   XEvent xev;
   xev.xclient.type = ClientMessage;
-  xev.xclient.message_type = atom_cache_.GetAtom(kXdndPosition);
+  xev.xclient.message_type = ui::GetAtom(kXdndPosition);
   xev.xclient.format = 32;
   xev.xclient.window = dest_window;
   xev.xclient.data.l[0] = xwindow_;
   xev.xclient.data.l[1] = 0;
   xev.xclient.data.l[2] = (screen_point.x() << 16) | screen_point.y();
   xev.xclient.data.l[3] = event_time;
   xev.xclient.data.l[4] = DragOperationToAtom(drag_operation_);
   SendXClientEvent(dest_window, &xev);
 
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html and
   // the Xdnd protocol both recommend that drag events should be sent
   // periodically.
   repeat_mouse_move_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kRepeatMouseMoveTimeoutMs),
       base::Bind(&DesktopDragDropClientAuraX11::ProcessMouseMove,
                  base::Unretained(this),
                  screen_point,
                  event_time));
 }
 
 void DesktopDragDropClientAuraX11::SendXdndDrop(::Window dest_window) {
   XEvent xev;
   xev.xclient.type = ClientMessage;
-  xev.xclient.message_type = atom_cache_.GetAtom(kXdndDrop);
+  xev.xclient.message_type = ui::GetAtom(kXdndDrop);
   xev.xclient.format = 32;
   xev.xclient.window = dest_window;
   xev.xclient.data.l[0] = xwindow_;
   xev.xclient.data.l[1] = 0;
   xev.xclient.data.l[2] = CurrentTime;
   xev.xclient.data.l[3] = None;
   xev.xclient.data.l[4] = None;
   SendXClientEvent(dest_window, &xev);
 }
 
@@ skipping 44 matching lines @@
     for (int x = 0; x < in_bitmap->width(); ++x) {
       if (SkColorGetA(in_row[x]) > kMinAlpha)
         return true;
     }
   }
 
   return false;
 }
 
 }  // namespace views