Revert of Clean up WindowEventDispatcher some more.

ui/aura/window_tree_host_win.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_win.h"
 
 #include <windows.h>
 
 #include <algorithm>
 
 #include "base/message_loop/message_loop.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/cursor/cursor_loader_win.h"
 #include "ui/base/view_prop.h"
-#include "ui/compositor/compositor.h"
 #include "ui/events/event.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/screen.h"
 
 using std::max;
 using std::min;
 
 namespace aura {
 namespace {
@@ skipping 101 matching lines @@
       NULL,
       window_rect.left,
       window_rect.top,
       window_rect.right - window_rect.left,
       window_rect.bottom - window_rect.top,
       SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOREDRAW | SWP_NOREPOSITION);
 
   // Explicity call OnHostResized when the scale has changed because
   // the window size may not have changed.
   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();
   if (current_scale != new_scale)
     OnHostResized(bounds.size());
 }
 
 gfx::Insets WindowTreeHostWin::GetInsets() const {
   return gfx::Insets();
 }
 
 void WindowTreeHostWin::SetInsets(const gfx::Insets& insets) {
 }
@@ skipping 73 matching lines @@
 void WindowTreeHostWin::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
   NOTIMPLEMENTED();
 }
 
 void WindowTreeHostWin::PrepareForShutdown() {
   NOTIMPLEMENTED();
 }
 
 ui::EventProcessor* WindowTreeHostWin::GetEventProcessor() {
-  return dispatcher();
+  return delegate_->GetEventProcessor();
 }
 
 void WindowTreeHostWin::OnClose() {
   // TODO: this obviously shouldn't be here.
   base::MessageLoopForUI::current()->Quit();
 }
 
 LRESULT WindowTreeHostWin::OnKeyEvent(UINT message,
                                       WPARAM w_param,
                                       LPARAM l_param) {
@@ skipping 17 matching lines @@
   }
   SetMsgHandled(handled);
   return 0;
 }
 
 LRESULT WindowTreeHostWin::OnCaptureChanged(UINT message,
                                             WPARAM w_param,
                                             LPARAM l_param) {
   if (has_capture_) {
     has_capture_ = false;
-    OnHostLostWindowCapture();
+    delegate_->OnHostLostWindowCapture();
   }
   return 0;
 }
 
 LRESULT WindowTreeHostWin::OnNCActivate(UINT message,
                                         WPARAM w_param,
                                         LPARAM l_param) {
   if (!!w_param)
-    OnHostActivated();
+    delegate_->OnHostActivated();
   return DefWindowProc(hwnd(), message, w_param, l_param);
 }
 
 void WindowTreeHostWin::OnMove(const gfx::Point& point) {
   OnHostMoved(point);
 }
 
 void WindowTreeHostWin::OnPaint(HDC dc) {
   gfx::Rect damage_rect;
   RECT update_rect = {0};
   if (GetUpdateRect(hwnd(), &update_rect, FALSE))
     damage_rect = gfx::Rect(update_rect);
   compositor()->ScheduleRedrawRect(damage_rect);
   ValidateRect(hwnd(), NULL);
 }
 
 void WindowTreeHostWin::OnSize(UINT param, const gfx::Size& size) {
   // Minimizing resizes the window to 0x0 which causes our layout to go all
   // screwy, so we just ignore it.
-  if (param != SIZE_MINIMIZED)
+  if (delegate_ && param != SIZE_MINIMIZED)
     OnHostResized(size);
 }
 
 namespace test {
 
 // static
 void SetUsePopupAsRootWindowForTest(bool use) {
   use_popup_as_root_window_for_test = use;
 }
 
 }  // namespace test
 
 }  // namespace aura