aura: Start using EventPrcessor interface for event dispatch.

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/bind.h"
 #include "base/command_line.h"
@@ skipping 72 matching lines @@
 }
 
 RootWindowHost* CreateHost(RootWindow* root_window,
                            const RootWindow::CreateParams& params) {
   RootWindowHost* host = params.host ?
       params.host : RootWindowHost::Create(params.initial_bounds);
   host->set_delegate(root_window);
   return host;
 }
 
+bool IsUsingEventProcessorForDispatch(const ui::Event& event) {
+  return event.IsKeyEvent() ||
+         event.IsScrollEvent();
+}
+
 class SimpleRootWindowTransformer : public RootWindowTransformer {
  public:
   SimpleRootWindowTransformer(const Window* root_window,
                               const gfx::Transform& transform)
       : root_window_(root_window),
         transform_(transform) {
   }
 
   // RootWindowTransformer overrides:
   virtual gfx::Transform GetTransform() const OVERRIDE {
@@ skipping 42 matching lines @@
     : window_(new Window(NULL)),
       host_(CreateHost(this, params)),
       touch_ids_down_(0),
       last_cursor_(ui::kCursorNull),
       mouse_pressed_handler_(NULL),
       mouse_moved_handler_(NULL),
       event_dispatch_target_(NULL),
       old_dispatch_target_(NULL),
       synthesize_mouse_move_(false),
       move_hold_count_(0),
+      dispatching_held_event_(false),
       repost_event_factory_(this),
       held_event_factory_(this) {
   window()->set_dispatcher(this);
   window()->SetName("RootWindow");
   window()->set_event_targeter(
       scoped_ptr<ui::EventTargeter>(new WindowTargeter()));
 
   compositor_.reset(new ui::Compositor(host_->GetAcceleratedWidget()));
   DCHECK(compositor_.get());
 
@@ skipping 59 matching lines @@
   // We allow for only one outstanding repostable event. This is used
   // in exiting context menus.  A dropped repost request is allowed.
   if (event.type() == ui::ET_MOUSE_PRESSED) {
     held_repostable_event_.reset(
         new ui::MouseEvent(
             static_cast<const ui::MouseEvent&>(event),
             static_cast<aura::Window*>(event.target()),
             window()));
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(&RootWindow::DispatchHeldEventsAsync,
+        base::Bind(base::IgnoreResult(&RootWindow::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.
   }
 }
 
 RootWindowHostDelegate* RootWindow::AsRootWindowHostDelegate() {
@@ skipping 203 matching lines @@
 void RootWindow::ReleasePointerMoves() {
   --move_hold_count_;
   DCHECK_GE(move_hold_count_, 0);
   if (!move_hold_count_ && held_move_event_) {
     // We don't want to call DispatchHeldEvents directly, because this might be
     // called from a deep stack while another event, in which case dispatching
     // another one may not be safe/expected.  Instead we post a task, that we
     // may cancel if HoldPointerMoves is called again before it executes.
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(&RootWindow::DispatchHeldEventsAsync,
+        base::Bind(base::IgnoreResult(&RootWindow::DispatchHeldEvents),
                    held_event_factory_.GetWeakPtr()));
   }
   TRACE_EVENT_ASYNC_END0("ui", "RootWindow::HoldPointerMoves", this);
 }
 
 gfx::Point RootWindow::GetLastMouseLocationInRoot() const {
   gfx::Point location = Env::GetInstance()->last_mouse_location();
   client::ScreenPositionClient* client =
       client::GetScreenPositionClient(window());
   if (client)
@@ skipping 105 matching lines @@
   // crbug.com/157583
   if (reason != WINDOW_MOVING) {
     Window* capture_window = aura::client::GetCaptureWindow(window());
     // If the ancestor of the capture window is hidden,
     // release the capture.
     if (invisible->Contains(capture_window) && invisible != window())
       capture_window->ReleaseCapture();
 
     if (invisible->Contains(event_dispatch_target_))
       event_dispatch_target_ = NULL;
+
+    if (invisible->Contains(old_dispatch_target_))
+      old_dispatch_target_ = NULL;
   }
 
   // If the ancestor of any event handler windows are invisible, release the
   // pointer to those windows.
   if (invisible->Contains(mouse_pressed_handler_))
     mouse_pressed_handler_ = NULL;
   if (invisible->Contains(mouse_moved_handler_))
     mouse_moved_handler_ = NULL;
 
   CleanupGestureState(invisible);
@@ skipping 64 matching lines @@
 void RootWindow::ReleaseNativeCapture() {
   host_->ReleaseCapture();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::EventProcessor implementation:
 ui::EventTarget* RootWindow::GetRootTarget() {
   return window();
 }
 
+void RootWindow::PrepareEventForDispatch(ui::Event* event) {
+  if (event->IsMouseEvent() ||
+      event->IsScrollEvent() ||
+      event->IsTouchEvent() ||
+      event->IsGestureEvent()) {
+    TransformEventForDeviceScaleFactor(static_cast<ui::LocatedEvent*>(event));
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::EventDispatcherDelegate implementation:
 
 bool RootWindow::CanDispatchToTarget(ui::EventTarget* target) {
   return event_dispatch_target_ == target;
 }
 
 ui::EventDispatchDetails RootWindow::PreDispatchEvent(ui::EventTarget* target,
                                                       ui::Event* event) {
+  if (!dispatching_held_event_ && IsUsingEventProcessorForDispatch(*event)) {
+    DispatchDetails details = DispatchHeldEvents();
+    if (details.dispatcher_destroyed || details.target_destroyed)
+      return details;
+
+    Window* target_window = static_cast<Window*>(target);
+    if (event->IsScrollEvent()) {
+      PreDispatchLocatedEvent(target_window,
+                              static_cast<ui::ScrollEvent*>(event));
+    }
+  }
   old_dispatch_target_ = event_dispatch_target_;
   event_dispatch_target_ = static_cast<Window*>(target);
   return DispatchDetails();
 }
 
 ui::EventDispatchDetails RootWindow::PostDispatchEvent(ui::EventTarget* target,
                                                        const ui::Event& event) {
   DispatchDetails details;
   if (target != event_dispatch_target_)
     details.target_destroyed = true;
@@ skipping 34 matching lines @@
 }
 
 void RootWindow::OnLayerAnimationAborted(
     ui::LayerAnimationSequence* animation) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, RootWindowHostDelegate implementation:
 
 bool RootWindow::OnHostKeyEvent(ui::KeyEvent* event) {
-  DispatchDetails details = DispatchHeldEvents();
+  DispatchDetails details = OnEventFromSource(event);
   if (details.dispatcher_destroyed)
-    return false;
-  if (event->key_code() == ui::VKEY_UNKNOWN)
-    return false;
-  client::EventClient* client = client::GetEventClient(window());
-  Window* focused_window = client::GetFocusClient(window())->GetFocusedWindow();
-  if (client && !client->CanProcessEventsWithinSubtree(focused_window)) {
-    client::GetFocusClient(window())->FocusWindow(NULL);
-    return false;
-  }
-  details = DispatchEvent(focused_window ? focused_window : window(), event);
-  if (details.dispatcher_destroyed)
-    return true;
+    event->SetHandled();
   return event->handled();
 }
 
 bool RootWindow::OnHostMouseEvent(ui::MouseEvent* event) {
   DispatchDetails details = OnHostMouseEventImpl(event);
   return event->handled() || details.dispatcher_destroyed;
 }
 
 bool RootWindow::OnHostScrollEvent(ui::ScrollEvent* event) {
-  DispatchDetails details = DispatchHeldEvents();
+  DispatchDetails details = OnEventFromSource(event);
   if (details.dispatcher_destroyed)
-    return false;
-
-  TransformEventForDeviceScaleFactor(event);
-  SetLastMouseLocation(window(), event->location());
-  synthesize_mouse_move_ = false;
-
-  Window* target = mouse_pressed_handler_ ?
-      mouse_pressed_handler_ : client::GetCaptureWindow(window());
-
-  if (!target)
-    target = window()->GetEventHandlerForPoint(event->location());
-
-  if (!target)
-    target = window();
-
-  event->ConvertLocationToTarget(window(), target);
-  int flags = event->flags();
-  if (IsNonClientLocation(target, event->location()))
-    flags |= ui::EF_IS_NON_CLIENT;
-  event->set_flags(flags);
-
-  details = DispatchEvent(target, event);
-  if (details.dispatcher_destroyed)
-    return true;
+    event->SetHandled();
   return event->handled();
 }
 
 bool RootWindow::OnHostTouchEvent(ui::TouchEvent* event) {
   if ((event->type() == ui::ET_TOUCH_MOVED)) {
     if (move_hold_count_) {
       Window* null_window = static_cast<Window*>(NULL);
       held_move_event_.reset(
           new ui::TouchEvent(*event, null_window, null_window));
       return true;
@@ skipping 282 matching lines @@
 
   // Get the list of GestureEvents from GestureRecognizer.
   scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
   gestures.reset(ui::GestureRecognizer::Get()->
       ProcessTouchEventForGesture(event_for_gr, result, target));
 
   return ProcessGestures(gestures.get());
 }
 
 ui::EventDispatchDetails RootWindow::DispatchHeldEvents() {
+  CHECK(!dispatching_held_event_);
+  dispatching_held_event_ = true;
+
   DispatchDetails dispatch_details;
   if (held_repostable_event_) {
     if (held_repostable_event_->type() == ui::ET_MOUSE_PRESSED) {
       scoped_ptr<ui::MouseEvent> mouse_event(
           static_cast<ui::MouseEvent*>(held_repostable_event_.release()));
       dispatch_details = DispatchMouseEventRepost(mouse_event.get());
     } else {
       // TODO(rbyers): GESTURE_TAP_DOWN not yet supported: crbug.com/170987.
       NOTREACHED();
     }
     if (dispatch_details.dispatcher_destroyed)
       return dispatch_details;
   }
 
   if (held_move_event_ && held_move_event_->IsMouseEvent()) {
     // If a mouse move has been synthesized, the target location is suspect,
     // so drop the held event.
-    if (!synthesize_mouse_move_)
+    if (!synthesize_mouse_move_) {
       dispatch_details = DispatchMouseEventImpl(
           static_cast<ui::MouseEvent*>(held_move_event_.get()));
+    }
     if (!dispatch_details.dispatcher_destroyed)
       held_move_event_.reset();
   } else if (held_move_event_ && held_move_event_->IsTouchEvent()) {
     dispatch_details = DispatchTouchEventImpl(
         static_cast<ui::TouchEvent*>(held_move_event_.get()));
     if (!dispatch_details.dispatcher_destroyed)
       held_move_event_.reset();
   }
 
+  if (!dispatch_details.dispatcher_destroyed)
+    dispatching_held_event_ = false;
   return dispatch_details;
 }
 
-void RootWindow::DispatchHeldEventsAsync() {
-  DispatchDetails details = DispatchHeldEvents();
-  if (details.dispatcher_destroyed)
-    return;
-}
-
 void RootWindow::PostMouseMoveEventAfterWindowChange() {
   if (synthesize_mouse_move_)
     return;
   synthesize_mouse_move_ = true;
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&RootWindow::SynthesizeMouseMoveEventAsync,
                  held_event_factory_.GetWeakPtr()));
 }
 
@@ skipping 21 matching lines @@
     return;
 }
 
 gfx::Transform RootWindow::GetInverseRootTransform() const {
   float scale = ui::GetDeviceScaleFactor(window()->layer());
   gfx::Transform transform;
   transform.Scale(1.0f / scale, 1.0f / scale);
   return transformer_->GetInverseTransform() * transform;
 }
 
+void RootWindow::PreDispatchLocatedEvent(Window* target,
+                                         ui::LocatedEvent* event) {
+  int flags = event->flags();
+  if (IsNonClientLocation(target, event->location()))
+    flags |= ui::EF_IS_NON_CLIENT;
+  event->set_flags(flags);
+
+  if (!dispatching_held_event_) {
+    SetLastMouseLocation(window(), event->location());
+    synthesize_mouse_move_ = false;
+  }
+}
+
 }  // namespace aura