events: Start changing EventHandler interface to not return a value.

ui/aura/root_window.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/root_window.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 243 matching lines @@
   Window* target = client::GetCaptureWindow(this);
   if (!target) {
     target = ConsumerToWindow(
         gesture_recognizer_->GetTargetForGestureEvent(event));
     if (!target)
       return false;
   }
 
   if (target) {
     event->ConvertLocationToTarget(static_cast<Window*>(this), target);
-    ui::EventResult status = ProcessGestureEvent(target, event);
-    return status != ui::ER_UNHANDLED;
+    ProcessGestureEvent(target, event);
+    return event->default_prevented();
   }
 
   return false;
 }
 
 void RootWindow::OnWindowDestroying(Window* window) {
   OnWindowHidden(window, WINDOW_DESTROYED, NULL);
 
   if (window->IsVisible() &&
       window->ContainsPointInRoot(GetLastMouseLocationInRoot())) {
@@ skipping 332 matching lines @@
   if (mouse_moved_handler_ && mouse_moved_handler_->delegate()) {
     ui::MouseEvent translated_event(event,
                                     static_cast<Window*>(this),
                                     mouse_moved_handler_,
                                     ui::ET_MOUSE_ENTERED,
                                     event.flags());
     ProcessMouseEvent(mouse_moved_handler_, &translated_event);
   }
 }
 
-bool RootWindow::ProcessMouseEvent(Window* target, ui::MouseEvent* event) {
+void RootWindow::ProcessMouseEvent(Window* target, ui::MouseEvent* event) {
   base::AutoReset<Window*> reset(&event_dispatch_target_, target);
-  return ProcessEvent(target, event) != ui::ER_UNHANDLED;
+  ProcessEvent(target, event);
 }
 
-bool RootWindow::ProcessKeyEvent(Window* target, ui::KeyEvent* event) {
+void RootWindow::ProcessKeyEvent(Window* target, ui::KeyEvent* event) {
   if (!target)
     target = this;
   base::AutoReset<Window*> reset(&event_dispatch_target_, target);
-  return ProcessEvent(target, event) != ui::ER_UNHANDLED;
+  ProcessEvent(target, event);
 }
 
-bool RootWindow::ProcessScrollEvent(Window* target, ui::ScrollEvent* event) {
+void RootWindow::ProcessScrollEvent(Window* target, ui::ScrollEvent* event) {
   base::AutoReset<Window*> reset(&event_dispatch_target_, target);
-  return ProcessEvent(target, event) != ui::ER_UNHANDLED;
+  ProcessEvent(target, event);
 }
 
-ui::EventResult RootWindow::ProcessTouchEvent(Window* target,
-                                              ui::TouchEvent* event) {
+void RootWindow::ProcessTouchEvent(Window* target, ui::TouchEvent* event) {
   if (!target)
     target = this;
   base::AutoReset<Window*> reset(&event_dispatch_target_, target);
-  return static_cast<ui::EventResult>(ProcessEvent(target, event));
+  ProcessEvent(target, event);
 }
 
-ui::EventResult RootWindow::ProcessGestureEvent(Window* target,
-                                                ui::GestureEvent* event) {
+void RootWindow::ProcessGestureEvent(Window* target, ui::GestureEvent* event) {
   if (!target)
     target = this;
   base::AutoReset<Window*> reset(&event_dispatch_target_, target);
-  return static_cast<ui::EventResult>(ProcessEvent(target, event));
+  ProcessEvent(target, event);
 }
 
 bool RootWindow::ProcessGestures(ui::GestureRecognizer::Gestures* gestures) {
   if (!gestures)
     return false;
   bool handled = false;
   for (unsigned int i = 0; i < gestures->size(); i++) {
     ui::GestureEvent* gesture = gestures->get().at(i);
     if (DispatchGestureEvent(gesture) != ui::ER_UNHANDLED)
       handled = true;
@@ skipping 122 matching lines @@
 bool RootWindow::OnHostKeyEvent(ui::KeyEvent* event) {
   DispatchHeldMouseMove();
   if (event->key_code() == ui::VKEY_UNKNOWN)
     return false;
   client::EventClient* client = client::GetEventClient(GetRootWindow());
   Window* focused_window = client::GetFocusClient(this)->GetFocusedWindow();
   if (client && !client->CanProcessEventsWithinSubtree(focused_window)) {
     client::GetFocusClient(this)->FocusWindow(NULL, NULL);
     return false;
   }
-  return ProcessKeyEvent(focused_window, event);
+  ProcessKeyEvent(focused_window, event);
+  return event->default_prevented();
 }
 
 bool RootWindow::OnHostMouseEvent(ui::MouseEvent* event) {
   if (event->type() == ui::ET_MOUSE_DRAGGED ||
       (event->flags() & ui::EF_IS_SYNTHESIZED)) {
     if (mouse_move_hold_count_) {
       Window* null_window = static_cast<Window*>(NULL);
       held_mouse_move_.reset(
           new ui::MouseEvent(*event, null_window, null_window));
       return true;
@@ skipping 22 matching lines @@
     target = GetEventHandlerForPoint(event->location());
 
   if (target && target->delegate()) {
     int flags = event->flags();
     gfx::Point location_in_window = event->location();
     Window::ConvertPointToTarget(this, target, &location_in_window);
     if (IsNonClientLocation(target, location_in_window))
       flags |= ui::EF_IS_NON_CLIENT;
     event->set_flags(flags);
     event->ConvertLocationToTarget(static_cast<Window*>(this), target);
-    return ProcessScrollEvent(target, event);
+    ProcessScrollEvent(target, event);
+    return event->default_prevented();
   }
   return false;
 }
 
 bool RootWindow::OnHostTouchEvent(ui::TouchEvent* event) {
   DispatchHeldMouseMove();
   switch (event->type()) {
     case ui::ET_TOUCH_PRESSED:
       touch_ids_down_ |= (1 << event->touch_id());
       Env::GetInstance()->set_touch_down(touch_ids_down_ != 0);
       break;
 
     // Don't handle ET_TOUCH_CANCELLED since we always get a ET_TOUCH_RELEASED.
     case ui::ET_TOUCH_RELEASED:
       touch_ids_down_ = (touch_ids_down_ | (1 << event->touch_id())) ^
                         (1 << event->touch_id());
       Env::GetInstance()->set_touch_down(touch_ids_down_ != 0);
       break;
 
     default:
       break;
   }
   TransformEventForDeviceScaleFactor(event);
   bool handled = false;
-  ui::EventResult result = ui::ER_UNHANDLED;
   Window* target = client::GetCaptureWindow(this);
   if (!target) {
     target = ConsumerToWindow(
         gesture_recognizer_->GetTouchLockedTarget(event));
     if (!target) {
       target = ConsumerToWindow(
           gesture_recognizer_->GetTargetForLocation(event->location()));
     }
   }
 
+  ui::EventResult result = ui::ER_UNHANDLED;
   if (!target && !bounds().Contains(event->location())) {
     // If the initial touch is outside the root window, target the root.
     target = this;
-    result = ProcessTouchEvent(target, event);
-    CHECK_EQ(ui::ER_UNHANDLED, result);
+    ProcessTouchEvent(target, event);
+    CHECK_EQ(ui::ER_UNHANDLED, event->result());
+    result = event->result();
   } else {
     // We only come here when the first contact was within the root window.
     if (!target) {
       target = GetEventHandlerForPoint(event->location());
       if (!target)
         return false;
     }
 
     ui::TouchEvent translated_event(
         *event, static_cast<Window*>(this), target);
-    result = ProcessTouchEvent(target, &translated_event);
-    handled = result != ui::ER_UNHANDLED;
+    ProcessTouchEvent(target, &translated_event);
+    handled = translated_event.default_prevented();
+    result = translated_event.result();
   }
 
   // Get the list of GestureEvents from GestureRecognizer.
   scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
   gestures.reset(gesture_recognizer_->ProcessTouchEventForGesture(
       *event, result, target));
 
   return ProcessGestures(gestures.get()) ? true : handled;
 }
 
@@ skipping 87 matching lines @@
           ~event->changed_button_flags();
       Env::GetInstance()->set_mouse_button_flags(mouse_button_flags_);
       break;
     default:
       break;
   }
   if (target) {
     event->ConvertLocationToTarget(static_cast<Window*>(this), target);
     if (IsNonClientLocation(target, event->location()))
       event->set_flags(event->flags() | ui::EF_IS_NON_CLIENT);
-    return ProcessMouseEvent(target, event);
+    ProcessMouseEvent(target, event);
+    return event->default_prevented();
   }
   return false;
 }
 
 void RootWindow::DispatchHeldMouseMove() {
   if (held_mouse_move_.get()) {
     // If a mouse move has been synthesized, the target location is suspect,
     // so drop the held event.
     if (!synthesize_mouse_move_)
       DispatchMouseEventImpl(held_mouse_move_.get());
@@ skipping 30 matching lines @@
   ui::MouseEvent event(ui::ET_MOUSE_MOVED,
                        orig_mouse_location,
                        orig_mouse_location,
                        ui::EF_IS_SYNTHESIZED);
   event.set_system_location(Env::GetInstance()->last_mouse_location());
   OnHostMouseEvent(&event);
 #endif
 }
 
 }  // namespace aura