Move ui::GetAtom to gfx::GetAtom

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>
 
 #include "base/event_types.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/drag_drop_client.h"
 #include "ui/aura/client/drag_drop_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/dragdrop/drop_target_event.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/dragdrop/os_exchange_data_provider_aurax11.h"
 #include "ui/base/layout.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/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/x/x11_atom_cache.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h"
 #include "ui/views/widget/desktop_aura/x11_topmost_window_finder.h"
 #include "ui/views/widget/desktop_aura/x11_whole_screen_move_loop.h"
 #include "ui/views/widget/widget.h"
 
 // Reading recommended for understanding the implementation in this file:
 //
 // * The X Window System Concepts section in The X New Developer’s Guide
 // * The X Selection Mechanism paper by Keith Packard
@@ skipping 259 matching lines @@
       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) {
-      if (!ui::GetAtomArrayProperty(source_window_,
-                                    kXdndTypeList,
+      if (!ui::GetAtomArrayProperty(source_window_, kXdndTypeList,
                                     &unfetched_targets_)) {
         return;
       }
     } else {
       // data.l[2,3,4] contain the first three types. Unused slots can be None.
       for (int i = 0; i < 3; ++i) {
         if (event.data.l[2 + i] != None) {
           unfetched_targets_.push_back(event.data.l[2 + i]);
         }
       }
@@ skipping 57 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(), ui::GetAtom(kXdndSelection), target,
-                    ui::GetAtom(kChromiumDragReciever), local_window_,
+  XConvertSelection(gfx::GetXDisplay(), gfx::GetAtom(kXdndSelection), target,
+                    gfx::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, ui::GetAtom(kChromiumDragReciever));
+    DCHECK_EQ(event.property, gfx::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
     // the formats advertised by the source. http://crbug.com/628099
     LOG(ERROR) << "XConvertSelection failed for source-advertised target "
                << event.target;
   }
 
   if (!unfetched_targets_.empty()) {
     RequestNextTarget();
   } else {
     waiting_to_handle_position_ = false;
     drag_drop_client_->CompleteXdndPosition(source_window_, screen_point_);
     drag_drop_client_ = NULL;
   }
 }
 
 void DesktopDragDropClientAuraX11::X11DragContext::ReadActions() {
   if (!source_client_) {
     std::vector<::Atom> atom_array;
-    if (!ui::GetAtomArrayProperty(source_window_,
-                                  kXdndActionList,
+    if (!ui::GetAtomArrayProperty(source_window_, kXdndActionList,
                                   &atom_array)) {
       actions_.clear();
     } else {
       actions_.swap(atom_array);
     }
   } else {
     // We have a property notify set up for other windows in case they change
     // their action list. Thankfully, the views interface is static and you
     // can't change the action list after you enter StartDragAndDrop().
     actions_ = source_client_->GetOfferedDragOperations();
   }
 }
 
 int DesktopDragDropClientAuraX11::X11DragContext::GetDragOperation() const {
   int drag_operation = ui::DragDropTypes::DRAG_NONE;
   for (std::vector<::Atom>::const_iterator it = actions_.begin();
        it != actions_.end(); ++it) {
     MaskOperation(*it, &drag_operation);
   }
 
   MaskOperation(suggested_action_, &drag_operation);
 
   return drag_operation;
 }
 
 void DesktopDragDropClientAuraX11::X11DragContext::MaskOperation(
     ::Atom xdnd_operation,
     int* drag_operation) const {
-  if (xdnd_operation == ui::GetAtom(kXdndActionCopy))
+  if (xdnd_operation == gfx::GetAtom(kXdndActionCopy))
     *drag_operation |= ui::DragDropTypes::DRAG_COPY;
-  else if (xdnd_operation == ui::GetAtom(kXdndActionMove))
+  else if (xdnd_operation == gfx::GetAtom(kXdndActionMove))
     *drag_operation |= ui::DragDropTypes::DRAG_MOVE;
-  else if (xdnd_operation == ui::GetAtom(kXdndActionLink))
+  else if (xdnd_operation == gfx::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 == ui::GetAtom(kXdndActionList)) {
+      event->xproperty.atom == gfx::GetAtom(kXdndActionList)) {
     ReadActions();
     return ui::POST_DISPATCH_STOP_PROPAGATION;
   }
   return ui::POST_DISPATCH_NONE;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 DesktopDragDropClientAuraX11::DesktopDragDropClientAuraX11(
     aura::Window* root_window,
@@ skipping 13 matching lines @@
       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_, ui::GetAtom(kXdndAware), XA_ATOM, 32,
+  XChangeProperty(xdisplay_, xwindow_, gfx::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();
 
@@ skipping 189 matching lines @@
 
       drag_operation = delegate->OnPerformDrop(event);
     }
 
     target_window_->RemoveObserver(this);
     target_window_ = NULL;
   }
 
   XEvent xev;
   xev.xclient.type = ClientMessage;
-  xev.xclient.message_type = ui::GetAtom(kXdndFinished);
+  xev.xclient.message_type = gfx::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(ui::GetAtom(kXdndActionDirectSave));
+    actions.push_back(gfx::GetAtom(kXdndActionDirectSave));
     ui::SetStringProperty(
-        xwindow_, ui::GetAtom(kXdndDirectSave0),
-        ui::GetAtom(ui::Clipboard::kMimeTypeText),
+        xwindow_, gfx::GetAtom(kXdndDirectSave0),
+        gfx::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_, ui::GetAtom(kXdndActionList));
-    XDeleteProperty(xdisplay_, xwindow_, ui::GetAtom(kXdndDirectSave0));
+    XDeleteProperty(xdisplay_, xwindow_, gfx::GetAtom(kXdndActionList));
+    XDeleteProperty(xdisplay_, xwindow_, gfx::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 == ui::GetAtom(kXdndEnter)) {
+    if (message_type == gfx::GetAtom(kXdndEnter)) {
       short_circuit->OnXdndEnter(xev->xclient);
       return;
-    } else if (message_type == ui::GetAtom(kXdndLeave)) {
+    } else if (message_type == gfx::GetAtom(kXdndLeave)) {
       short_circuit->OnXdndLeave(xev->xclient);
       return;
-    } else if (message_type == ui::GetAtom(kXdndPosition)) {
+    } else if (message_type == gfx::GetAtom(kXdndPosition)) {
       short_circuit->OnXdndPosition(xev->xclient);
       return;
-    } else if (message_type == ui::GetAtom(kXdndStatus)) {
+    } else if (message_type == gfx::GetAtom(kXdndStatus)) {
       short_circuit->OnXdndStatus(xev->xclient);
       return;
-    } else if (message_type == ui::GetAtom(kXdndFinished)) {
+    } else if (message_type == gfx::GetAtom(kXdndFinished)) {
       short_circuit->OnXdndFinished(xev->xclient);
       return;
-    } else if (message_type == ui::GetAtom(kXdndDrop)) {
+    } else if (message_type == gfx::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 ui::GetAtom(kXdndActionCopy);
+    return gfx::GetAtom(kXdndActionCopy);
   if (drag_operation & ui::DragDropTypes::DRAG_MOVE)
-    return ui::GetAtom(kXdndActionMove);
+    return gfx::GetAtom(kXdndActionMove);
   if (drag_operation & ui::DragDropTypes::DRAG_LINK)
-    return ui::GetAtom(kXdndActionLink);
+    return gfx::GetAtom(kXdndActionLink);
 
   return None;
 }
 
 ui::DragDropTypes::DragOperation
 DesktopDragDropClientAuraX11::AtomToDragOperation(::Atom atom) {
-  if (atom == ui::GetAtom(kXdndActionCopy))
+  if (atom == gfx::GetAtom(kXdndActionCopy))
     return ui::DragDropTypes::DRAG_COPY;
-  if (atom == ui::GetAtom(kXdndActionMove))
+  if (atom == gfx::GetAtom(kXdndActionMove))
     return ui::DragDropTypes::DRAG_MOVE;
-  if (atom == ui::GetAtom(kXdndActionLink))
+  if (atom == gfx::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(ui::GetAtom(kXdndActionCopy));
+    operations.push_back(gfx::GetAtom(kXdndActionCopy));
   if (drag_operation_ & ui::DragDropTypes::DRAG_MOVE)
-    operations.push_back(ui::GetAtom(kXdndActionMove));
+    operations.push_back(gfx::GetAtom(kXdndActionMove));
   if (drag_operation_ & ui::DragDropTypes::DRAG_LINK)
-    operations.push_back(ui::GetAtom(kXdndActionLink));
+    operations.push_back(gfx::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 = ui::GetAtom(kXdndStatus);
+  xev.xclient.message_type = gfx::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 = ui::GetAtom(kXdndEnter);
+  xev.xclient.message_type = gfx::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 = ui::GetAtom(kXdndLeave);
+  xev.xclient.message_type = gfx::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 = ui::GetAtom(kXdndPosition);
+  xev.xclient.message_type = gfx::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 = ui::GetAtom(kXdndDrop);
+  xev.xclient.message_type = gfx::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