Window ownership -> WindowTreeHost

ui/aura/window.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/window.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 144 matching lines @@
     GetLayersToStack(child->children()[i], layers);
 }
 
 }  // namespace
 
 class ScopedCursorHider {
  public:
   explicit ScopedCursorHider(Window* window)
       : window_(window),
         hid_cursor_(false) {
-    if (!window_->HasDispatcher())
+    if (!window_->IsRootWindow())
       return;
     const bool cursor_is_in_bounds = window_->GetBoundsInScreen().Contains(
         Env::GetInstance()->last_mouse_location());
     client::CursorClient* cursor_client = client::GetCursorClient(window_);
     if (cursor_is_in_bounds && cursor_client &&
         cursor_client->IsCursorVisible()) {
       cursor_client->HideCursor();
       hid_cursor_ = true;
     }
   }
   ~ScopedCursorHider() {
-    if (!window_->HasDispatcher())
+    if (!window_->IsRootWindow())
       return;
 
     // Update the device scale factor of the cursor client only when the last
     // mouse location is on this root window.
     if (hid_cursor_) {
       client::CursorClient* cursor_client = client::GetCursorClient(window_);
       if (cursor_client) {
         const gfx::Display& display =
             gfx::Screen::GetScreenFor(window_)->GetDisplayNearestWindow(
                 window_);
         cursor_client->SetDisplay(display);
         cursor_client->ShowCursor();
       }
     }
   }
 
  private:
   Window* window_;
   bool hid_cursor_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedCursorHider);
 };
 
 Window::Window(WindowDelegate* delegate)
-    : dispatcher_(NULL),
+    : host_(NULL),
       type_(ui::wm::WINDOW_TYPE_UNKNOWN),
       owned_by_parent_(true),
       delegate_(delegate),
       parent_(NULL),
       visible_(false),
       id_(-1),
       transparent_(false),
       user_data_(NULL),
       ignore_events_(false),
       // Don't notify newly added observers during notification. This causes
       // problems for code that adds an observer as part of an observer
       // notification (such as the workspace code).
       observers_(ObserverList<WindowObserver>::NOTIFY_EXISTING_ONLY) {
   set_target_handler(delegate_);
 }
 
 Window::~Window() {
   // |layer_| can be NULL during tests, or if this Window is layerless.
   if (layer_)
     layer_->SuppressPaint();
 
   // Let the delegate know we're in the processing of destroying.
   if (delegate_)
     delegate_->OnWindowDestroying(this);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDestroying(this));
 
   // Let the root know so that it can remove any references to us.
-  WindowEventDispatcher* dispatcher = GetDispatcher();
-  if (dispatcher)
-    dispatcher->OnWindowDestroying(this);
+  WindowTreeHost* host = GetHost();
+  if (host)
+    host->dispatcher()->OnWindowDestroying(this);
 
   // Then destroy the children.
   RemoveOrDestroyChildren();
 
   // The window needs to be removed from the parent before calling the
   // WindowDestroyed callbacks of delegate and the observers.
   if (parent_)
     parent_->RemoveChild(this);
 
   if (delegate_)
@@ skipping 93 matching lines @@
   if (layer_)
     layer_->SetFillsBoundsOpaquely(!transparent_);
 }
 
 Window* Window::GetRootWindow() {
   return const_cast<Window*>(
       static_cast<const Window*>(this)->GetRootWindow());
 }
 
 const Window* Window::GetRootWindow() const {
-  return dispatcher_ ? this : parent_ ? parent_->GetRootWindow() : NULL;
+  return IsRootWindow() ? this : parent_ ? parent_->GetRootWindow() : NULL;
 }
 
-WindowEventDispatcher* Window::GetDispatcher() {
-  return const_cast<WindowEventDispatcher*>(const_cast<const Window*>(this)->
-      GetDispatcher());
+WindowTreeHost* Window::GetHost() {
+  return const_cast<WindowTreeHost*>(const_cast<const Window*>(this)->
+      GetHost());
 }
 
-const WindowEventDispatcher* Window::GetDispatcher() const {
+const WindowTreeHost* Window::GetHost() const {
   const Window* root_window = GetRootWindow();
-  return root_window ? root_window->dispatcher_ : NULL;
+  return root_window ? root_window->host_ : NULL;
 }
 
 void Window::Show() {
   SetVisible(true);
 }
 
 void Window::Hide() {
   // RootWindow::OnVisibilityChanged will call ReleaseCapture.
   SetVisible(false);
 }
@@ skipping 37 matching lines @@
   }
   return bounds;
 }
 
 void Window::SetTransform(const gfx::Transform& transform) {
   if (!layer_) {
     // Transforms aren't supported on layerless windows.
     NOTREACHED();
     return;
   }
-  WindowEventDispatcher* dispatcher = GetDispatcher();
+  WindowEventDispatcher* dispatcher = GetHost()->dispatcher();
   bool contained_mouse = IsVisible() && dispatcher &&
       ContainsPointInRoot(dispatcher->GetLastMouseLocationInRoot());
   layer_->SetTransform(transform);
   if (dispatcher)
     dispatcher->OnWindowTransformed(this, contained_mouse);
 }
 
 void Window::SetLayoutManager(LayoutManager* layout_manager) {
   if (layout_manager == layout_manager_)
     return;
@@ skipping 116 matching lines @@
   child->parent_ = this;
 
   children_.push_back(child);
   if (layout_manager_)
     layout_manager_->OnWindowAddedToLayout(child);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowAdded(child));
   child->OnParentChanged();
 
   Window* root_window = GetRootWindow();
   if (root_window && old_root != root_window) {
-    root_window->GetDispatcher()->OnWindowAddedToRootWindow(child);
+    root_window->GetHost()->dispatcher()->OnWindowAddedToRootWindow(child);
     child->NotifyAddedToRootWindow();
   }
 
   params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGED;
   NotifyWindowHierarchyChange(params);
 }
 
 void Window::RemoveChild(Window* child) {
   WindowObserver::HierarchyChangeParams params;
   params.target = child;
@@ skipping 61 matching lines @@
   } else {
     ui::Layer::ConvertPointToLayer(source->layer_, target->layer_, point);
   }
 }
 
 void Window::MoveCursorTo(const gfx::Point& point_in_window) {
   Window* root_window = GetRootWindow();
   DCHECK(root_window);
   gfx::Point point_in_root(point_in_window);
   ConvertPointToTarget(this, root_window, &point_in_root);
-  root_window->GetDispatcher()->host()->MoveCursorTo(point_in_root);
+  root_window->GetHost()->MoveCursorTo(point_in_root);
 }
 
 gfx::NativeCursor Window::GetCursor(const gfx::Point& point) const {
   return delegate_ ? delegate_->GetCursor(point) : gfx::kNullCursor;
 }
 
 void Window::SetEventFilter(ui::EventHandler* event_filter) {
   if (event_filter_)
     RemovePreTargetHandler(event_filter_.get());
   event_filter_.reset(event_filter);
@@ skipping 54 matching lines @@
   DCHECK(client);
   client->FocusWindow(NULL);
 }
 
 bool Window::HasFocus() const {
   client::FocusClient* client = client::GetFocusClient(this);
   return client && client->GetFocusedWindow() == this;
 }
 
 bool Window::CanFocus() const {
-  if (dispatcher_)
+  if (IsRootWindow())
     return IsVisible();
 
   // NOTE: as part of focusing the window the ActivationClient may make the
   // window visible (by way of making a hidden ancestor visible). For this
   // reason we can't check visibility here and assume the client is doing it.
   if (!parent_ || (delegate_ && !delegate_->CanFocus()))
     return false;
 
   // The client may forbid certain windows from receiving focus at a given point
   // in time.
   client::EventClient* client = client::GetEventClient(GetRootWindow());
   if (client && !client->CanProcessEventsWithinSubtree(this))
     return false;
 
   return parent_->CanFocus();
 }
 
 bool Window::CanReceiveEvents() const {
-  if (dispatcher_)
+  if (IsRootWindow())
     return IsVisible();
 
   // The client may forbid certain windows from receiving events at a given
   // point in time.
   client::EventClient* client = client::GetEventClient(GetRootWindow());
   if (client && !client->CanProcessEventsWithinSubtree(this))
     return false;
 
   return parent_ && IsVisible() && parent_->CanReceiveEvents();
 }
@@ skipping 34 matching lines @@
   SetPropertyInternal(
       key, key, NULL, reinterpret_cast<int64>(value), 0);
 }
 
 void* Window::GetNativeWindowProperty(const char* key) const {
   return reinterpret_cast<void*>(GetPropertyInternal(key, 0));
 }
 
 void Window::OnDeviceScaleFactorChanged(float device_scale_factor) {
   ScopedCursorHider hider(this);
-  if (dispatcher_)
-    dispatcher_->host()->OnDeviceScaleFactorChanged(device_scale_factor);
+  if (IsRootWindow())
+    host_->OnDeviceScaleFactorChanged(device_scale_factor);
   if (delegate_)
     delegate_->OnDeviceScaleFactorChanged(device_scale_factor);
 }
 
 #if !defined(NDEBUG)
 std::string Window::GetDebugInfo() const {
   return base::StringPrintf(
       "%s<%d> bounds(%d, %d, %d, %d) %s %s opacity=%.1f",
       name().empty() ? "Unknown" : name().c_str(), id(),
       bounds().x(), bounds().y(), bounds().width(), bounds().height(),
@@ skipping 119 matching lines @@
 }
 
 void Window::SetVisible(bool visible) {
   if ((layer_ && visible == layer_->GetTargetVisibility()) ||
       (!layer_ && visible == visible_))
     return;  // No change.
 
   FOR_EACH_OBSERVER(WindowObserver, observers_,
                     OnWindowVisibilityChanging(this, visible));
 
-  WindowEventDispatcher* dispatcher = GetDispatcher();
-  if (dispatcher)
-    dispatcher->DispatchMouseExitToHidingWindow(this);
+  WindowTreeHost* host = GetHost();
+  if (host)
+    host->dispatcher()->DispatchMouseExitToHidingWindow(this);
 
   client::VisibilityClient* visibility_client =
       client::GetVisibilityClient(this);
   if (visibility_client)
     visibility_client->UpdateLayerVisibility(this, visible);
   else if (layer_)
     layer_->SetVisible(visible);
   visible_ = visible;
   SchedulePaint();
   if (parent_ && parent_->layout_manager_)
     parent_->layout_manager_->OnChildWindowVisibilityChanged(this, visible);
 
   if (delegate_)
     delegate_->OnWindowTargetVisibilityChanged(visible);
 
   NotifyWindowVisibilityChanged(this, visible);
 
-  if (dispatcher)
-    dispatcher->OnWindowVisibilityChanged(this, visible);
+  if (host)
+    host->dispatcher()->OnWindowVisibilityChanged(this, visible);
 }
 
 void Window::SchedulePaint() {
   SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
 }
 
 void Window::Paint(gfx::Canvas* canvas) {
   if (delegate_)
     delegate_->OnPaint(canvas);
   PaintLayerlessChildren(canvas);
@@ skipping 68 matching lines @@
   return delegate_ ? this : NULL;
 }
 
 void Window::RemoveChildImpl(Window* child, Window* new_parent) {
   if (layout_manager_)
     layout_manager_->OnWillRemoveWindowFromLayout(child);
   FOR_EACH_OBSERVER(WindowObserver, observers_, OnWillRemoveWindow(child));
   Window* root_window = child->GetRootWindow();
   Window* new_root_window = new_parent ? new_parent->GetRootWindow() : NULL;
   if (root_window && root_window != new_root_window) {
-    root_window->GetDispatcher()->OnWindowRemovedFromRootWindow(
+    root_window->GetHost()->dispatcher()->OnWindowRemovedFromRootWindow(
         child, new_root_window);
     child->NotifyRemovingFromRootWindow();
   }
 
   gfx::Vector2d offset;
   GetAncestorWithLayer(&offset);
   child->UnparentLayers(!layer_, offset);
   child->parent_ = NULL;
   Windows::iterator i = std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
@@ skipping 293 matching lines @@
     }
   }
 
   if (layout_manager_)
     layout_manager_->OnWindowResized();
   if (delegate_)
     delegate_->OnBoundsChanged(old_bounds, bounds());
   FOR_EACH_OBSERVER(WindowObserver,
                     observers_,
                     OnWindowBoundsChanged(this, old_bounds, bounds()));
-  WindowEventDispatcher* dispatcher = GetDispatcher();
-  if (dispatcher)
-    dispatcher->OnWindowBoundsChanged(this, contained_mouse);
+  WindowTreeHost* host = GetHost();
+  if (host)
+    host->dispatcher()->OnWindowBoundsChanged(this, contained_mouse);
 }
 
 void Window::OnPaintLayer(gfx::Canvas* canvas) {
   Paint(canvas);
 }
 
 base::Closure Window::PrepareForLayerBoundsChange() {
   return base::Bind(&Window::OnWindowBoundsChanged, base::Unretained(this),
                     bounds(), ContainsMouse());
 }
@@ skipping 18 matching lines @@
   if (!parent_)
     return true;
 
   // For located events (i.e. mouse, touch etc.), an assumption is made that
   // windows that don't have a delegate cannot process the event (see more in
   // GetWindowForPoint()). This assumption is not made for key events.
   return event.IsKeyEvent() || delegate_;
 }
 
 ui::EventTarget* Window::GetParentTarget() {
-  if (dispatcher_) {
+  if (IsRootWindow()) {
     return client::GetEventClient(this) ?
         client::GetEventClient(this)->GetToplevelEventTarget() :
             Env::GetInstance();
   }
   return parent_;
 }
 
 scoped_ptr<ui::EventTargetIterator> Window::GetChildIterator() const {
   return scoped_ptr<ui::EventTargetIterator>(
       new ui::EventTargetIteratorImpl<Window>(children()));
@@ skipping 20 matching lines @@
   if (id_ != -1)
     layer_name += " " + base::IntToString(id_);
 
   layer_->set_name(layer_name);
 #endif
 }
 
 bool Window::ContainsMouse() {
   bool contains_mouse = false;
   if (IsVisible()) {
-    WindowEventDispatcher* dispatcher = GetDispatcher();
-    contains_mouse = dispatcher &&
-        ContainsPointInRoot(dispatcher->GetLastMouseLocationInRoot());
+    WindowTreeHost* host = GetHost();
+    contains_mouse = host &&
+        ContainsPointInRoot(host->dispatcher()->GetLastMouseLocationInRoot());
   }
   return contains_mouse;
 }
 
 const Window* Window::GetAncestorWithLayer(gfx::Vector2d* offset) const {
   for (const aura::Window* window = this; window; window = window->parent()) {
     if (window->layer_)
       return window;
     if (offset)
       *offset += window->bounds().OffsetFromOrigin();
   }
   if (offset)
     *offset = gfx::Vector2d();
   return NULL;
 }
 
 }  // namespace aura