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

ui/aura/window.h

 // 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.
 
 #ifndef UI_AURA_WINDOW_H_
 #define UI_AURA_WINDOW_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 28 matching lines @@
 class Texture;
 }
 
 namespace aura {
 
 class LayoutManager;
 class RootWindow;
 class WindowDelegate;
 class WindowObserver;
 
+// TODO(beng): remove once RootWindow is renamed.
+typedef RootWindow WindowEventDispatcher;
+
 // Defined in window_property.h (which we do not include)
 template<typename T>
 struct WindowProperty;
 
 namespace test {
 class WindowTestApi;
 }
 
 // Aura window implementation. Interesting events are sent to the
 // WindowDelegate.
@@ skipping 42 matching lines @@
   void SetTransparent(bool transparent);
 
   WindowDelegate* delegate() { return delegate_; }
   const WindowDelegate* delegate() const { return delegate_; }
 
   const gfx::Rect& bounds() const;
 
   Window* parent() { return parent_; }
   const Window* parent() const { return parent_; }
 
-  // Returns the RootWindow that contains this Window or NULL if the Window is
-  // not contained by a RootWindow.
-  virtual RootWindow* GetRootWindow();
-  virtual const RootWindow* GetRootWindow() const;
+  // Returns the root Window that contains this Window. The root Window is
+  // defined as the Window that has a dispatcher. These functions return NULL if
+  // the Window is contained in a hierarchy that does not have a dispatcher at
+  // its root.
+  virtual Window* GetRootWindow();
+  virtual const Window* GetRootWindow() const;
+
+  WindowEventDispatcher* GetDispatcher();
+  const WindowEventDispatcher* GetDispatcher() const;
+  void set_dispatcher(WindowEventDispatcher* dispatcher) {
+    dispatcher_ = dispatcher;
+  }
+  bool HasDispatcher() const { return !!dispatcher_; }
 
   // The Window does not own this object.
   void set_user_data(void* user_data) { user_data_ = user_data; }
   void* user_data() const { return user_data_; }
 
   // Changes the visibility of the window.
   void Show();
   void Hide();
   // Returns true if this window and all its ancestors are visible.
   bool IsVisible() const;
@@ skipping 343 matching lines @@
   // Overridden from ui::EventTarget:
   virtual bool CanAcceptEvent(const ui::Event& event) OVERRIDE;
   virtual EventTarget* GetParentTarget() OVERRIDE;
 
   // Updates the layer name with a name based on the window's name and id.
   void UpdateLayerName(const std::string& name);
 
   // Returns true if the mouse is currently within our bounds.
   bool ContainsMouse();
 
+  WindowEventDispatcher* dispatcher_;
+
   client::WindowType type_;
 
   // True if the Window is owned by its parent - i.e. it will be deleted by its
   // parent during its parents destruction. True is the default.
   bool owned_by_parent_;
 
   WindowDelegate* delegate_;
 
   // The Window's parent.
   Window* parent_;
@@ skipping 44 matching lines @@
   };
 
   std::map<const void*, Value> prop_map_;
 
   DISALLOW_COPY_AND_ASSIGN(Window);
 };
 
 }  // namespace aura
 
 #endif  // UI_AURA_WINDOW_H_