Make GetRootWindow() return a Window instead of a RootWindow.

ui/views/test/ui_controls_factory_desktop_aurax11.cc

 // Copyright 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 <X11/keysym.h>
 #include <X11/Xlib.h>
 
 // X macro fail.
 #if defined(RootWindow)
 #undef RootWindow
@@ skipping 107 matching lines @@
   virtual bool SendKeyPressNotifyWhenDone(
       gfx::NativeWindow window,
       ui::KeyboardCode key,
       bool control,
       bool shift,
       bool alt,
       bool command,
       const base::Closure& closure) OVERRIDE {
     DCHECK(!command);  // No command key on Aura
 
-    aura::RootWindow* root_window = window->GetRootWindow();
+    aura::WindowEventDispatcher* dispatcher = window->GetDispatcher();
 
     XEvent xevent = {0};
     xevent.xkey.type = KeyPress;
     if (control) {
-      SetKeycodeAndSendThenMask(root_window, &xevent, XK_Control_L,
+      SetKeycodeAndSendThenMask(dispatcher, &xevent, XK_Control_L,
                                 ControlMask);
     }
     if (shift)
-      SetKeycodeAndSendThenMask(root_window, &xevent, XK_Shift_L, ShiftMask);
+      SetKeycodeAndSendThenMask(dispatcher, &xevent, XK_Shift_L, ShiftMask);
     if (alt)
-      SetKeycodeAndSendThenMask(root_window, &xevent, XK_Alt_L, Mod1Mask);
+      SetKeycodeAndSendThenMask(dispatcher, &xevent, XK_Alt_L, Mod1Mask);
     xevent.xkey.keycode =
         XKeysymToKeycode(x_display_,
                          ui::XKeysymForWindowsKeyCode(key, shift));
-    root_window->PostNativeEvent(&xevent);
+    dispatcher->PostNativeEvent(&xevent);
 
     // Send key release events.
     xevent.xkey.type = KeyRelease;
-    root_window->PostNativeEvent(&xevent);
+    dispatcher->PostNativeEvent(&xevent);
     if (alt)
-      UnmaskAndSetKeycodeThenSend(root_window, &xevent, Mod1Mask, XK_Alt_L);
+      UnmaskAndSetKeycodeThenSend(dispatcher, &xevent, Mod1Mask, XK_Alt_L);
     if (shift)
-      UnmaskAndSetKeycodeThenSend(root_window, &xevent, ShiftMask, XK_Shift_L);
+      UnmaskAndSetKeycodeThenSend(dispatcher, &xevent, ShiftMask, XK_Shift_L);
     if (control) {
-      UnmaskAndSetKeycodeThenSend(root_window, &xevent, ControlMask,
+      UnmaskAndSetKeycodeThenSend(dispatcher, &xevent, ControlMask,
                                   XK_Control_L);
     }
     DCHECK(!xevent.xkey.state);
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
 
   // Simulate a mouse move. (x,y) are absolute screen coordinates.
   virtual bool SendMouseMove(long x, long y) OVERRIDE {
     return SendMouseMoveNotifyWhenDone(x, y, base::Closure());
   }
   virtual bool SendMouseMoveNotifyWhenDone(
       long x,
       long y,
       const base::Closure& closure) OVERRIDE {
     gfx::Point screen_point(x, y);
     gfx::Point window_point = screen_point;
-    aura::RootWindow* root_window = RootWindowForPoint(screen_point);
+    aura::Window* root_window = RootWindowForPoint(screen_point);
 
     aura::client::ScreenPositionClient* screen_position_client =
           aura::client::GetScreenPositionClient(root_window);
     if (screen_position_client) {
       screen_position_client->ConvertPointFromScreen(root_window,
                                                      &window_point);
     }
 
     XEvent xevent = {0};
     XMotionEvent* xmotion = &xevent.xmotion;
     xmotion->type = MotionNotify;
     xmotion->x = window_point.x();
     xmotion->y = window_point.y();
     xmotion->state = button_down_mask;
     xmotion->same_screen = True;
     // RootWindow will take care of other necessary fields.
-    root_window->PostNativeEvent(&xevent);
+    root_window->GetDispatcher()->PostNativeEvent(&xevent);
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
   virtual bool SendMouseEvents(MouseButton type, int state) OVERRIDE {
     return SendMouseEventsNotifyWhenDone(type, state, base::Closure());
   }
   virtual bool SendMouseEventsNotifyWhenDone(
       MouseButton type,
       int state,
       const base::Closure& closure) OVERRIDE {
     XEvent xevent = {0};
     XButtonEvent* xbutton = &xevent.xbutton;
     gfx::Point mouse_loc = aura::Env::GetInstance()->last_mouse_location();
-    aura::RootWindow* root_window = RootWindowForPoint(mouse_loc);
+    aura::Window* root_window = RootWindowForPoint(mouse_loc);
     aura::client::ScreenPositionClient* screen_position_client =
           aura::client::GetScreenPositionClient(root_window);
     if (screen_position_client)
       screen_position_client->ConvertPointFromScreen(root_window, &mouse_loc);
     xbutton->x = mouse_loc.x();
     xbutton->y = mouse_loc.y();
     xbutton->same_screen = True;
     switch (type) {
       case LEFT:
         xbutton->button = Button1;
         xbutton->state = Button1Mask;
         break;
       case MIDDLE:
         xbutton->button = Button2;
         xbutton->state = Button2Mask;
         break;
       case RIGHT:
         xbutton->button = Button3;
         xbutton->state = Button3Mask;
         break;
     }
     // RootWindow will take care of other necessary fields.
     if (state & DOWN) {
       xevent.xbutton.type = ButtonPress;
-      root_window->PostNativeEvent(&xevent);
+      root_window->GetDispatcher()->PostNativeEvent(&xevent);
       button_down_mask |= xbutton->state;
     }
     if (state & UP) {
       xevent.xbutton.type = ButtonRelease;
-      root_window->PostNativeEvent(&xevent);
+      root_window->GetDispatcher()->PostNativeEvent(&xevent);
       button_down_mask = (button_down_mask | xbutton->state) ^ xbutton->state;
     }
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
   virtual bool SendMouseClick(MouseButton type) OVERRIDE {
     return SendMouseEvents(type, UP | DOWN);
   }
   virtual void RunClosureAfterAllPendingUIEvents(
       const base::Closure& closure) OVERRIDE {
     if (closure.is_null())
       return;
     static XEvent* marker_event = NULL;
     if (!marker_event) {
       marker_event = new XEvent();
       marker_event->xclient.type = ClientMessage;
       marker_event->xclient.display = x_display_;
       marker_event->xclient.window = x_window_;
       marker_event->xclient.format = 8;
     }
     marker_event->xclient.message_type = MarkerEventAtom();
     XSendEvent(x_display_, x_window_, False, 0, marker_event);
     new EventWaiter(closure, &Matcher);
   }
  private:
-  aura::RootWindow* RootWindowForPoint(const gfx::Point& point) {
+  aura::Window* RootWindowForPoint(const gfx::Point& point) {
     // Most interactive_ui_tests run inside of the aura_test_helper
     // environment. This means that we can't rely on gfx::Screen and several
     // other things to work properly. Therefore we hack around this by
     // iterating across the windows owned DesktopRootWindowHostX11 since this
     // doesn't rely on having a DesktopScreenX11.
     std::vector<aura::Window*> windows =
         DesktopRootWindowHostX11::GetAllOpenWindows();
     for (std::vector<aura::Window*>::const_iterator it = windows.begin();
          it != windows.end(); ++it) {
       if ((*it)->GetBoundsInScreen().Contains(point)) {
@@ skipping 35 matching lines @@
 };
 
 }  // namespace
 
 UIControlsAura* CreateUIControlsDesktopAura() {
   return new UIControlsDesktopX11();
 }
 
 }  // namespace test
 }  // namespace views