Window ownership -> WindowTreeHost

content/browser/renderer_host/render_widget_host_view_aura.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 "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 130 matching lines @@
   if (GetProp(window, kWidgetOwnerProperty) == widget)
     SetParent(window, ui::GetHiddenWindow());
   return TRUE;
 }
 
 BOOL CALLBACK ShowWindowsCallback(HWND window, LPARAM param) {
   RenderWidgetHostViewAura* widget =
       reinterpret_cast<RenderWidgetHostViewAura*>(param);
 
   if (GetProp(window, kWidgetOwnerProperty) == widget &&
-      widget->GetNativeView()->GetDispatcher()) {
-    HWND parent = widget->GetNativeView()->GetDispatcher()->host()->
-        GetAcceleratedWidget();
+      widget->GetNativeView()->GetHost()) {
+    HWND parent = widget->GetNativeView()->GetHost()->GetAcceleratedWidget();
     SetParent(window, parent);
   }
   return TRUE;
 }
 
 struct CutoutRectsParams {
   RenderWidgetHostViewAura* widget;
   std::vector<gfx::Rect> cutout_rects;
   std::map<HWND, WebPluginGeometry>* geometry;
 };
 
 // Used to update the region for the windowed plugin to draw in. We start with
 // the clip rect from the renderer, then remove the cutout rects from the
 // renderer, and then remove the transient windows from the root window and the
 // constrained windows from the parent window.
 BOOL CALLBACK SetCutoutRectsCallback(HWND window, LPARAM param) {
   CutoutRectsParams* params = reinterpret_cast<CutoutRectsParams*>(param);
 
   if (GetProp(window, kWidgetOwnerProperty) == params->widget) {
     // First calculate the offset of this plugin from the root window, since
     // the cutouts are relative to the root window.
-    HWND parent = params->widget->GetNativeView()->GetDispatcher()->
-        host()->GetAcceleratedWidget();
+    HWND parent =
+        params->widget->GetNativeView()->GetHost()->GetAcceleratedWidget();
     POINT offset;
     offset.x = offset.y = 0;
     MapWindowPoints(window, parent, &offset, 1);
 
     // Now get the cached clip rect and cutouts for this plugin window that came
     // from the renderer.
     std::map<HWND, WebPluginGeometry>::iterator i = params->geometry->begin();
     while (i != params->geometry->end() &&
            i->second.window != window &&
            GetParent(i->second.window) != window) {
@@ skipping 428 matching lines @@
       released_front_lock_ = compositor->GetCompositorLock();
   }
 
 #if defined(OS_WIN)
   if (legacy_render_widget_host_HWND_) {
     // Reparent the legacy Chrome_RenderWidgetHostHWND window to the parent
     // window before reparenting any plugins. This ensures that the plugin
     // windows stay on top of the child Zorder in the parent and receive
     // mouse events, etc.
     legacy_render_widget_host_HWND_->UpdateParent(
-        GetNativeView()->GetDispatcher()->host()->GetAcceleratedWidget());
+        GetNativeView()->GetHost()->GetAcceleratedWidget());
     legacy_render_widget_host_HWND_->SetBounds(
         window_->GetBoundsInRootWindow());
   }
   LPARAM lparam = reinterpret_cast<LPARAM>(this);
   EnumChildWindows(ui::GetHiddenWindow(), ShowWindowsCallback, lparam);
 #endif
 }
 
 void RenderWidgetHostViewAura::WasHidden() {
   if (!host_ || host_->is_hidden())
     return;
   host_->WasHidden();
   software_frame_manager_->SetVisibility(false);
   delegated_frame_evictor_->SetVisible(false);
   released_front_lock_ = NULL;
 
 #if defined(OS_WIN)
   constrained_rects_.clear();
-  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
-  if (dispatcher) {
-    HWND parent = dispatcher->host()->GetAcceleratedWidget();
+  aura::WindowTreeHost* host = window_->GetHost();
+  if (host) {
+    HWND parent = host->GetAcceleratedWidget();
     LPARAM lparam = reinterpret_cast<LPARAM>(this);
     EnumChildWindows(parent, HideWindowsCallback, lparam);
     // We reparent the legacy Chrome_RenderWidgetHostHWND window to the global
     // hidden window on the same lines as Windowed plugin windows.
     if (legacy_render_widget_host_HWND_)
       legacy_render_widget_host_HWND_->UpdateParent(ui::GetHiddenWindow());
   }
 #endif
 }
 
@@ skipping 18 matching lines @@
           window_->parent(), &relative_origin);
     }
   }
 
   InternalSetBounds(gfx::Rect(relative_origin, rect.size()));
 }
 
 void RenderWidgetHostViewAura::MaybeCreateResizeLock() {
   if (!ShouldCreateResizeLock())
     return;
-  DCHECK(window_->GetDispatcher());
-  DCHECK(window_->GetDispatcher()->host()->compositor());
+  DCHECK(window_->GetHost());
+  DCHECK(window_->GetHost()->compositor());
 
   // Listen to changes in the compositor lock state.
-  ui::Compositor* compositor = window_->GetDispatcher()->host()->compositor();
+  ui::Compositor* compositor = window_->GetHost()->compositor();
   if (!compositor->HasObserver(this))
     compositor->AddObserver(this);
 
   bool defer_compositor_lock =
       can_lock_compositor_ == NO_PENDING_RENDERER_FRAME ||
       can_lock_compositor_ == NO_PENDING_COMMIT;
 
   if (can_lock_compositor_ == YES)
     can_lock_compositor_ = YES_DID_LOCK;
 
@@ skipping 17 matching lines @@
 
   if (host_->should_auto_resize())
     return false;
   if (!host_->is_accelerated_compositing_active())
     return false;
 
   gfx::Size desired_size = window_->bounds().size();
   if (desired_size == current_frame_size_)
     return false;
 
-  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
-  if (!dispatcher)
+  aura::WindowTreeHost* host = window_->GetHost();
+  if (!host)
     return false;
 
-  ui::Compositor* compositor = dispatcher->host()->compositor();
+  ui::Compositor* compositor = host->compositor();
   if (!compositor)
     return false;
 
   return true;
 }
 
 scoped_ptr<ResizeLock> RenderWidgetHostViewAura::CreateResizeLock(
     bool defer_compositor_lock) {
   gfx::Size desired_size = window_->bounds().size();
   return scoped_ptr<ResizeLock>(new CompositorResizeLock(
-      window_->GetDispatcher(),
+      window_->GetHost()->dispatcher(),
       desired_size,
       defer_compositor_lock,
       base::TimeDelta::FromMilliseconds(kResizeLockTimeoutMs)));
 }
 
 void RenderWidgetHostViewAura::RequestCopyOfOutput(
     scoped_ptr<cc::CopyOutputRequest> request) {
   window_->layer()->RequestCopyOfOutput(request.Pass());
 }
 
 gfx::NativeView RenderWidgetHostViewAura::GetNativeView() const {
   return window_;
 }
 
 gfx::NativeViewId RenderWidgetHostViewAura::GetNativeViewId() const {
 #if defined(OS_WIN)
-  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
-  if (dispatcher)
-    return reinterpret_cast<gfx::NativeViewId>(
-        dispatcher->host()->GetAcceleratedWidget());
+  aura::WindowTreeHost* host = window_->GetHost();
+  if (host)
+    return reinterpret_cast<gfx::NativeViewId>(host->GetAcceleratedWidget());
 #endif
   return static_cast<gfx::NativeViewId>(NULL);
 }
 
 gfx::NativeViewAccessible RenderWidgetHostViewAura::GetNativeViewAccessible() {
 #if defined(OS_WIN)
-  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
-  if (!dispatcher)
+  aura::WindowTreeHost* host = window_->GetHost();
+  if (!host)
     return static_cast<gfx::NativeViewAccessible>(NULL);
-  HWND hwnd = dispatcher->host()->GetAcceleratedWidget();
+  HWND hwnd = host->GetAcceleratedWidget();
 
   CreateBrowserAccessibilityManagerIfNeeded();
   BrowserAccessibilityManager* manager = GetBrowserAccessibilityManager();
   if (manager)
     return manager->GetRoot()->ToBrowserAccessibilityWin();
 #endif
 
   NOTIMPLEMENTED();
   return static_cast<gfx::NativeViewAccessible>(NULL);
 }
 
 void RenderWidgetHostViewAura::SetKeyboardFocus() {
 #if defined(OS_WIN)
   if (CanFocus()) {
-    aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
-    if (dispatcher)
-      ::SetFocus(dispatcher->host()->GetAcceleratedWidget());
+    aura::WindowTreeHost* host = window_->GetHost();
+    if (host)
+      ::SetFocus(host->GetAcceleratedWidget());
   }
 #endif
 }
 
 void RenderWidgetHostViewAura::MovePluginWindows(
     const gfx::Vector2d& scroll_offset,
     const std::vector<WebPluginGeometry>& plugin_window_moves) {
 #if defined(OS_WIN)
   // We need to clip the rectangle to the tab's viewport, otherwise we will draw
   // over the browser UI.
   if (!window_->GetRootWindow()) {
     DCHECK(plugin_window_moves.empty());
     return;
   }
-  HWND parent = window_->GetDispatcher()->host()->GetAcceleratedWidget();
+  HWND parent = window_->GetHost()->GetAcceleratedWidget();
   gfx::Rect view_bounds = window_->GetBoundsInRootWindow();
   std::vector<WebPluginGeometry> moves = plugin_window_moves;
 
   gfx::Rect view_port(scroll_offset.x(), scroll_offset.y(), view_bounds.width(),
                       view_bounds.height());
 
   for (size_t i = 0; i < moves.size(); ++i) {
     gfx::Rect clip(moves[i].clip_rect);
     gfx::Vector2d view_port_offset(
         moves[i].window_rect.OffsetFromOrigin() + scroll_offset);
@@ skipping 164 matching lines @@
   if (paint_canvas_) {
     SkRect sk_clip_rect;
     if (paint_canvas_->sk_canvas()->getClipBounds(&sk_clip_rect))
       clip_rect = gfx::ToEnclosingRect(gfx::SkRectToRectF(sk_clip_rect));
   }
 
   if (!scroll_rect.IsEmpty())
     SchedulePaintIfNotInClip(scroll_rect, clip_rect);
 
 #if defined(OS_WIN)
-  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
+  aura::WindowTreeHost* host = window_->GetHost();
 #endif
   for (size_t i = 0; i < copy_rects.size(); ++i) {
     gfx::Rect rect = gfx::SubtractRects(copy_rects[i], scroll_rect);
     if (rect.IsEmpty())
       continue;
 
     SchedulePaintIfNotInClip(rect, clip_rect);
 
 #if defined(OS_WIN)
-    if (dispatcher) {
+    if (host) {
       // Send the invalid rect in screen coordinates.
       gfx::Rect screen_rect = GetViewBounds();
       gfx::Rect invalid_screen_rect(rect);
       invalid_screen_rect.Offset(screen_rect.x(), screen_rect.y());
-      HWND hwnd = dispatcher->host()->GetAcceleratedWidget();
+      HWND hwnd = host->GetAcceleratedWidget();
       PaintPluginWindowsHelper(hwnd, invalid_screen_rect);
     }
 #endif  // defined(OS_WIN)
   }
 }
 
 void RenderWidgetHostViewAura::RenderProcessGone(base::TerminationStatus status,
                                                  int error_code) {
   UpdateCursorIfOverSelf();
   Destroy();
@@ skipping 345 matching lines @@
           base::Bind(callback, present_time));
     }
   }
 }
 
 #if defined(OS_WIN)
 void RenderWidgetHostViewAura::UpdateConstrainedWindowRects(
     const std::vector<gfx::Rect>& rects) {
   // Check this before setting constrained_rects_, so that next time they're set
   // and we have a root window we don't early return.
-  if (!window_->GetDispatcher())
+  if (!window_->GetHost())
     return;
 
   if (rects == constrained_rects_)
     return;
 
   constrained_rects_ = rects;
 
-  HWND parent = window_->GetDispatcher()->host()->GetAcceleratedWidget();
+  HWND parent = window_->GetHost()->GetAcceleratedWidget();
   CutoutRectsParams params;
   params.widget = this;
   params.cutout_rects = constrained_rects_;
   params.geometry = &plugin_window_moves_;
   LPARAM lparam = reinterpret_cast<LPARAM>(&params);
   EnumChildWindows(parent, SetCutoutRectsCallback, lparam);
 }
 #endif
 
 void RenderWidgetHostViewAura::AcceleratedSurfaceBuffersSwapped(
@@ skipping 746 matching lines @@
   GetScreenInfoForWindow(results, window_->GetRootWindow() ? window_ : NULL);
 }
 
 gfx::Rect RenderWidgetHostViewAura::GetBoundsInRootWindow() {
 #if defined(OS_WIN)
   // aura::Window::GetBoundsInScreen doesn't take non-client area into
   // account.
   RECT window_rect = {0};
 
   aura::Window* top_level = window_->GetToplevelWindow();
-  aura::WindowEventDispatcher* dispatcher = top_level->GetDispatcher();
-  if (!dispatcher)
+  aura::WindowTreeHost* host = top_level->GetHost();
+  if (!host)
     return top_level->GetBoundsInScreen();
-  HWND hwnd = dispatcher->host()->GetAcceleratedWidget();
+  HWND hwnd = host->GetAcceleratedWidget();
   ::GetWindowRect(hwnd, &window_rect);
   gfx::Rect rect(window_rect);
 
   // Maximized windows are outdented from the work area by the frame thickness
   // even though this "frame" is not painted.  This confuses code (and people)
   // that think of a maximized window as corresponding exactly to the work area.
   // Correct for this by subtracting the frame thickness back off.
   if (::IsZoomed(hwnd)) {
     rect.Inset(GetSystemMetrics(SM_CXSIZEFRAME),
                GetSystemMetrics(SM_CYSIZEFRAME));
@@ skipping 12 matching lines @@
     touch_editing_client_->GestureEventAck(event.type);
 }
 
 void RenderWidgetHostViewAura::ProcessAckedTouchEvent(
     const TouchEventWithLatencyInfo& touch, InputEventAckState ack_result) {
   ScopedVector<ui::TouchEvent> events;
   if (!MakeUITouchEventsFromWebTouchEvents(touch, &events,
                                            SCREEN_COORDINATES))
     return;
 
-  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
+  aura::WindowTreeHost* host = window_->GetHost();
   // |dispatcher| is NULL during tests.
-  if (!dispatcher)
+  if (!host)
     return;
 
   ui::EventResult result = (ack_result ==
       INPUT_EVENT_ACK_STATE_CONSUMED) ? ui::ER_HANDLED : ui::ER_UNHANDLED;
   for (ScopedVector<ui::TouchEvent>::iterator iter = events.begin(),
       end = events.end(); iter != end; ++iter) {
-    dispatcher->ProcessedTouchEvent((*iter), window_, result);
+    host->dispatcher()->ProcessedTouchEvent((*iter), window_, result);
   }
 }
 
 scoped_ptr<SyntheticGestureTarget>
 RenderWidgetHostViewAura::CreateSyntheticGestureTarget() {
   return scoped_ptr<SyntheticGestureTarget>(
       new SyntheticGestureTargetAura(host_));
 }
 
 void RenderWidgetHostViewAura::SetHasHorizontalScrollbar(
     bool has_horizontal_scrollbar) {
   // Not needed. Mac-only.
 }
 
 void RenderWidgetHostViewAura::SetScrollOffsetPinning(
     bool is_pinned_to_left, bool is_pinned_to_right) {
   // Not needed. Mac-only.
 }
 
 void RenderWidgetHostViewAura::CreateBrowserAccessibilityManagerIfNeeded() {
   if (GetBrowserAccessibilityManager())
     return;
 
   BrowserAccessibilityManager* manager = NULL;
 #if defined(OS_WIN)
-  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
-  if (!dispatcher)
+  aura::WindowTreeHost* host = window_->GetHost();
+  if (!host)
     return;
-  HWND hwnd = dispatcher->host()->GetAcceleratedWidget();
+  HWND hwnd = host->GetAcceleratedWidget();
 
   // The accessible_parent may be NULL at this point. The WebContents will pass
   // it down to this instance (by way of the RenderViewHost and
   // RenderWidgetHost) when it is known. This instance will then set it on its
   // BrowserAccessibilityManager.
   gfx::NativeViewAccessible accessible_parent =
       host_->GetParentNativeViewAccessible();
 
   if (legacy_render_widget_host_HWND_) {
     manager = new BrowserAccessibilityManagerWin(
@@ skipping 29 matching lines @@
     cursor_client->HideCursor();
     cursor_client->LockCursor();
   }
 
   if (ShouldMoveToCenter()) {
     synthetic_move_sent_ = true;
     window_->MoveCursorTo(gfx::Rect(window_->bounds().size()).CenterPoint());
   }
   tooltip_disabler_.reset(new aura::client::ScopedTooltipDisabler(root_window));
 
-  root_window->GetDispatcher()->host()->ConfineCursorToRootWindow();
+  root_window->GetHost()->ConfineCursorToRootWindow();
   return true;
 }
 
 void RenderWidgetHostViewAura::UnlockMouse() {
   tooltip_disabler_.reset();
 
   aura::Window* root_window = window_->GetRootWindow();
   if (!mouse_locked_ || !root_window)
     return;
 
   mouse_locked_ = false;
 
 #if !defined(OS_WIN)
   window_->ReleaseCapture();
 #endif
   window_->MoveCursorTo(unlocked_mouse_position_);
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root_window);
   if (cursor_client) {
     cursor_client->UnlockCursor();
     cursor_client->ShowCursor();
   }
 
   host_->LostMouseLock();
-  root_window->GetDispatcher()->host()->UnConfineCursor();
+  root_window->GetHost()->UnConfineCursor();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ui::TextInputClient implementation:
 void RenderWidgetHostViewAura::SetCompositionText(
     const ui::CompositionText& composition) {
   if (!host_)
     return;
 
   // ui::CompositionUnderline should be identical to
@@ skipping 350 matching lines @@
 }
 
 void RenderWidgetHostViewAura::OnWindowDestroying(aura::Window* window) {
 #if defined(OS_WIN)
   HWND parent = NULL;
   // If the tab was hidden and it's closed, host_->is_hidden would have been
   // reset to false in RenderWidgetHostImpl::RendererExited.
   if (!window_->GetRootWindow() || host_->is_hidden()) {
     parent = ui::GetHiddenWindow();
   } else {
-    parent = window_->GetDispatcher()->host()->GetAcceleratedWidget();
+    parent = window_->GetHost()->GetAcceleratedWidget();
   }
   LPARAM lparam = reinterpret_cast<LPARAM>(this);
   EnumChildWindows(parent, WindowDestroyingCallback, lparam);
 #endif
 
   // Make sure that the input method no longer references to this object before
   // this object is removed from the root window (i.e. this object loses access
   // to the input method).
   ui::InputMethod* input_method = GetInputMethod();
   if (input_method)
@@ skipping 206 matching lines @@
        event->type() == ui::ET_MOUSE_MOVED)) {
     event->StopPropagation();
     return;
   }
 
   if (event->type() == ui::ET_MOUSEWHEEL) {
 #if defined(OS_WIN)
     // We get mouse wheel/scroll messages even if we are not in the foreground.
     // So here we check if we have any owned popup windows in the foreground and
     // dismiss them.
-    aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
-    if (dispatcher) {
-      HWND parent = dispatcher->host()->GetAcceleratedWidget();
+    aura::WindowTreeHost* host = window_->GetHost();
+    if (host) {
+      HWND parent = host->GetAcceleratedWidget();
       HWND toplevel_hwnd = ::GetAncestor(parent, GA_ROOT);
       EnumThreadWindows(GetCurrentThreadId(),
                         DismissOwnedPopups,
                         reinterpret_cast<LPARAM>(toplevel_hwnd));
     }
 #endif
     blink::WebMouseWheelEvent mouse_wheel_event =
         MakeWebMouseWheelEvent(static_cast<ui::MouseWheelEvent*>(event));
     if (mouse_wheel_event.deltaX != 0 || mouse_wheel_event.deltaY != 0)
       host_->ForwardWheelEvent(mouse_wheel_event);
@@ skipping 144 matching lines @@
 
   // If a gesture is not processed by the webpage, then WebKit processes it
   // (e.g. generates synthetic mouse events).
   event->SetHandled();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, aura::client::ActivationDelegate implementation:
 
 bool RenderWidgetHostViewAura::ShouldActivate() const {
-  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
-  if (!dispatcher)
+  aura::WindowTreeHost* host = window_->GetHost();
+  if (!host)
     return true;
-  const ui::Event* event = dispatcher->current_event();
+  const ui::Event* event = host->dispatcher()->current_event();
   if (!event)
     return true;
   return is_fullscreen_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura,
 //     aura::client::ActivationChangeObserver implementation:
 
 void RenderWidgetHostViewAura::OnWindowActivated(aura::Window* gained_active,
                                                  aura::Window* lost_active) {
   DCHECK(window_ == gained_active || window_ == lost_active);
   if (window_ == gained_active) {
-    const ui::Event* event = window_->GetDispatcher()->current_event();
+    const ui::Event* event = window_->GetHost()->dispatcher()->current_event();
     if (event && PointerEventActivates(*event))
       host_->OnPointerEventActivate();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, aura::client::CursorClientObserver implementation:
 
 void RenderWidgetHostViewAura::OnCursorVisibilityChanged(bool is_visible) {
   NotifyRendererOfCursorVisibilityState(is_visible);
@@ skipping 216 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, private:
 
 RenderWidgetHostViewAura::~RenderWidgetHostViewAura() {
   if (touch_editing_client_)
     touch_editing_client_->OnViewDestroyed();
 
   ImageTransportFactory::GetInstance()->RemoveObserver(this);
 
   window_observer_.reset();
-  if (window_->GetDispatcher())
-    window_->GetDispatcher()->RemoveRootWindowObserver(this);
+  if (window_->GetHost())
+    window_->GetHost()->dispatcher()->RemoveRootWindowObserver(this);
   UnlockMouse();
   if (popup_parent_host_view_) {
     DCHECK(popup_parent_host_view_->popup_child_host_view_ == NULL ||
            popup_parent_host_view_->popup_child_host_view_ == this);
     popup_parent_host_view_->popup_child_host_view_ = NULL;
   }
   if (popup_child_host_view_) {
     DCHECK(popup_child_host_view_->popup_parent_host_view_ == NULL ||
            popup_child_host_view_->popup_parent_host_view_ == this);
     popup_child_host_view_->popup_parent_host_view_ = NULL;
@@ skipping 162 matching lines @@
   DCHECK(compositor);
 
   if (!compositor->HasObserver(this))
     compositor->AddObserver(this);
 
   can_lock_compositor_ = NO_PENDING_COMMIT;
   on_compositing_did_commit_callbacks_.push_back(callback);
 }
 
 void RenderWidgetHostViewAura::AddedToRootWindow() {
-  window_->GetDispatcher()->AddRootWindowObserver(this);
+  window_->GetHost()->dispatcher()->AddRootWindowObserver(this);
   UpdateScreenInfo(window_);
 
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(window_->GetRootWindow());
   if (cursor_client) {
     cursor_client->AddObserver(this);
     NotifyRendererOfCursorVisibilityState(cursor_client->IsCursorVisible());
   }
   if (current_surface_.get())
     UpdateExternalTexture();
@@ skipping 20 matching lines @@
 }
 
 void RenderWidgetHostViewAura::RemovingFromRootWindow() {
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(window_->GetRootWindow());
   if (cursor_client)
     cursor_client->RemoveObserver(this);
 
   DetachFromInputMethod();
 
-  window_->GetDispatcher()->RemoveRootWindowObserver(this);
+  window_->GetHost()->dispatcher()->RemoveRootWindowObserver(this);
   ui::Compositor* compositor = GetCompositor();
   if (current_surface_.get()) {
     // We can't get notification for commits after this point, which would
     // guarantee that the compositor isn't using an old texture any more, so
     // instead we force the layer to stop using any external resources which
     // synchronizes with the compositor thread, and makes it safe to run the
     // callback.
     window_->layer()->SetShowPaintedContent();
   }
   RunOnCommitCallbacks();
@@ skipping 10 matching lines @@
     legacy_render_widget_host_HWND_->UpdateParent(::GetDesktopWindow());
 #endif
 
   if (vsync_manager_) {
     vsync_manager_->RemoveObserver(this);
     vsync_manager_ = NULL;
   }
 }
 
 ui::Compositor* RenderWidgetHostViewAura::GetCompositor() const {
-  aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
-  return dispatcher ? dispatcher->host()->compositor() : NULL;
+  aura::WindowTreeHost* host = window_->GetHost();
+  return host ? host->compositor() : NULL;
 }
 
 void RenderWidgetHostViewAura::DetachFromInputMethod() {
   ui::InputMethod* input_method = GetInputMethod();
   if (input_method && input_method->GetTextInputClient() == this)
     input_method->SetFocusedTextInputClient(NULL);
 }
 
 void RenderWidgetHostViewAura::LockResources() {
   DCHECK(frame_provider_);
@@ skipping 13 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content