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

ui/aura/test/event_generator.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/test/event_generator.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "ui/aura/client/screen_position_client.h"
@@ skipping 13 matching lines @@
 
 namespace aura {
 namespace test {
 namespace {
 
 void DummyCallback(ui::EventType, const gfx::Vector2dF&) {
 }
 
 class DefaultEventGeneratorDelegate : public EventGeneratorDelegate {
  public:
-  explicit DefaultEventGeneratorDelegate(RootWindow* root_window)
+  explicit DefaultEventGeneratorDelegate(Window* root_window)
       : root_window_(root_window) {}
   virtual ~DefaultEventGeneratorDelegate() {}
 
   // EventGeneratorDelegate overrides:
   virtual RootWindow* GetRootWindowAt(const gfx::Point& point) const OVERRIDE {
-    return root_window_;
+    return root_window_->GetDispatcher();
   }
 
   virtual client::ScreenPositionClient* GetScreenPositionClient(
       const aura::Window* window) const OVERRIDE {
     return NULL;
   }
 
  private:
-  RootWindow* root_window_;
+  Window* root_window_;
 
   DISALLOW_COPY_AND_ASSIGN(DefaultEventGeneratorDelegate);
 };
 
 class TestKeyEvent : public ui::KeyEvent {
  public:
   TestKeyEvent(const base::NativeEvent& native_event, int flags, bool is_char)
       : KeyEvent(native_event, is_char) {
     set_flags(flags);
   }
 };
 
 class TestTouchEvent : public ui::TouchEvent {
  public:
   TestTouchEvent(ui::EventType type,
                  const gfx::Point& root_location,
                  int flags)
       : TouchEvent(type, root_location, flags, 0, ui::EventTimeForNow(),
                    1.0f, 1.0f, 1.0f, 1.0f) {
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestTouchEvent);
 };
 
 const int kAllButtonMask = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON;
 
 }  // namespace
 
-EventGenerator::EventGenerator(RootWindow* root_window)
+EventGenerator::EventGenerator(Window* root_window)
     : delegate_(new DefaultEventGeneratorDelegate(root_window)),
       current_root_window_(delegate_->GetRootWindowAt(current_location_)),
       flags_(0),
       grab_(false),
       async_(false) {
 }
 
-EventGenerator::EventGenerator(RootWindow* root_window, const gfx::Point& point)
+EventGenerator::EventGenerator(Window* root_window, const gfx::Point& point)
     : delegate_(new DefaultEventGeneratorDelegate(root_window)),
       current_location_(point),
       current_root_window_(delegate_->GetRootWindowAt(current_location_)),
       flags_(0),
       grab_(false),
       async_(false) {
 }
 
-EventGenerator::EventGenerator(RootWindow* root_window, Window* window)
+EventGenerator::EventGenerator(Window* root_window, Window* window)
     : delegate_(new DefaultEventGeneratorDelegate(root_window)),
       current_location_(CenterOfWindow(window)),
       current_root_window_(delegate_->GetRootWindowAt(current_location_)),
       flags_(0),
       grab_(false),
       async_(false) {
 }
 
 EventGenerator::EventGenerator(EventGeneratorDelegate* delegate)
     : delegate_(delegate),
@@ skipping 459 matching lines @@
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(&EventGenerator::DispatchNextPendingEvent,
                    base::Unretained(this)));
   }
 }
 
 
 }  // namespace test
 }  // namespace aura