Window ownership -> WindowTreeHost

ui/aura/window_tree_host_x11.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_tree_host_x11.h"
 
 #include <strings.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/XInput2.h>
@@ skipping 345 matching lines @@
   XEvent* xev = event;
 
   if (FindEventTarget(event) == x_root_window_) {
     if (event->type == GenericEvent)
       DispatchXI2Event(event);
     return POST_DISPATCH_NONE;
   }
 
   switch (xev->type) {
     case EnterNotify: {
-      aura::Window* root_window = GetDispatcher()->window();
+      aura::Window* root_window = window();
       client::CursorClient* cursor_client =
           client::GetCursorClient(root_window);
       if (cursor_client) {
         const gfx::Display display = gfx::Screen::GetScreenFor(root_window)->
             GetDisplayNearestWindow(root_window);
         cursor_client->SetDisplay(display);
       }
       ui::MouseEvent mouse_event(xev);
       // EnterNotify creates ET_MOUSE_MOVE. Mark as synthesized as this is not
       // real mouse move event.
@@ skipping 251 matching lines @@
 void WindowTreeHostX11::SetCapture() {
   // TODO(oshima): Grab x input.
 }
 
 void WindowTreeHostX11::ReleaseCapture() {
   // TODO(oshima): Release x input.
 }
 
 bool WindowTreeHostX11::QueryMouseLocation(gfx::Point* location_return) {
   client::CursorClient* cursor_client =
-      client::GetCursorClient(GetDispatcher()->window());
+      client::GetCursorClient(window());
   if (cursor_client && !cursor_client->IsMouseEventsEnabled()) {
     *location_return = gfx::Point(0, 0);
     return false;
   }
 
   ::Window root_return, child_return;
   int root_x_return, root_y_return, win_x_return, win_y_return;
   unsigned int mask_return;
   XQueryPointer(xdisplay_,
                 xwindow_,
@@ skipping 111 matching lines @@
 }
 
 void WindowTreeHostX11::OnCursorVisibilityChangedNative(bool show) {
   SetCrOSTapPaused(!show);
 }
 
 void WindowTreeHostX11::OnWindowInitialized(Window* window) {
 }
 
 void WindowTreeHostX11::OnRootWindowInitialized(
-    WindowEventDispatcher* dispatcher) {
+    WindowEventDispatcher* d) {
   // UpdateIsInternalDisplay relies on:
   // 1. delegate_ pointing to WindowEventDispatcher - available after
   //    SetDelegate.
   // 2. WED's kDisplayIdKey property set - available by the time
   //    WED::Init is called.
   //    (set in DisplayManager::CreateRootWindowForDisplay)
   // Ready when NotifyRootWindowInitialized is called from WED::Init.
-  if (!delegate_ || dispatcher != GetDispatcher())
+  if (!delegate_ || d != dispatcher())
     return;
   UpdateIsInternalDisplay();
 
   // We have to enable Tap-to-click by default because the cursor is set to
   // visible in Shell::InitRootWindowController.
   SetCrOSTapPaused(false);
 }
 
 ui::EventProcessor* WindowTreeHostX11::GetEventProcessor() {
   return delegate_->GetEventProcessor();
@@ skipping 134 matching lines @@
   return XGetSelectionOwner(
       xdisplay_, atom_cache_.GetAtom("WM_S0")) != None;
 }
 
 void WindowTreeHostX11::SetCursorInternal(gfx::NativeCursor cursor) {
   XDefineCursor(xdisplay_, xwindow_, cursor.platform());
 }
 
 void WindowTreeHostX11::TranslateAndDispatchMouseEvent(
     ui::MouseEvent* event) {
-  Window* root_window = GetDispatcher()->window();
+  Window* root_window = window();
   client::ScreenPositionClient* screen_position_client =
       client::GetScreenPositionClient(root_window);
   gfx::Rect local(bounds_.size());
 
   if (screen_position_client && !local.Contains(event->location())) {
     gfx::Point location(event->location());
     // In order to get the correct point in screen coordinates
     // during passive grab, we first need to find on which host window
     // the mouse is on, and find out the screen coordinates on that
     // host window, then convert it back to this host window's coordinate.
     screen_position_client->ConvertHostPointToScreen(root_window, &location);
     screen_position_client->ConvertPointFromScreen(root_window, &location);
     ConvertPointToHost(&location);
     event->set_location(location);
     event->set_root_location(location);
   }
   SendEventToProcessor(event);
 }
 
 void WindowTreeHostX11::UpdateIsInternalDisplay() {
-  Window* root_window = GetDispatcher()->window();
+  Window* root_window = window();
   gfx::Screen* screen = gfx::Screen::GetScreenFor(root_window);
   gfx::Display display = screen->GetDisplayNearestWindow(root_window);
   is_internal_display_ = display.IsInternal();
 }
 
 void WindowTreeHostX11::SetCrOSTapPaused(bool state) {
 #if defined(OS_CHROMEOS)
   if (!ui::IsXInput2Available())
     return;
   // Temporarily pause tap-to-click when the cursor is hidden.
@@ skipping 34 matching lines @@
 }
 
 namespace test {
 
 void SetUseOverrideRedirectWindowByDefault(bool override_redirect) {
   default_override_redirect = override_redirect;
 }
 
 }  // namespace test
 }  // namespace aura