Desktop aura: Put x11 cache in aura, instead of ui/base/x/.

ui/aura/root_window_host_linux.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/aura/root_window_host_linux.h"
 
 #include <X11/Xatom.h>
 #include <X11/Xcursor/Xcursor.h>
 #include <X11/Xlib.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/Xrandr.h>
 #include <algorithm>
 
 #include "base/message_pump_x.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "grit/ui_resources_standard.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/client/user_gesture_client.h"
 #include "ui/aura/dispatcher_linux.h"
 #include "ui/aura/env.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
+#include "ui/aura/x11_atom_cache.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/touch/touch_factory.h"
 #include "ui/base/view_prop.h"
-#include "ui/base/x/x11_atom_cache.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/image/image.h"
 
-using ui::X11AtomCache;
 using std::max;
 using std::min;
 
 namespace aura {
 
 namespace {
 
 // Standard Linux mouse buttons for going back and forward.
 const int kBackMouseButton = 8;
 const int kForwardMouseButton = 9;
@@ skipping 338 matching lines @@
   invisible_cursor_ = XCreatePixmapCursor(xdisplay_, blank, blank,
                                           &black, &black, 0, 0);
   XFreePixmap(xdisplay_, blank);
 
   if (RootWindow::hide_host_cursor())
     XDefineCursor(xdisplay_, x_root_window_, invisible_cursor_);
 
   // 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.
-  X11AtomCache* cache = X11AtomCache::GetInstance();
+  X11AtomCache* cache = aura::Env::GetInstance()->atom_cache();
   ::Atom protocols[2];
-  protocols[0] = cache->GetAtom(ui::ATOM_WM_DELETE_WINDOW);
-  protocols[1] = cache->GetAtom(ui::ATOM__NET_WM_PING);
+  protocols[0] = cache->GetAtom(ATOM_WM_DELETE_WINDOW);
+  protocols[1] = cache->GetAtom(ATOM__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.
   pid_t pid = getpid();
   XChangeProperty(xdisplay_,
                   xwindow_,
-                  cache->GetAtom(ui::ATOM__NET_WM_PID),
+                  cache->GetAtom(ATOM__NET_WM_PID),
                   XA_CARDINAL,
                   32,
                   PropModeReplace,
                   reinterpret_cast<unsigned char*>(&pid), 1);
 
   // crbug.com/120229 - set the window title so gtalk can find the primary root
   // window to broadcast.
   // TODO(jhorwich) Remove this once Chrome supports window-based broadcasting.
   static int root_window_number = 0;
   std::string name = StringPrintf("aura_root_%d", root_window_number++);
@@ skipping 151 matching lines @@
     }
     case MapNotify: {
       // If there's no window manager running, we need to assign the X input
       // focus to our host window.
       if (!IsWindowManagerPresent() && focus_when_shown_)
         XSetInputFocus(xdisplay_, xwindow_, RevertToNone, CurrentTime);
       break;
     }
     case ClientMessage: {
       Atom message_type = static_cast<Atom>(xev->xclient.data.l[0]);
-      X11AtomCache* cache = X11AtomCache::GetInstance();
-      if (message_type == cache->GetAtom(ui::ATOM_WM_DELETE_WINDOW)) {
+      X11AtomCache* cache = aura::Env::GetInstance()->atom_cache();
+      if (message_type == cache->GetAtom(ATOM_WM_DELETE_WINDOW)) {
         // We have received a close message from the window manager.
         root_window_->OnRootWindowHostClosed();
-      } else if (message_type == cache->GetAtom(ui::ATOM__NET_WM_PING)) {
+      } else if (message_type == cache->GetAtom(ATOM__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);
       }
       break;
@@ skipping 272 matching lines @@
       break;
   }
   XSendEvent(xdisplay_, xwindow_, False, 0, &xevent);
 }
 
 bool RootWindowHostLinux::IsWindowManagerPresent() {
   // Per ICCCM 2.8, "Manager Selections", window managers should take ownership
   // of WM_Sn selections (where n is a screen number).
   return XGetSelectionOwner(
       xdisplay_,
-      X11AtomCache::GetInstance()->GetAtom(ui::ATOM_WM_S0)) != None;
+      aura::Env::GetInstance()->atom_cache()->GetAtom(ATOM_WM_S0)) != None;
 }
 
 void RootWindowHostLinux::SetCursorInternal(gfx::NativeCursor cursor) {
   ::Cursor xcursor =
       image_cursors_->IsImageCursor(cursor) ?
       image_cursors_->ImageCursorFromNative(cursor) :
       cursor == ui::kCursorNone ?
       invisible_cursor_ :
       cursor == ui::kCursorCustom ?
       cursor.platform() :
@@ skipping 13 matching lines @@
       ui::ViewProp::GetValue(accelerated_widget, kRootWindowHostLinuxKey));
 }
 
 // static
 gfx::Size RootWindowHost::GetNativeScreenSize() {
   ::Display* xdisplay = base::MessagePumpX::GetDefaultXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 }  // namespace aura