Revert of Clean up WindowEventDispatcher some more.

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 18 matching lines @@
 #include "base/sys_info.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/user_action_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/view_prop.h"
 #include "ui/base/x/x11_util.h"
-#include "ui/compositor/compositor.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/events/x/device_data_manager.h"
 #include "ui/events/x/device_list_cache_x.h"
 #include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/screen.h"
 
@@ skipping 347 matching lines @@
     }
     case KeyRelease: {
       ui::KeyEvent keyup_event(xev, false);
       SendEventToProcessor(&keyup_event);
       break;
     }
     case ButtonPress: {
       if (static_cast<int>(xev->xbutton.button) == kBackMouseButton ||
           static_cast<int>(xev->xbutton.button) == kForwardMouseButton) {
         client::UserActionClient* gesture_client =
-            client::GetUserActionClient(window());
+            client::GetUserActionClient(delegate_->AsDispatcher()->window());
         if (gesture_client) {
           gesture_client->OnUserAction(
               static_cast<int>(xev->xbutton.button) == kBackMouseButton ?
               client::UserActionClient::BACK :
               client::UserActionClient::FORWARD);
         }
         break;
       }
     }  // fallthrough
     case ButtonRelease: {
@@ skipping 12 matching lines @@
         case ui::ET_UNKNOWN:
           // No event is created for X11-release events for mouse-wheel buttons.
           break;
         default:
           NOTREACHED();
       }
       break;
     }
     case FocusOut:
       if (xev->xfocus.mode != NotifyGrab)
-        OnHostLostWindowCapture();
+        delegate_->OnHostLostWindowCapture();
       break;
     case ConfigureNotify: {
       DCHECK_EQ(xwindow_, xev->xconfigure.event);
       DCHECK_EQ(xwindow_, xev->xconfigure.window);
       // It's possible that the X window may be resized by some other means
       // than from within aura (e.g. the X window manager can change the
       // size). Make sure the root window size is maintained properly.
       gfx::Rect bounds(xev->xconfigure.x, xev->xconfigure.y,
           xev->xconfigure.width, xev->xconfigure.height);
       bool size_changed = bounds_.size() != bounds.size();
@@ skipping 112 matching lines @@
 }
 
 gfx::Rect WindowTreeHostX11::GetBounds() const {
   return bounds_;
 }
 
 void WindowTreeHostX11::SetBounds(const gfx::Rect& bounds) {
   // Even if the host window's size doesn't change, aura's root window
   // size, which is in DIP, changes when the scale changes.
   float current_scale = compositor()->device_scale_factor();
-  float new_scale = gfx::Screen::GetScreenFor(window())->
-      GetDisplayNearestWindow(window()).device_scale_factor();
+  float new_scale = gfx::Screen::GetScreenFor(
+      delegate_->AsDispatcher()->window())->GetDisplayNearestWindow(
+          delegate_->AsDispatcher()->window()).device_scale_factor();
   bool origin_changed = bounds_.origin() != bounds.origin();
   bool size_changed = bounds_.size() != bounds.size();
   XWindowChanges changes = {0};
   unsigned value_mask = 0;
 
   if (size_changed) {
     changes.width = bounds.width();
     changes.height = bounds.height();
     value_mask = CWHeight | CWWidth;
   }
@@ skipping 11 matching lines @@
   // manager, it can modify or ignore the request, but (per ICCCM) we'll get a
   // (possibly synthetic) ConfigureNotify about the actual size and correct
   // |bounds_| later.
   bounds_ = bounds;
   UpdateIsInternalDisplay();
   if (origin_changed)
     OnHostMoved(bounds.origin());
   if (size_changed || current_scale != new_scale) {
     OnHostResized(bounds.size());
   } else {
-    window()->SchedulePaintInRect(window()->bounds());
+    delegate_->AsDispatcher()->window()->SchedulePaintInRect(
+        delegate_->AsDispatcher()->window()->bounds());
   }
 }
 
 gfx::Insets WindowTreeHostX11::GetInsets() const {
   return insets_;
 }
 
 void WindowTreeHostX11::SetInsets(const gfx::Insets& insets) {
   insets_ = insets;
   if (pointer_barriers_) {
@@ skipping 102 matching lines @@
     case KeyRelease:
     case ButtonPress:
     case ButtonRelease: {
       // The fields used below are in the same place for all of events
       // above. Using xmotion from XEvent's unions to avoid repeating
       // the code.
       xevent.xmotion.root = x_root_window_;
       xevent.xmotion.time = CurrentTime;
 
       gfx::Point point(xevent.xmotion.x, xevent.xmotion.y);
-      ConvertPointToNativeScreen(&point);
+      delegate_->AsDispatcher()->host()->ConvertPointToNativeScreen(&point);
       xevent.xmotion.x_root = point.x();
       xevent.xmotion.y_root = point.y();
     }
     default:
       break;
   }
   XSendEvent(xdisplay_, xwindow_, False, 0, &xevent);
 }
 
 void WindowTreeHostX11::OnDeviceScaleFactorChanged(
@@ skipping 19 matching lines @@
 
 void WindowTreeHostX11::OnCursorVisibilityChangedNative(bool show) {
   SetCrOSTapPaused(!show);
 }
 
 void WindowTreeHostX11::OnWindowInitialized(Window* window) {
 }
 
 void WindowTreeHostX11::OnRootWindowInitialized(
     WindowEventDispatcher* d) {
-  // UpdateIsInternalDisplay relies on WED's kDisplayIdKey property being set
-  // available by the time WED::Init is called. (set in
-  // DisplayManager::CreateRootWindowForDisplay)
+  // 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 (d != dispatcher())
+  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 dispatcher();
+  return delegate_->GetEventProcessor();
 }
 
 void WindowTreeHostX11::DispatchXI2Event(const base::NativeEvent& event) {
   ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
   XEvent* xev = event;
   if (!factory->ShouldProcessXI2Event(xev))
     return;
 
   TRACE_EVENT1("input", "WindowTreeHostX11::DispatchXI2Event",
                "event_latency_us",
@@ skipping 69 matching lines @@
           xev = &last_event;
       } else if (type == ui::ET_MOUSE_PRESSED ||
                  type == ui::ET_MOUSE_RELEASED) {
         XIDeviceEvent* xievent =
             static_cast<XIDeviceEvent*>(xev->xcookie.data);
         int button = xievent->detail;
         if (button == kBackMouseButton || button == kForwardMouseButton) {
           if (type == ui::ET_MOUSE_RELEASED)
             break;
           client::UserActionClient* gesture_client =
-              client::GetUserActionClient(window());
+              client::GetUserActionClient(delegate_->AsDispatcher()->window());
           if (gesture_client) {
             bool reverse_direction =
                 ui::IsTouchpadEvent(xev) && ui::IsNaturalScrollEnabled();
             gesture_client->OnUserAction(
                 (button == kBackMouseButton && !reverse_direction) ||
                 (button == kForwardMouseButton && reverse_direction) ?
                 client::UserActionClient::BACK :
                 client::UserActionClient::FORWARD);
           }
           break;
@@ skipping 110 matching lines @@
 }
 
 namespace test {
 
 void SetUseOverrideRedirectWindowByDefault(bool override_redirect) {
   default_override_redirect = override_redirect;
 }
 
 }  // namespace test
 }  // namespace aura