Move ui::GetAtom to gfx::GetAtom

ui/views/widget/desktop_aura/desktop_window_tree_host_x11.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_window_tree_host_x11.h"
 
 #include <X11/extensions/shape.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xregion.h>
@@ skipping 30 matching lines @@
 #include "ui/events/event_utils.h"
 #include "ui/events/null_event_targeter.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/events/platform/x11/x11_event_source.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_rep.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/path_x11.h"
+#include "ui/gfx/x/x11_atom_cache.h"
 #include "ui/views/corewm/tooltip_aura.h"
 #include "ui/views/linux_ui/linux_ui.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/views_switches.h"
 #include "ui/views/widget/desktop_aura/desktop_drag_drop_client_aurax11.h"
 #include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h"
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_observer_x11.h"
 #include "ui/views/widget/desktop_aura/x11_desktop_handler.h"
 #include "ui/views/widget/desktop_aura/x11_desktop_window_move_client.h"
@@ skipping 663 matching lines @@
     return;
 
   BeforeActivationStateChanged();
 
   ignore_keyboard_input_ = false;
 
   // wmii says that it supports _NET_ACTIVE_WINDOW but does not.
   // https://code.google.com/p/wmii/issues/detail?id=266
   static bool wm_supports_active_window =
       ui::GuessWindowManager() != ui::WM_WMII &&
-      ui::WmSupportsHint(ui::GetAtom("_NET_ACTIVE_WINDOW"));
+      ui::WmSupportsHint(gfx::GetAtom("_NET_ACTIVE_WINDOW"));
 
   Time timestamp = ui::X11EventSource::GetInstance()->GetTimestamp();
 
   if (wm_supports_active_window) {
     XEvent xclient;
     memset(&xclient, 0, sizeof(xclient));
     xclient.type = ClientMessage;
     xclient.xclient.window = xwindow_;
-    xclient.xclient.message_type = ui::GetAtom("_NET_ACTIVE_WINDOW");
+    xclient.xclient.message_type = gfx::GetAtom("_NET_ACTIVE_WINDOW");
     xclient.xclient.format = 32;
     xclient.xclient.data.l[0] = 1;  // Specified we are an app.
     xclient.xclient.data.l[1] = timestamp;
     // TODO(thomasanderson): if another chrome window is active, specify that in
     // data.l[2].  The EWMH spec claims this may make the WM more likely to
     // service our _NET_ACTIVE_WINDOW request.
     xclient.xclient.data.l[2] = None;
     xclient.xclient.data.l[3] = 0;
     xclient.xclient.data.l[4] = 0;
 
@@ skipping 36 matching lines @@
 
   // |has_window_focus_| and |has_pointer_focus_| are mutually exclusive.
   DCHECK(!has_window_focus_ || !has_pointer_focus_);
 
   return is_active;
 }
 
 void DesktopWindowTreeHostX11::Maximize() {
   if (HasWMSpecProperty("_NET_WM_STATE_FULLSCREEN")) {
     // Unfullscreen the window if it is fullscreen.
-    SetWMSpecState(false, ui::GetAtom("_NET_WM_STATE_FULLSCREEN"), None);
+    SetWMSpecState(false, gfx::GetAtom("_NET_WM_STATE_FULLSCREEN"), None);
 
     // Resize the window so that it does not have the same size as a monitor.
     // (Otherwise, some window managers immediately put the window back in
     // fullscreen mode).
     gfx::Rect adjusted_bounds_in_pixels(bounds_in_pixels_.origin(),
                                         AdjustSize(bounds_in_pixels_.size()));
     if (adjusted_bounds_in_pixels != bounds_in_pixels_)
       SetBoundsInPixels(adjusted_bounds_in_pixels);
   }
 
   // Some WMs do not respect maximization hints on unmapped windows, so we
   // save this one for later too.
   should_maximize_after_map_ = !IsVisible();
 
   // When we are in the process of requesting to maximize a window, we can
   // accurately keep track of our restored bounds instead of relying on the
   // heuristics that are in the PropertyNotify and ConfigureNotify handlers.
   restored_bounds_in_pixels_ = bounds_in_pixels_;
 
-  SetWMSpecState(true, ui::GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"),
-                 ui::GetAtom("_NET_WM_STATE_MAXIMIZED_HORZ"));
+  SetWMSpecState(true, gfx::GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"),
+                 gfx::GetAtom("_NET_WM_STATE_MAXIMIZED_HORZ"));
   if (IsMinimized())
     ShowWindowWithState(ui::SHOW_STATE_NORMAL);
 }
 
 void DesktopWindowTreeHostX11::Minimize() {
   ReleaseCapture();
   XIconifyWindow(xdisplay_, xwindow_, 0);
 }
 
 void DesktopWindowTreeHostX11::Restore() {
   should_maximize_after_map_ = false;
-  SetWMSpecState(false, ui::GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"),
-                 ui::GetAtom("_NET_WM_STATE_MAXIMIZED_HORZ"));
+  SetWMSpecState(false, gfx::GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"),
+                 gfx::GetAtom("_NET_WM_STATE_MAXIMIZED_HORZ"));
   if (IsMinimized())
     ShowWindowWithState(ui::SHOW_STATE_NORMAL);
 }
 
 bool DesktopWindowTreeHostX11::IsMaximized() const {
   return (HasWMSpecProperty("_NET_WM_STATE_MAXIMIZED_VERT") &&
           HasWMSpecProperty("_NET_WM_STATE_MAXIMIZED_HORZ"));
 }
 
 bool DesktopWindowTreeHostX11::IsMinimized() const {
   return HasWMSpecProperty("_NET_WM_STATE_HIDDEN");
 }
 
 bool DesktopWindowTreeHostX11::HasCapture() const {
   return g_current_capture == this;
 }
 
 void DesktopWindowTreeHostX11::SetAlwaysOnTop(bool always_on_top) {
   is_always_on_top_ = always_on_top;
-  SetWMSpecState(always_on_top, ui::GetAtom("_NET_WM_STATE_ABOVE"), None);
+  SetWMSpecState(always_on_top, gfx::GetAtom("_NET_WM_STATE_ABOVE"), None);
 }
 
 bool DesktopWindowTreeHostX11::IsAlwaysOnTop() const {
   return is_always_on_top_;
 }
 
 void DesktopWindowTreeHostX11::SetVisibleOnAllWorkspaces(bool always_visible) {
-  SetWMSpecState(always_visible, ui::GetAtom("_NET_WM_STATE_STICKY"), None);
+  SetWMSpecState(always_visible, gfx::GetAtom("_NET_WM_STATE_STICKY"), None);
 
   int new_desktop = 0;
   if (always_visible) {
     new_desktop = kAllDesktops;
   } else {
     if (!ui::GetCurrentDesktop(&new_desktop))
       return;
   }
 
   workspace_ = base::IntToString(kAllDesktops);
   XEvent xevent;
   memset (&xevent, 0, sizeof (xevent));
   xevent.type = ClientMessage;
   xevent.xclient.window = xwindow_;
-  xevent.xclient.message_type = ui::GetAtom("_NET_WM_DESKTOP");
+  xevent.xclient.message_type = gfx::GetAtom("_NET_WM_DESKTOP");
   xevent.xclient.format = 32;
   xevent.xclient.data.l[0] = new_desktop;
   xevent.xclient.data.l[1] = 0;
   xevent.xclient.data.l[2] = 0;
   xevent.xclient.data.l[3] = 0;
   xevent.xclient.data.l[4] = 0;
   XSendEvent(xdisplay_, x_root_window_, False,
              SubstructureRedirectMask | SubstructureNotifyMask,
              &xevent);
 }
 
 bool DesktopWindowTreeHostX11::IsVisibleOnAllWorkspaces() const {
   // We don't need a check for _NET_WM_STATE_STICKY because that would specify
   // that the window remain in a fixed position even if the viewport scrolls.
   // This is different from the type of workspace that's associated with
   // _NET_WM_DESKTOP.
   return GetWorkspace() == base::IntToString(kAllDesktops);
 }
 
 bool DesktopWindowTreeHostX11::SetWindowTitle(const base::string16& title) {
   if (window_title_ == title)
     return false;
   window_title_ = title;
   std::string utf8str = base::UTF16ToUTF8(title);
-  XChangeProperty(xdisplay_, xwindow_, ui::GetAtom("_NET_WM_NAME"),
-                  ui::GetAtom("UTF8_STRING"), 8, PropModeReplace,
+  XChangeProperty(xdisplay_, xwindow_, gfx::GetAtom("_NET_WM_NAME"),
+                  gfx::GetAtom("UTF8_STRING"), 8, PropModeReplace,
                   reinterpret_cast<const unsigned char*>(utf8str.c_str()),
                   utf8str.size());
   XTextProperty xtp;
   char* c_utf8_str = const_cast<char*>(utf8str.c_str());
   if (Xutf8TextListToTextProperty(xdisplay_, &c_utf8_str, 1,
                                   XUTF8StringStyle, &xtp) == Success) {
     XSetWMName(xdisplay_, xwindow_, &xtp);
     XFree(xtp.value);
   }
   return true;
@@ skipping 76 matching lines @@
 
   // Work around a bug where if we try to unfullscreen, metacity immediately
   // fullscreens us again. This is a little flickery and not necessary if
   // there's a gnome-panel, but it's not easy to detect whether there's a
   // panel or not.
   bool unmaximize_and_remaximize = !fullscreen && IsMaximized() &&
                                    ui::GuessWindowManager() == ui::WM_METACITY;
 
   if (unmaximize_and_remaximize)
     Restore();
-  SetWMSpecState(fullscreen, ui::GetAtom("_NET_WM_STATE_FULLSCREEN"), None);
+  SetWMSpecState(fullscreen, gfx::GetAtom("_NET_WM_STATE_FULLSCREEN"), None);
   if (unmaximize_and_remaximize)
     Maximize();
 
   // Try to guess the size we will have after the switch to/from fullscreen:
   // - (may) avoid transient states
   // - works around Flash content which expects to have the size updated
   //   synchronously.
   // See https://crbug.com/361408
   if (fullscreen) {
     restored_bounds_in_pixels_ = bounds_in_pixels_;
@@ skipping 24 matching lines @@
   // XChangeProperty() expects "cardinality" to be long.
 
   // Scale opacity to [0 .. 255] range.
   unsigned long opacity_8bit =
       static_cast<unsigned long>(opacity * 255.0f) & 0xFF;
   // Use opacity value for all channels.
   const unsigned long channel_multiplier = 0x1010101;
   unsigned long cardinality = opacity_8bit * channel_multiplier;
 
   if (cardinality == 0xffffffff) {
-    XDeleteProperty(xdisplay_, xwindow_, ui::GetAtom("_NET_WM_WINDOW_OPACITY"));
+    XDeleteProperty(xdisplay_, xwindow_,
+                    gfx::GetAtom("_NET_WM_WINDOW_OPACITY"));
   } else {
-    XChangeProperty(xdisplay_, xwindow_, ui::GetAtom("_NET_WM_WINDOW_OPACITY"),
+    XChangeProperty(xdisplay_, xwindow_, gfx::GetAtom("_NET_WM_WINDOW_OPACITY"),
                     XA_CARDINAL, 32, PropModeReplace,
                     reinterpret_cast<unsigned char*>(&cardinality), 1);
   }
 }
 
 void DesktopWindowTreeHostX11::SetWindowIcons(
     const gfx::ImageSkia& window_icon, const gfx::ImageSkia& app_icon) {
   // TODO(erg): The way we handle icons across different versions of chrome
   // could be substantially improved. The Windows version does its own thing
   // and only sometimes comes down this code path. The icon stuff in
@@ skipping 237 matching lines @@
   unsigned long attribute_mask = CWBackPixmap | CWBitGravity;
   XSetWindowAttributes swa;
   memset(&swa, 0, sizeof(swa));
   swa.background_pixmap = None;
   swa.bit_gravity = NorthWestGravity;
 
   ::Atom window_type;
   switch (params.type) {
     case Widget::InitParams::TYPE_MENU:
       swa.override_redirect = True;
-      window_type = ui::GetAtom("_NET_WM_WINDOW_TYPE_MENU");
+      window_type = gfx::GetAtom("_NET_WM_WINDOW_TYPE_MENU");
       break;
     case Widget::InitParams::TYPE_TOOLTIP:
       swa.override_redirect = True;
-      window_type = ui::GetAtom("_NET_WM_WINDOW_TYPE_TOOLTIP");
+      window_type = gfx::GetAtom("_NET_WM_WINDOW_TYPE_TOOLTIP");
       break;
     case Widget::InitParams::TYPE_POPUP:
       swa.override_redirect = True;
-      window_type = ui::GetAtom("_NET_WM_WINDOW_TYPE_NOTIFICATION");
+      window_type = gfx::GetAtom("_NET_WM_WINDOW_TYPE_NOTIFICATION");
       break;
     case Widget::InitParams::TYPE_DRAG:
       swa.override_redirect = True;
-      window_type = ui::GetAtom("_NET_WM_WINDOW_TYPE_DND");
+      window_type = gfx::GetAtom("_NET_WM_WINDOW_TYPE_DND");
       break;
     default:
-      window_type = ui::GetAtom("_NET_WM_WINDOW_TYPE_NORMAL");
+      window_type = gfx::GetAtom("_NET_WM_WINDOW_TYPE_NORMAL");
       break;
   }
   // An in-activatable window should not interact with the system wm.
   if (!activatable_)
     swa.override_redirect = True;
 
   if (swa.override_redirect)
     attribute_mask |= CWOverrideRedirect;
 
   bool enable_transparent_visuals;
@@ skipping 48 matching lines @@
   xwindow_events_.reset(new ui::XScopedEventSelector(xwindow_, event_mask));
   XFlush(xdisplay_);
 
   if (ui::IsXInput2Available())
     ui::TouchFactory::GetInstance()->SetupXI2ForXWindow(xwindow_);
 
   // TODO(erg): We currently only request window deletion events. We also
   // should listen for activation events and anything else that GTK+ listens
   // for, and do something useful.
   ::Atom protocols[2];
-  protocols[0] = ui::GetAtom("WM_DELETE_WINDOW");
-  protocols[1] = ui::GetAtom("_NET_WM_PING");
+  protocols[0] = gfx::GetAtom("WM_DELETE_WINDOW");
+  protocols[1] = gfx::GetAtom("_NET_WM_PING");
   XSetWMProtocols(xdisplay_, xwindow_, protocols, 2);
 
   // We need a WM_CLIENT_MACHINE and WM_LOCALE_NAME value so we integrate with
   // the desktop environment.
   XSetWMProperties(xdisplay_, xwindow_, NULL, NULL, NULL, 0, NULL, NULL, NULL);
 
   // Likewise, the X server needs to know this window's pid so it knows which
   // program to kill if the window hangs.
   // XChangeProperty() expects "pid" to be long.
   static_assert(sizeof(long) >= sizeof(pid_t),
                 "pid_t should not be larger than long");
   long pid = getpid();
-  XChangeProperty(xdisplay_, xwindow_, ui::GetAtom("_NET_WM_PID"), XA_CARDINAL,
+  XChangeProperty(xdisplay_, xwindow_, gfx::GetAtom("_NET_WM_PID"), XA_CARDINAL,
                   32, PropModeReplace, reinterpret_cast<unsigned char*>(&pid),
                   1);
 
-  XChangeProperty(xdisplay_, xwindow_, ui::GetAtom("_NET_WM_WINDOW_TYPE"),
+  XChangeProperty(xdisplay_, xwindow_, gfx::GetAtom("_NET_WM_WINDOW_TYPE"),
                   XA_ATOM, 32, PropModeReplace,
                   reinterpret_cast<unsigned char*>(&window_type), 1);
 
   // List of window state properties (_NET_WM_STATE) to set, if any.
   std::vector< ::Atom> state_atom_list;
 
   // Remove popup windows from taskbar unless overridden.
   if ((params.type == Widget::InitParams::TYPE_POPUP ||
        params.type == Widget::InitParams::TYPE_BUBBLE) &&
       !params.force_show_in_taskbar) {
-    state_atom_list.push_back(ui::GetAtom("_NET_WM_STATE_SKIP_TASKBAR"));
+    state_atom_list.push_back(gfx::GetAtom("_NET_WM_STATE_SKIP_TASKBAR"));
   }
 
   // If the window should stay on top of other windows, add the
   // _NET_WM_STATE_ABOVE property.
   is_always_on_top_ = params.keep_on_top;
   if (is_always_on_top_)
-    state_atom_list.push_back(ui::GetAtom("_NET_WM_STATE_ABOVE"));
+    state_atom_list.push_back(gfx::GetAtom("_NET_WM_STATE_ABOVE"));
 
   workspace_.clear();
   if (params.visible_on_all_workspaces) {
-    state_atom_list.push_back(ui::GetAtom("_NET_WM_STATE_STICKY"));
+    state_atom_list.push_back(gfx::GetAtom("_NET_WM_STATE_STICKY"));
     ui::SetIntProperty(xwindow_, "_NET_WM_DESKTOP", "CARDINAL", kAllDesktops);
   } else if (!params.workspace.empty()) {
     int workspace;
     if (base::StringToInt(params.workspace, &workspace))
       ui::SetIntProperty(xwindow_, "_NET_WM_DESKTOP", "CARDINAL", workspace);
   }
 
   // Setting _NET_WM_STATE by sending a message to the root_window (with
   // SetWMSpecState) has no effect here since the window has not yet been
   // mapped. So we manually change the state.
@@ skipping 74 matching lines @@
   }
 
   // Do not request a 0x0 window size. It causes an XError.
   gfx::Size size_in_pixels = requested_size_in_pixels;
   size_in_pixels.SetToMax(gfx::Size(1, 1));
   return size_in_pixels;
 }
 
 void DesktopWindowTreeHostX11::OnWMStateUpdated() {
   std::vector< ::Atom> atom_list;
-  // Ignore the return value of ui::GetAtomArrayProperty(). Fluxbox removes the
+  // Ignore the return value of gfx::GetAtomArrayProperty(). Fluxbox removes the
   // _NET_WM_STATE property when no _NET_WM_STATE atoms are set.
   ui::GetAtomArrayProperty(xwindow_, "_NET_WM_STATE", &atom_list);
 
   bool was_minimized = IsMinimized();
 
   window_properties_.clear();
   std::copy(atom_list.begin(), atom_list.end(),
             inserter(window_properties_, window_properties_.begin()));
 
   // Propagate the window minimization information to the content window, so
@@ skipping 101 matching lines @@
     const ui::PlatformEvent& event) {
   if (!IsActive())
     return;
 
   ui::EventType type = ui::EventTypeFromNative(event);
   if (type == ui::ET_MOUSE_PRESSED ||
       type == ui::ET_KEY_PRESSED ||
       type == ui::ET_TOUCH_PRESSED) {
     unsigned long wm_user_time_ms = static_cast<unsigned long>(
         (ui::EventTimeFromNative(event) - base::TimeTicks()).InMilliseconds());
-    XChangeProperty(xdisplay_, xwindow_, ui::GetAtom("_NET_WM_USER_TIME"),
+    XChangeProperty(xdisplay_, xwindow_, gfx::GetAtom("_NET_WM_USER_TIME"),
                     XA_CARDINAL, 32, PropModeReplace,
                     reinterpret_cast<const unsigned char*>(&wm_user_time_ms),
                     1);
   }
 }
 
 void DesktopWindowTreeHostX11::SetWMSpecState(bool enabled,
                                               ::Atom state1,
                                               ::Atom state2) {
   XEvent xclient;
   memset(&xclient, 0, sizeof(xclient));
   xclient.type = ClientMessage;
   xclient.xclient.window = xwindow_;
-  xclient.xclient.message_type = ui::GetAtom("_NET_WM_STATE");
+  xclient.xclient.message_type = gfx::GetAtom("_NET_WM_STATE");
   xclient.xclient.format = 32;
   xclient.xclient.data.l[0] =
       enabled ? k_NET_WM_STATE_ADD : k_NET_WM_STATE_REMOVE;
   xclient.xclient.data.l[1] = state1;
   xclient.xclient.data.l[2] = state2;
   xclient.xclient.data.l[3] = 1;
   xclient.xclient.data.l[4] = 0;
 
   XSendEvent(xdisplay_, x_root_window_, False,
              SubstructureRedirectMask | SubstructureNotifyMask,
              &xclient);
 }
 
 bool DesktopWindowTreeHostX11::HasWMSpecProperty(const char* property) const {
-  return window_properties_.find(ui::GetAtom(property)) !=
+  return window_properties_.find(gfx::GetAtom(property)) !=
          window_properties_.end();
 }
 
 void DesktopWindowTreeHostX11::SetUseNativeFrame(bool use_native_frame) {
   use_native_frame_ = use_native_frame;
   ui::SetUseOSWindowFrame(xwindow_, use_native_frame);
   ResetWindowRegion();
 }
 
 void DesktopWindowTreeHostX11::DispatchMouseEvent(ui::MouseEvent* event) {
@@ skipping 160 matching lines @@
 
   // If SHOW_STATE_INACTIVE, tell the window manager not to focus the window
   // when mapping. This is done by setting the _NET_WM_USER_TIME to 0. See e.g.
   // http://standards.freedesktop.org/wm-spec/latest/ar01s05.html
   ignore_keyboard_input_ = show_state == ui::SHOW_STATE_INACTIVE;
   unsigned long wm_user_time_ms =
       ignore_keyboard_input_
           ? 0
           : ui::X11EventSource::GetInstance()->GetTimestamp();
   if (show_state == ui::SHOW_STATE_INACTIVE || wm_user_time_ms != 0) {
-    XChangeProperty(xdisplay_, xwindow_, ui::GetAtom("_NET_WM_USER_TIME"),
+    XChangeProperty(xdisplay_, xwindow_, gfx::GetAtom("_NET_WM_USER_TIME"),
                     XA_CARDINAL, 32, PropModeReplace,
                     reinterpret_cast<const unsigned char*>(&wm_user_time_ms),
                     1);
   }
 
   ui::X11EventSource* event_source = ui::X11EventSource::GetInstance();
   DCHECK(event_source);
 
   UpdateMinAndMaxSize();
 
@@ skipping 240 matching lines @@
       has_pointer_ = false;
       has_pointer_grab_ = false;
       has_pointer_focus_ = false;
       has_window_focus_ = false;
       for (DesktopWindowTreeHostObserverX11& observer : observer_list_)
         observer.OnWindowUnmapped(xwindow_);
       break;
     }
     case ClientMessage: {
       Atom message_type = xev->xclient.message_type;
-      if (message_type == ui::GetAtom("WM_PROTOCOLS")) {
+      if (message_type == gfx::GetAtom("WM_PROTOCOLS")) {
         Atom protocol = static_cast<Atom>(xev->xclient.data.l[0]);
-        if (protocol == ui::GetAtom("WM_DELETE_WINDOW")) {
+        if (protocol == gfx::GetAtom("WM_DELETE_WINDOW")) {
           // We have received a close message from the window manager.
           OnHostCloseRequested();
-        } else if (protocol == ui::GetAtom("_NET_WM_PING")) {
+        } else if (protocol == gfx::GetAtom("_NET_WM_PING")) {
           XEvent reply_event = *xev;
           reply_event.xclient.window = x_root_window_;
 
           XSendEvent(xdisplay_,
                      reply_event.xclient.window,
                      False,
                      SubstructureRedirectMask | SubstructureNotifyMask,
                      &reply_event);
         }
-      } else if (message_type == ui::GetAtom("XdndEnter")) {
+      } else if (message_type == gfx::GetAtom("XdndEnter")) {
         drag_drop_client_->OnXdndEnter(xev->xclient);
-      } else if (message_type == ui::GetAtom("XdndLeave")) {
+      } else if (message_type == gfx::GetAtom("XdndLeave")) {
         drag_drop_client_->OnXdndLeave(xev->xclient);
-      } else if (message_type == ui::GetAtom("XdndPosition")) {
+      } else if (message_type == gfx::GetAtom("XdndPosition")) {
         drag_drop_client_->OnXdndPosition(xev->xclient);
-      } else if (message_type == ui::GetAtom("XdndStatus")) {
+      } else if (message_type == gfx::GetAtom("XdndStatus")) {
         drag_drop_client_->OnXdndStatus(xev->xclient);
-      } else if (message_type == ui::GetAtom("XdndFinished")) {
+      } else if (message_type == gfx::GetAtom("XdndFinished")) {
         drag_drop_client_->OnXdndFinished(xev->xclient);
-      } else if (message_type == ui::GetAtom("XdndDrop")) {
+      } else if (message_type == gfx::GetAtom("XdndDrop")) {
         drag_drop_client_->OnXdndDrop(xev->xclient);
       }
       break;
     }
     case MappingNotify: {
       switch (xev->xmapping.request) {
         case MappingModifier:
         case MappingKeyboard:
           XRefreshKeyboardMapping(&xev->xmapping);
           break;
@@ skipping 23 matching lines @@
           break;
         }
       }
 
       ui::MouseEvent mouseev(xev);
       DispatchMouseEvent(&mouseev);
       break;
     }
     case PropertyNotify: {
       ::Atom changed_atom = xev->xproperty.atom;
-      if (changed_atom == ui::GetAtom("_NET_WM_STATE")) {
+      if (changed_atom == gfx::GetAtom("_NET_WM_STATE")) {
         OnWMStateUpdated();
-      } else if (changed_atom == ui::GetAtom("_NET_FRAME_EXTENTS")) {
+      } else if (changed_atom == gfx::GetAtom("_NET_FRAME_EXTENTS")) {
         OnFrameExtentsUpdated();
-      } else if (changed_atom == ui::GetAtom("_NET_WM_DESKTOP")) {
+      } else if (changed_atom == gfx::GetAtom("_NET_WM_DESKTOP")) {
         if (UpdateWorkspace())
           OnHostWorkspaceChanged();
       }
       break;
     }
     case SelectionNotify: {
       drag_drop_client_->OnSelectionNotify(xev->xselection);
       break;
     }
   }
@@ skipping 77 matching lines @@
 
 // static
 DesktopWindowTreeHost* DesktopWindowTreeHost::Create(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura) {
   return new DesktopWindowTreeHostX11(native_widget_delegate,
                                       desktop_native_widget_aura);
 }
 
 }  // namespace views