Add window manager component.

wm/host/root_window_host_linux.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2013 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 "wm/host/root_window_host_linux.h"
 
-#include <strings.h>
-#include <X11/cursorfont.h>
-#include <X11/extensions/Xfixes.h>
-#include <X11/extensions/XInput2.h>
-#include <X11/extensions/Xrandr.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/Xcomposite.h>
+#include <X11/extensions/Xfixes.h>
+#include <X11/extensions/Xrandr.h>
+#include <X11/extensions/shape.h>
+#include <strings.h>
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/message_pump_aurax11.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
@@ skipping 13 matching lines @@
 #include "ui/base/touch/touch_factory.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/view_prop.h"
 #include "ui/base/x/device_list_cache_x.h"
 #include "ui/base/x/valuators.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/screen.h"
+#include "wm/foreign_window.h"
+#include "wm/foreign_window_widget.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/chromeos/chromeos_version.h"
 #endif
 
 using std::max;
 using std::min;
 
-namespace aura {
+namespace wm {
 
 namespace {
 
 // Standard Linux mouse buttons for going back and forward.
 const int kBackMouseButton = 8;
 const int kForwardMouseButton = 9;
 
 // These are the same values that are used to calibrate touch events in
 // |CalibrateTouchCoordinates| (in ui/base/x/events_x.cc).
 // TODO(sad|skuhne): Remove the duplication of values (http://crbug.com/147605)
@@ skipping 95 matching lines @@
     case ui::VKEY_OEM_PLUS:
     case ui::VKEY_OEM_COMMA:
     case ui::VKEY_OEM_MINUS:
     case ui::VKEY_OEM_PERIOD:
       return true;
     default:
       return false;
   }
 }
 
+unsigned InitWindowChanges(const gfx::Rect& bounds,
+                           ::Window sibling_to_stack_above,
+                           XWindowChanges& wc) {
+  wc.x = bounds.x();
+  wc.y = bounds.y();
+  wc.width = bounds.width();
+  wc.height = bounds.height();
+  if (!sibling_to_stack_above) {
+    wc.stack_mode = Below;
+    return CWX | CWY | CWWidth | CWHeight | CWStackMode;
+  }
+
+  wc.sibling = sibling_to_stack_above;
+  wc.stack_mode = Above;
+  return CWX | CWY | CWWidth | CWHeight | CWStackMode | CWSibling;
+}
+
+aura::Window* FindLowestCommonAncestor(
+    aura::Window* root, const aura::Window* p, const aura::Window* q) {
+  // Root is the LCA.
+  if (root == p || root == q)
+    return root;
+
+  aura::Window* prev = NULL;
+  const aura::Window::Windows& children = root->children();
+  for (size_t i = 0; i < children.size(); ++i) {
+    // Try to find LCA of p and q in subtree.
+    aura::Window* next = FindLowestCommonAncestor(children[i], p, q);
+    if (next) {
+      // If a LCA was previously found, p and q must be in different subtrees.
+      if (prev)
+        return root;
+
+      prev = next;
+    }
+  }
+
+  return prev;
+}
+
+gfx::Vector2d GetTargetOffsetInRootWindow(const aura::Window* window) {
+  gfx::Vector2d offset;
+
+  const aura::Window* p = window;
+  for (; p != window->GetRootWindow(); p = p->parent())
+    offset += p->GetTargetBounds().OffsetFromOrigin();
+
+  return offset;
+}
+
+gfx::Rect GetTargetBoundsInRootWindow(const aura::Window* window) {
+  return gfx::Rect(window->GetTargetBounds().size()) +
+      GetTargetOffsetInRootWindow(window);

[danakj, 2013/02/22 21:42:59]

Yep looks good!

+}
+
 }  // namespace
 
 namespace internal {
 
 // A very lightweight message-pump observer that routes all the touch events to
 // the X root window so that they can be calibrated properly.
 class TouchEventCalibrate : public base::MessagePumpObserver {
  public:
   TouchEventCalibrate() {
     MessageLoopForUI::current()->AddObserver(this);
@@ skipping 77 matching lines @@
     : delegate_(NULL),
       xdisplay_(base::MessagePumpAuraX11::GetDefaultXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       current_cursor_(ui::kCursorNull),
       window_mapped_(false),
       bounds_(bounds),
       focus_when_shown_(false),
       touch_calibrate_(new internal::TouchEventCalibrate),
       mouse_move_filter_(new MouseMoveFilter),
-      atom_cache_(xdisplay_, kAtomsToCache) {
+      atom_cache_(xdisplay_, kAtomsToCache),
+      configure_window_(NULL),
+      x_input_window_(0),
+      need_to_set_default_cursor_(true) {
   XSetWindowAttributes swa;
   memset(&swa, 0, sizeof(swa));
   swa.background_pixmap = None;
   xwindow_ = XCreateWindow(
       xdisplay_, x_root_window_,
       bounds.x(), bounds.y(), bounds.width(), bounds.height(),
       0,               // border width
       CopyFromParent,  // depth
       InputOutput,
       CopyFromParent,  // visual
       CWBackPixmap,
       &swa);
+  x_input_window_ = XCreateWindow(
+      xdisplay_, xwindow_,
+      -100, -100, 1, 1,
+      0,               // border width
+      CopyFromParent,  // depth
+      InputOnly,
+      CopyFromParent,  // visual
+      0,
+      NULL);
+  XMapWindow(xdisplay_, x_input_window_);
+  XCompositeRedirectSubwindows(xdisplay_, xwindow_, CompositeRedirectManual);
+
   base::MessagePumpAuraX11::Current()->AddDispatcherForWindow(this, xwindow_);
   base::MessagePumpAuraX11::Current()->AddDispatcherForRootWindow(this);
 
   long event_mask = ButtonPressMask | ButtonReleaseMask | FocusChangeMask |
                     KeyPressMask | KeyReleaseMask |
                     EnterWindowMask | LeaveWindowMask |
                     ExposureMask | VisibilityChangeMask |
                     StructureNotifyMask | PropertyChangeMask |
-                    PointerMotionMask;
+                    PointerMotionMask |
+                    SubstructureNotifyMask | SubstructureRedirectMask;
   XSelectInput(xdisplay_, xwindow_, event_mask);
   XFlush(xdisplay_);
 
   if (base::MessagePumpForUI::HasXInput2())
     ui::TouchFactory::GetInstance()->SetupXI2ForXWindow(xwindow_);
 
   SelectEventsForRootWindow();
 
   // Get the initial size of the X root window.
   XWindowAttributes attrs;
@@ skipping 32 matching lines @@
   XRRSelectInput(xdisplay_, x_root_window_,
                  RRScreenChangeNotifyMask | RROutputChangeNotifyMask);
 }
 
 RootWindowHostLinux::~RootWindowHostLinux() {
   base::MessagePumpAuraX11::Current()->RemoveDispatcherForRootWindow(this);
   base::MessagePumpAuraX11::Current()->RemoveDispatcherForWindow(xwindow_);
 
   UnConfineCursor();
 
+  GetRootWindow()->RemoveObserver(this);
+  XDestroyWindow(xdisplay_, x_input_window_);
   XDestroyWindow(xdisplay_, xwindow_);
 }
 
 bool RootWindowHostLinux::Dispatch(const base::NativeEvent& event) {
   XEvent* xev = event;
 
   if (FindEventTarget(event) == x_root_window_)
     return DispatchEventForRootWindow(event);
 
   switch (xev->type) {
+    case ConfigureNotify: {
+      if (event->xconfigure.window == x_input_window_)
+        return true;
+
+      ForeignWindowMap::iterator it = foreign_windows_.find(
+          event->xconfigure.window);
+      if (it != foreign_windows_.end()) {
+        ForeignWindow* window = it->second;
+
+        int border_size = event->xconfigure.border_width * 2;
+        gfx::Size size(event->xconfigure.width + border_size,
+                       event->xconfigure.height + border_size);
+        window->OnWindowSizeChanged(size);
+        return true;
+      }
+      break;
+    }
+    case MapNotify: {
+      ForeignWindowMap::iterator it = foreign_windows_.find(
+          event->xmap.window);
+      if (it != foreign_windows_.end()) {
+        ForeignWindow* window = it->second;
+
+        window->OnWindowVisibilityChanged(true);
+        return true;
+      }
+      break;
+    }
+    case UnmapNotify: {
+      ForeignWindowMap::iterator it = foreign_windows_.find(
+          event->xunmap.window);
+      if (it != foreign_windows_.end()) {
+        ForeignWindow* window = it->second;
+
+        // Hide top level widget.
+        views::Widget* widget = window->GetWidget();
+        widget->Hide();
+
+        window->OnWindowVisibilityChanged(false);
+        return true;
+      }
+      break;
+    }
+    case CreateNotify: {
+      int border_size = event->xcreatewindow.border_width * 2;
+      gfx::Size size(event->xcreatewindow.width + border_size,
+                     event->xcreatewindow.height + border_size);
+
+      // Create a foreign window for this X window.
+      ForeignWindow::CreateParams params(event->xcreatewindow.window, size);
+      scoped_refptr<ForeignWindow> window(new ForeignWindow(params));
+
+      // Create top level window widget.
+      ForeignWindowWidget::CreateWindow(window.get());
+
+      // Add foreign window to map.
+      foreign_windows_[event->xcreatewindow.window] = window.get();
+      return true;
+    }
+    case DestroyNotify: {
+      ForeignWindowMap::iterator it = foreign_windows_.find(
+          event->xdestroywindow.window);
+      if (it != foreign_windows_.end()) {
+        ForeignWindow* window = it->second;
+
+        // Tell foreign window that X window has been destroyed.
+        window->OnWindowDestroyed();
+
+        // Close top level widget.
+        views::Widget* widget = window->GetWidget();
+        widget->Close();
+
+        foreign_windows_.erase(it);
+      }
+      return true;
+    }
+    case MapRequest: {
+      ForeignWindowMap::iterator it = foreign_windows_.find(
+          event->xmaprequest.window);
+      if (it != foreign_windows_.end()) {
+        ForeignWindow* window = it->second;
+
+        // Show top level widget.
+        views::Widget* widget = window->GetWidget();
+        widget->Show();
+      }
+      return true;
+    }
+    case ConfigureRequest: {
+      // TODO(reveman): Respect ConfigureRequest events.
+      return true;
+    }
+    case CirculateRequest: {
+      // TODO(reveman): Respect CirculateRequest events.
+      return true;
+    }
+  }
+
+  switch (xev->type) {
     case EnterNotify: {
       ui::MouseEvent mouseenter_event(xev);
       TranslateAndDispatchMouseEvent(&mouseenter_event);
       break;
     }
     case Expose:
       delegate_->AsRootWindow()->ScheduleFullDraw();
       break;
     case KeyPress: {
       ui::KeyEvent keydown_event(xev, false);
       delegate_->OnHostKeyEvent(&keydown_event);
       break;
     }
     case KeyRelease: {
       ui::KeyEvent keyup_event(xev, false);
       delegate_->OnHostKeyEvent(&keyup_event);
       break;
     }
     case ButtonPress: {
       if (static_cast<int>(xev->xbutton.button) == kBackMouseButton ||
           static_cast<int>(xev->xbutton.button) == kForwardMouseButton) {
-        client::UserActionClient* gesture_client =
-            client::GetUserActionClient(delegate_->AsRootWindow());
+        aura::client::UserActionClient* gesture_client =
+            aura::client::GetUserActionClient(delegate_->AsRootWindow());
         if (gesture_client) {
           gesture_client->OnUserAction(
               static_cast<int>(xev->xbutton.button) == kBackMouseButton ?
-              client::UserActionClient::BACK :
-              client::UserActionClient::FORWARD);
+              aura::client::UserActionClient::BACK :
+              aura::client::UserActionClient::FORWARD);
         }
         break;
       }
     }  // fallthrough
     case ButtonRelease: {
       ui::MouseEvent mouseev(xev);
       TranslateAndDispatchMouseEvent(&mouseev);
       break;
     }
     case FocusOut:
@@ skipping 85 matching lines @@
       }
 
       ui::MouseEvent mouseev(xev);
       TranslateAndDispatchMouseEvent(&mouseev);
       break;
     }
   }
   return true;
 }
 
-void RootWindowHostLinux::SetDelegate(RootWindowHostDelegate* delegate) {
+void RootWindowHostLinux::OnWindowAdded(aura::Window* window) {
+  window->AddObserver(this);
+}
+
+void RootWindowHostLinux::OnWillRemoveWindow(aura::Window* window) {
+  if (configure_window_ == window)
+    configure_window_ = window->parent();
+
+  window->RemoveObserver(this);
+}
+
+void RootWindowHostLinux::OnWindowStackingChanged(aura::Window* window) {
+  ScheduleConfigure(GetRootWindow());
+}
+
+void RootWindowHostLinux::OnWindowVisibilityChanged(
+    aura::Window* window, bool visible) {
+  ScheduleConfigure(GetRootWindow());
+}
+
+void RootWindowHostLinux::OnWindowBoundsChanged(
+    aura::Window* window,
+    const gfx::Rect& old_bounds,
+    const gfx::Rect& new_bounds) {
+  ScheduleConfigure(GetRootWindow());
+}
+
+void RootWindowHostLinux::OnWindowDestroying(aura::Window* window) {
+  window->RemoveObserver(this);
+}
+
+::Window RootWindowHostLinux::GetTopForeignWindow(const aura::Window* window) {
+  // children are ordered back to front, so walk through it in reverse.
+  const aura::Window::Windows& children = window->children();
+  for (size_t i = children.size(); i; --i) {
+    ::Window top = GetTopForeignWindow(children[i - 1]);
+    if (top)
+      return top;
+  }
+
+  ForeignWindow* foreign_window = ForeignWindow::GetForeignWindowForNativeView(
+      const_cast<gfx::NativeView>(window));
+  if (foreign_window) {
+    // Ignore windows that we're not allowed to configure.
+    if (foreign_window->IsManaged())
+      return foreign_window->GetWindowHandle();
+  }
+
+  return 0;
+}
+
+::Window RootWindowHostLinux::FindForeignWindowToStackAbove(
+    const aura::Window* window) {
+  const aura::Window* parent = window->parent();
+  if (!parent)
+    return 0;
+
+  ::Window above = 0;
+
+  const aura::Window::Windows& children = parent->children();
+  for (size_t i = 0; i < children.size(); ++i) {
+    if (children[i] == window)
+      break;
+
+    ::Window top = GetTopForeignWindow(children[i]);
+    if (top)
+      above = top;
+  }
+
+  if (!above)
+    above = FindForeignWindowToStackAbove(parent);
+
+  return above;
+}
+
+void RootWindowHostLinux::MapWindowIfNeeded(ForeignWindow* window) {
+  ForeignWindow::DisplayState current_display_state =
+      window->GetDisplayState();
+
+  if (current_display_state != ForeignWindow::DISPLAY_NORMAL) {
+    // TODO(reveman): Ignore possible X error.
+    XMapWindow(xdisplay_, window->GetWindowHandle());
+
+    window->SetDisplayState(ForeignWindow::DISPLAY_NORMAL);
+  }
+}
+
+void RootWindowHostLinux::UnmapWindowIfNeeded(ForeignWindow* window) {
+  ForeignWindow::DisplayState current_display_state =
+      window->GetDisplayState();
+
+  if (current_display_state == ForeignWindow::DISPLAY_NORMAL) {
+    // TODO(reveman): Ignore possible X error.
+    XUnmapWindow(xdisplay_, window->GetWindowHandle());
+
+    window->SetDisplayState(ForeignWindow::DISPLAY_ICONIC);
+  }
+}
+
+void RootWindowHostLinux::RecursiveConfigure(
+    aura::Window* window,
+    gfx::Vector2d offset,
+    ::Window* sibling_to_stack_above,
+    SkRegion* input_region) {
+  gfx::Rect bounds(gfx::Rect(window->GetTargetBounds().size()) + offset);
+  SkRegion::Op input_region_op;
+
+  ForeignWindow* foreign_window = ForeignWindow::GetForeignWindowForNativeView(
+      const_cast<gfx::NativeView>(window));
+  if (foreign_window) {
+    DCHECK(!bounds.IsEmpty());
+
+    // We should only be adjusting attributes of managed windows.
+    if (foreign_window->IsManaged()) {
+      if (!window->IsVisible())
+        UnmapWindowIfNeeded(foreign_window);
+
+      XWindowChanges wc;
+      unsigned mask = InitWindowChanges(bounds, *sibling_to_stack_above, wc);
+      // Get rid of any borders.
+      wc.border_width = 0;
+      mask |= CWBorderWidth;
+      // TODO(reveman): Ignore possible X error.
+      XConfigureWindow(xdisplay_,
+                       foreign_window->GetWindowHandle(),
+                       mask,
+                       &wc);
+
+      *sibling_to_stack_above = foreign_window->GetWindowHandle();
+
+      if (window->IsVisible())
+        MapWindowIfNeeded(foreign_window);
+    }
+
+    // Remove foreign window bounds from input region.
+    bounds.Inset(window->hit_test_bounds_override_inner());
+    input_region_op = SkRegion::kDifference_Op;
+  } else {
+    // Add window bounds to output region.
+    bounds.Inset(window->hit_test_bounds_override_outer_mouse());
+    input_region_op = SkRegion::kUnion_Op;
+  }
+
+  if (window->delegate() && window->IsVisible()) {
+    input_region->op(bounds.x(),
+                     bounds.y(),
+                     bounds.right(),
+                     bounds.bottom(),
+                     input_region_op);
+  }
+
+  const aura::Window::Windows& children = window->children();
+  for (size_t i = 0; i < children.size(); ++i) {
+    RecursiveConfigure(
+        children[i],
+        offset + children[i]->GetTargetBounds().OffsetFromOrigin(),
+        sibling_to_stack_above,
+        input_region);
+  }
+}
+
+void RootWindowHostLinux::Configure() {
+  if (!configure_window_)
+    return;
+
+  SkRegion input_region;
+  ::Window sibling_to_stack_above =
+      FindForeignWindowToStackAbove(configure_window_);
+  RecursiveConfigure(configure_window_,
+                     GetTargetOffsetInRootWindow(configure_window_),
+                     &sibling_to_stack_above,
+                     &input_region);
+
+  // Update input window and set focus when we configure the root window.
+  if (configure_window_ == GetRootWindow()) {
+    // Configure input window above all other windows.
+    XWindowChanges wc;
+    gfx::Rect bounds(gfx::Point(0, 0), bounds_.size());
+    unsigned mask = InitWindowChanges(bounds, sibling_to_stack_above, wc);
+    XConfigureWindow(xdisplay_, x_input_window_, mask, &wc);
+
+    // Update input window shape.
+    std::vector<XRectangle> rectangles;
+    for (SkRegion::Iterator iter(input_region); !iter.done(); iter.next()) {
+      const SkIRect& sk_rect = iter.rect();
+      XRectangle x_rect;
+      x_rect.x = sk_rect.x();
+      x_rect.y = sk_rect.y();
+      x_rect.width = sk_rect.width();
+      x_rect.height = sk_rect.height();
+      rectangles.push_back(x_rect);
+    }
+
+    XShapeCombineRectangles(xdisplay_,
+                            x_input_window_,
+                            ShapeInput,
+                            0,
+                            0,
+                            &rectangles.front(),
+                            rectangles.size(),
+                            ShapeSet,
+                            Unsorted);
+  }
+
+  XFlush(xdisplay_);
+  configure_window_ = NULL;
+}
+
+void RootWindowHostLinux::ScheduleConfigure(aura::Window* window) {
+  if (!configure_window_) {
+    configure_window_ = window;
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&RootWindowHostLinux::Configure, AsWeakPtr()));
+  } else {
+    configure_window_ = FindLowestCommonAncestor(
+        GetRootWindow(), configure_window_, window);
+  }
+}
+
+void RootWindowHostLinux::SetDelegate(aura::RootWindowHostDelegate* delegate) {
+  DCHECK(!delegate_);
   delegate_ = delegate;
-}
-
-RootWindow* RootWindowHostLinux::GetRootWindow() {
+  DCHECK(delegate_);
+  delegate_->AsRootWindow()->AddObserver(this);
+  ScheduleConfigure(delegate_->AsRootWindow());
+}
+
+aura::RootWindow* RootWindowHostLinux::GetRootWindow() {
   return delegate_->AsRootWindow();
 }
 
 gfx::AcceleratedWidget RootWindowHostLinux::GetAcceleratedWidget() {
   return xwindow_;
 }
 
 void RootWindowHostLinux::Show() {
   if (!window_mapped_) {
     // Before we map the window, set size hints. Otherwise, some window managers
@@ skipping 86 matching lines @@
 }
 
 void RootWindowHostLinux::SetCursor(gfx::NativeCursor cursor) {
   if (cursor == current_cursor_)
     return;
   current_cursor_ = cursor;
   SetCursorInternal(cursor);
 }
 
 bool RootWindowHostLinux::QueryMouseLocation(gfx::Point* location_return) {
-  client::CursorClient* cursor_client =
-      client::GetCursorClient(GetRootWindow());
+  aura::client::CursorClient* cursor_client =
+      aura::client::GetCursorClient(GetRootWindow());
   if (cursor_client && !cursor_client->IsMouseEventsEnabled()) {
     *location_return = gfx::Point(0, 0);
     return false;
   }
 
   ::Window root_return, child_return;
   int root_x_return, root_y_return, win_x_return, win_y_return;
   unsigned int mask_return;
   XQueryPointer(xdisplay_,
                 xwindow_,
@@ skipping 301 matching lines @@
         if (mouse_move_filter_ && mouse_move_filter_->Filter(xev))
           break;
       } else if (type == ui::ET_MOUSE_PRESSED ||
                  type == ui::ET_MOUSE_RELEASED) {
         XIDeviceEvent* xievent =
             static_cast<XIDeviceEvent*>(xev->xcookie.data);
         int button = xievent->detail;
         if (button == kBackMouseButton || button == kForwardMouseButton) {
           if (type == ui::ET_MOUSE_RELEASED)
             break;
-          client::UserActionClient* gesture_client =
-              client::GetUserActionClient(delegate_->AsRootWindow());
+          aura::client::UserActionClient* gesture_client =
+              aura::client::GetUserActionClient(delegate_->AsRootWindow());
           if (gesture_client) {
             bool reverse_direction =
                 ui::IsTouchpadEvent(xev) && ui::IsNaturalScrollEnabled();
             gesture_client->OnUserAction(
                 (button == kBackMouseButton && !reverse_direction) ||
                 (button == kForwardMouseButton && reverse_direction) ?
-                client::UserActionClient::BACK :
-                client::UserActionClient::FORWARD);
+                aura::client::UserActionClient::BACK :
+                aura::client::UserActionClient::FORWARD);
           }
           break;
         }
       }
       ui::MouseEvent mouseev(xev);
       TranslateAndDispatchMouseEvent(&mouseev);
       break;
     }
     case ui::ET_MOUSEWHEEL: {
       ui::MouseWheelEvent mouseev(xev);
@@ skipping 19 matching lines @@
 }
 
 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_, atom_cache_.GetAtom("WM_S0")) != None;
 }
 
 void RootWindowHostLinux::SetCursorInternal(gfx::NativeCursor cursor) {
-  XDefineCursor(xdisplay_, xwindow_, cursor.platform());
+  XDefineCursor(xdisplay_, x_input_window_, cursor.platform());
+
+  // Set default native window cursor.
+  if (need_to_set_default_cursor_ && cursor.native_type() == ui::kCursorNull) {
+    XDefineCursor(xdisplay_, xwindow_, cursor.platform());
+    need_to_set_default_cursor_ = false;
+  }
 }
 
 void RootWindowHostLinux::TranslateAndDispatchMouseEvent(
     ui::MouseEvent* event) {
-  RootWindow* root = GetRootWindow();
-  client::ScreenPositionClient* screen_position_client =
+  aura::RootWindow* root = GetRootWindow();
+  aura::client::ScreenPositionClient* screen_position_client =
       GetScreenPositionClient(root);
   if (screen_position_client && !bounds_.Contains(event->location())) {
     gfx::Point location(event->location());
     screen_position_client->ConvertNativePointToScreen(root, &location);
     screen_position_client->ConvertPointFromScreen(root, &location);
     // |delegate_|'s OnHoustMouseEvent expects native coordinates relative to
     // root.
     location = ui::ConvertPointToPixel(root->layer(), location);
     event->set_location(location);
     event->set_root_location(location);
   }
   delegate_->OnHostMouseEvent(event);
 }
 
 scoped_ptr<ui::XScopedImage> RootWindowHostLinux::GetXImage(
     const gfx::Rect& snapshot_bounds) {
   scoped_ptr<ui::XScopedImage> image(new ui::XScopedImage(
       XGetImage(xdisplay_, xwindow_,
                 snapshot_bounds.x(), snapshot_bounds.y(),
                 snapshot_bounds.width(), snapshot_bounds.height(),
                 AllPlanes, ZPixmap)));
   if (!image->get()) {
     LOG(ERROR) << "XGetImage failed";
     image.reset();
   }
   return image.Pass();
 }
 
-// static
-RootWindowHost* RootWindowHost::Create(const gfx::Rect& bounds) {
-  return new RootWindowHostLinux(bounds);
-}
-
-// static
-gfx::Size RootWindowHost::GetNativeScreenSize() {
-  ::Display* xdisplay = base::MessagePumpAuraX11::GetDefaultXDisplay();
-  return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
-}
-
-}  // namespace aura
+}  // namespace wm