Clean up WindowEventDispatcher some more.

ui/aura/window_event_dispatcher.cc

 // Copyright 2014 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_event_dispatcher.h"
 
-#include <vector>
-
 #include "base/bind.h"
-#include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/dip_util.h"
-#include "ui/compositor/layer.h"
-#include "ui/compositor/layer_animator.h"
 #include "ui/events/event.h"
 #include "ui/events/gestures/gesture_recognizer.h"
 #include "ui/events/gestures/gesture_types.h"
-#include "ui/gfx/screen.h"
-
-using std::vector;
 
 typedef ui::EventDispatchDetails DispatchDetails;
 
 namespace aura {
 
 namespace {
 
 // Returns true if |target| has a non-client (frame) component at |location|,
 // in window coordinates.
 bool IsNonClientLocation(Window* target, const gfx::Point& location) {
@@ skipping 77 matching lines @@
             base::IgnoreResult(&WindowEventDispatcher::DispatchHeldEvents),
             repost_event_factory_.GetWeakPtr()));
   } else {
     DCHECK(event.type() == ui::ET_GESTURE_TAP_DOWN);
     held_repostable_event_.reset();
     // TODO(rbyers): Reposing of gestures is tricky to get
     // right, so it's not yet supported.  crbug.com/170987.
   }
 }
 
-WindowTreeHostDelegate* WindowEventDispatcher::AsWindowTreeHostDelegate() {
-  return this;
-}
-
 void WindowEventDispatcher::OnMouseEventsEnableStateChanged(bool enabled) {
   // Send entered / exited so that visual state can be updated to match
   // mouse events state.
   PostMouseMoveEventAfterWindowChange();
   // TODO(mazda): Add code to disable mouse events when |enabled| == false.
 }
 
+void WindowEventDispatcher::DispatchCancelModeEvent() {
+  ui::CancelModeEvent event;
+  Window* focused_window = client::GetFocusClient(window())->GetFocusedWindow();
+  if (focused_window && !window()->Contains(focused_window))
+    focused_window = NULL;
+  DispatchDetails details =
+      DispatchEvent(focused_window ? focused_window : window(), &event);
+  if (details.dispatcher_destroyed)
+    return;
+}
+
 Window* WindowEventDispatcher::GetGestureTarget(ui::GestureEvent* event) {
   Window* target = NULL;
   if (!event->IsEndingEvent()) {
     // The window that received the start event (e.g. scroll begin) needs to
     // receive the end event (e.g. scroll end).
     target = client::GetCaptureWindow(window());
   }
   if (!target) {
     target = ConsumerToWindow(
         ui::GestureRecognizer::Get()->GetTargetForGestureEvent(*event));
@@ skipping 115 matching lines @@
 
 gfx::Point WindowEventDispatcher::GetLastMouseLocationInRoot() const {
   gfx::Point location = Env::GetInstance()->last_mouse_location();
   client::ScreenPositionClient* client =
       client::GetScreenPositionClient(window());
   if (client)
     client->ConvertPointFromScreen(window(), &location);
   return location;
 }
 
+void WindowEventDispatcher::OnHostLostMouseGrab() {
+  mouse_pressed_handler_ = NULL;
+  mouse_moved_handler_ = NULL;
+}
+
+void WindowEventDispatcher::OnHostResized(const gfx::Size& size) {
+  TRACE_EVENT1("ui", "WindowEventDispatcher::OnHostResized",
+               "size", size.ToString());
+
+  DispatchDetails details = DispatchHeldEvents();
+  if (details.dispatcher_destroyed)
+    return;
+
+  // Constrain the mouse position within the new root Window size.
+  gfx::Point point;
+  if (host_->QueryMouseLocation(&point)) {
+    SetLastMouseLocation(window(),
+                         ui::ConvertPointToDIP(window()->layer(), point));
+  }
+  synthesize_mouse_move_ = false;
+}
+
+void WindowEventDispatcher::OnCursorMovedToRootLocation(
+    const gfx::Point& root_location) {
+  SetLastMouseLocation(window(), root_location);
+  synthesize_mouse_move_ = false;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // WindowEventDispatcher, private:
 
 void WindowEventDispatcher::TransformEventForDeviceScaleFactor(
     ui::LocatedEvent* event) {
   event->UpdateForRootTransform(host()->GetInverseRootTransform());
 }
 
 ui::EventDispatchDetails WindowEventDispatcher::DispatchMouseEnterOrExit(
     const ui::MouseEvent& event,
@@ skipping 261 matching lines @@
   DispatchGestureEvent(event);
 }
 
 void WindowEventDispatcher::DispatchCancelTouchEvent(ui::TouchEvent* event) {
   DispatchDetails details = OnEventFromSource(event);
   if (details.dispatcher_destroyed)
     return;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// WindowEventDispatcher, ui::LayerAnimationObserver implementation:
-
-void WindowEventDispatcher::OnLayerAnimationEnded(
-    ui::LayerAnimationSequence* animation) {
-  host()->UpdateRootWindowSize(host_->GetBounds().size());
-}
-
-void WindowEventDispatcher::OnLayerAnimationScheduled(
-    ui::LayerAnimationSequence* animation) {
-}
-
-void WindowEventDispatcher::OnLayerAnimationAborted(
-    ui::LayerAnimationSequence* animation) {
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// WindowEventDispatcher, WindowTreeHostDelegate implementation:
-
-void WindowEventDispatcher::OnHostCancelMode() {
-  ui::CancelModeEvent event;
-  Window* focused_window = client::GetFocusClient(window())->GetFocusedWindow();
-  if (focused_window && !window()->Contains(focused_window))
-    focused_window = NULL;
-  DispatchDetails details =
-      DispatchEvent(focused_window ? focused_window : window(), &event);
-  if (details.dispatcher_destroyed)
-    return;
-}
-
-void WindowEventDispatcher::OnHostActivated() {
-  Env::GetInstance()->RootWindowActivated(this);
-}
-
-void WindowEventDispatcher::OnHostLostWindowCapture() {
-  Window* capture_window = client::GetCaptureWindow(window());
-  if (capture_window && capture_window->GetRootWindow() == window())
-    capture_window->ReleaseCapture();
-}
-
-void WindowEventDispatcher::OnHostLostMouseGrab() {
-  mouse_pressed_handler_ = NULL;
-  mouse_moved_handler_ = NULL;
-}
-
-void WindowEventDispatcher::OnHostResized(const gfx::Size& size) {
-  TRACE_EVENT1("ui", "WindowEventDispatcher::OnHostResized",
-               "size", size.ToString());
-
-  DispatchDetails details = DispatchHeldEvents();
-  if (details.dispatcher_destroyed)
-    return;
-
-  // Constrain the mouse position within the new root Window size.
-  gfx::Point point;
-  if (host_->QueryMouseLocation(&point)) {
-    SetLastMouseLocation(window(),
-                         ui::ConvertPointToDIP(window()->layer(), point));
-  }
-  synthesize_mouse_move_ = false;
-}
-
-void WindowEventDispatcher::OnCursorMovedToRootLocation(
-    const gfx::Point& root_location) {
-  SetLastMouseLocation(window(), root_location);
-  synthesize_mouse_move_ = false;
-}
-
-WindowEventDispatcher* WindowEventDispatcher::AsDispatcher() {
-  return this;
-}
-
-const WindowEventDispatcher* WindowEventDispatcher::AsDispatcher() const {
-  return this;
-}
-
-ui::EventProcessor* WindowEventDispatcher::GetEventProcessor() {
-  return this;
-}
-
-////////////////////////////////////////////////////////////////////////////////
 // WindowEventDispatcher, private:
 
 ui::EventDispatchDetails WindowEventDispatcher::DispatchHeldEvents() {
   if (!held_repostable_event_ && !held_move_event_)
     return DispatchDetails();
 
   CHECK(!dispatching_held_event_);
   dispatching_held_event_ = true;
 
   DispatchDetails dispatch_details;
@@ skipping 198 matching lines @@
       break;
 
     default:
       NOTREACHED();
       break;
   }
   PreDispatchLocatedEvent(target, event);
 }
 
 }  // namespace aura