Make ToplevelWindowEventFilter and WorkspaceEventFilter into event handlers.

ash/wm/workspace/workspace_event_handler.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 "ash/wm/workspace/workspace_event_filter.h"
+#include "ash/wm/workspace/workspace_event_handler.h"
 
 #include "ash/screen_ash.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/workspace_window_resizer.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/events/event.h"
 #include "ui/base/hit_test.h"
@@ skipping 31 matching lines @@
     }
   } else {
     window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   }
 }
 
 }  // namespace
 
 namespace internal {
 
-WorkspaceEventFilter::WorkspaceEventFilter(aura::Window* owner)
-    : ToplevelWindowEventFilter(owner),
+WorkspaceEventHandler::WorkspaceEventHandler(aura::Window* owner)
+    : ToplevelWindowEventHandler(owner),
       destroyed_(NULL) {
 }
 
-WorkspaceEventFilter::~WorkspaceEventFilter() {
+WorkspaceEventHandler::~WorkspaceEventHandler() {
   if (destroyed_)
     *destroyed_ = true;
 }
 
-bool WorkspaceEventFilter::PreHandleMouseEvent(aura::Window* target,
-                                               ui::MouseEvent* event) {
+ui::EventResult WorkspaceEventHandler::OnMouseEvent(ui::MouseEvent* event) {
+  aura::Window* target = static_cast<aura::Window*>(event->target());
   switch (event->type()) {
     case ui::ET_MOUSE_MOVED: {
       int component =
           target->delegate()->GetNonClientComponent(event->location());
       multi_window_resize_controller_.Show(target, component,
                                            event->location());
       break;
     }
     case ui::ET_MOUSE_ENTERED:
       break;
     case ui::ET_MOUSE_CAPTURE_CHANGED:
     case ui::ET_MOUSE_EXITED:
       break;
     case ui::ET_MOUSE_PRESSED: {
       if (event->flags() & ui::EF_IS_DOUBLE_CLICK &&
           target->delegate()->GetNonClientComponent(event->location()) ==
           HTCAPTION) {
         bool destroyed = false;
         destroyed_ = &destroyed;
         ToggleMaximizedState(target);
         if (destroyed)
-          return false;
+          return ui::ER_UNHANDLED;
         destroyed_ = NULL;
       }
       multi_window_resize_controller_.Hide();
       HandleVerticalResizeDoubleClick(target, event);
       break;
     }
     default:
       break;
   }
-  return ToplevelWindowEventFilter::PreHandleMouseEvent(target, event);
+  return ToplevelWindowEventHandler::OnMouseEvent(event);
 }
 
-ui::EventResult WorkspaceEventFilter::PreHandleGestureEvent(
-    aura::Window* target,
-    ui::GestureEvent* event) {
+ui::EventResult WorkspaceEventHandler::OnGestureEvent(ui::GestureEvent* event) {
+  aura::Window* target = static_cast<aura::Window*>(event->target());
   if (event->type() == ui::ET_GESTURE_DOUBLE_TAP &&
       target->delegate()->GetNonClientComponent(event->location()) ==
       HTCAPTION) {
     ToggleMaximizedState(target);  // |this| may be destroyed from here.
     return ui::ER_CONSUMED;
   }
-  return ToplevelWindowEventFilter::PreHandleGestureEvent(target, event);
+  return ToplevelWindowEventHandler::OnGestureEvent(event);
 }
 
-WindowResizer* WorkspaceEventFilter::CreateWindowResizer(
+WindowResizer* WorkspaceEventHandler::CreateWindowResizer(
     aura::Window* window,
     const gfx::Point& point_in_parent,
     int window_component) {
   // Allow dragging maximized windows if it's not tracked by workspace. This is
   // set by tab dragging code.
   if (!wm::IsWindowNormal(window) &&
       (window_component != HTCAPTION || GetTrackedByWorkspace(window))) {
     return NULL;
   }
   return WorkspaceWindowResizer::Create(
       window, point_in_parent, window_component,
       std::vector<aura::Window*>());
 }
 
-void WorkspaceEventFilter::HandleVerticalResizeDoubleClick(
+void WorkspaceEventHandler::HandleVerticalResizeDoubleClick(
     aura::Window* target,
     ui::MouseEvent* event) {
   if (event->flags() & ui::EF_IS_DOUBLE_CLICK &&
       !wm::IsWindowMaximized(target)) {
     int component =
         target->delegate()->GetNonClientComponent(event->location());
     gfx::Rect work_area =
         gfx::Screen::GetDisplayNearestWindow(target).work_area();
     const gfx::Rect* restore_bounds =
         target->GetProperty(aura::client::kRestoreBoundsKey);
@@ skipping 20 matching lines @@
                                      target->bounds().y(),
                                      work_area.width(),
                                      target->bounds().height()));
       }
     }
   }
 }
 
 }  // namespace internal
 }  // namespace ash