events: Allow retrieving the current event being dispatched from EventDispatcher.

content/browser/renderer_host/render_widget_host_view_aura.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 "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 157 matching lines @@
   return pinch_allowed;
 }
 
 bool ShouldReleaseFrontSurface() {
   static bool release_front_surface_allowed =
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableUIReleaseFrontSurface);
   return release_front_surface_allowed;
 }
 
+bool PointerEventActivates(const ui::Event& event) {
+  if (event.type() == ui::ET_MOUSE_PRESSED)
+    return true;
+
+  if (event.type() == ui::ET_GESTURE_BEGIN) {
+    const ui::GestureEvent& gesture =
+        static_cast<const ui::GestureEvent&>(event);
+    return gesture.details().touch_points() == 1;
+  }
+
+  return false;
+}
+
 }  // namespace
 
 // We have to implement the WindowObserver interface on a separate object
 // because clang doesn't like implementing multiple interfaces that have
 // methods with the same name. This object is owned by the
 // RenderWidgetHostViewAura.
 class RenderWidgetHostViewAura::WindowObserver : public aura::WindowObserver {
  public:
   explicit WindowObserver(RenderWidgetHostViewAura* view) : view_(view) {}
   virtual ~WindowObserver() {}
@@ skipping 90 matching lines @@
       has_composition_text_(false),
       device_scale_factor_(1.0f),
       current_surface_(0),
       current_surface_is_protected_(true),
       current_surface_in_use_by_compositor_(true),
       protection_state_id_(0),
       surface_route_id_(0),
       paint_canvas_(NULL),
       synthetic_move_sent_(false),
       accelerated_compositing_state_changed_(false),
-      can_lock_compositor_(YES),
-      pointer_activate_(false) {
+      can_lock_compositor_(YES) {
   host_->SetView(this);
   window_observer_.reset(new WindowObserver(this));
   window_->AddObserver(window_observer_.get());
   aura::client::SetTooltipText(window_, &tooltip_);
   aura::client::SetActivationDelegate(window_, this);
   gfx::Screen::GetScreenFor(window_)->AddObserver(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, RenderWidgetHostView implementation:
@@ skipping 1235 matching lines @@
     } else {
       NativeWebKeyboardEvent webkit_event(event);
       host_->ForwardKeyboardEvent(webkit_event);
     }
   }
   return ui::ER_HANDLED;
 }
 
 ui::EventResult RenderWidgetHostViewAura::OnMouseEvent(ui::MouseEvent* event) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAura::OnMouseEvent");
-  pointer_activate_ = event->type() == ui::ET_MOUSE_PRESSED;
 
   if (mouse_locked_) {
     // Hide the cursor if someone else has shown it.
     aura::client::CursorClient* cursor_client =
         aura::client::GetCursorClient(window_->GetRootWindow());
     if (cursor_client && cursor_client->IsCursorVisible())
       cursor_client->ShowCursor(false);
 
     WebKit::WebMouseEvent mouse_event = MakeWebMouseEvent(event);
     gfx::Point center(gfx::Rect(window_->bounds().size()).CenterPoint());
@@ skipping 122 matching lines @@
   if ((event->type() == ui::ET_GESTURE_PINCH_BEGIN ||
       event->type() == ui::ET_GESTURE_PINCH_UPDATE ||
       event->type() == ui::ET_GESTURE_PINCH_END) && !ShouldSendPinchGesture()) {
     return ui::ER_CONSUMED;
   }
 
   RenderViewHostDelegate* delegate = NULL;
   if (popup_type_ == WebKit::WebPopupTypeNone && !is_fullscreen_)
     delegate = RenderViewHost::From(host_)->GetDelegate();
 
-  bool gesture_begin = event->type() == ui::ET_GESTURE_BEGIN &&
-      event->details().touch_points() == 1;
-  if (delegate && gesture_begin)
+  if (delegate && event->type() == ui::ET_GESTURE_BEGIN &&
+      event->details().touch_points() == 1) {
     delegate->HandleGestureBegin();
-  pointer_activate_ = gesture_begin;
+  }
 
   WebKit::WebGestureEvent gesture = MakeWebGestureEvent(event);
   if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
     // Webkit does not stop a fling-scroll on tap-down. So explicitly send an
     // event to stop any in-progress flings.
     WebKit::WebGestureEvent fling_cancel = gesture;
     fling_cancel.type = WebKit::WebInputEvent::GestureFlingCancel;
     host_->ForwardGestureEvent(fling_cancel);
   }
 
@@ skipping 18 matching lines @@
   // (e.g. generates synthetic mouse events). So CONSUMED should be returned
   // from here to avoid any duplicate synthetic mouse-events being generated
   // from aura.
   return ui::ER_CONSUMED;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, aura::client::ActivationDelegate implementation:
 
 bool RenderWidgetHostViewAura::ShouldActivate() const {
+  const ui::Event* event = window_->GetRootWindow()->current_event();
+  if (!event)
+    return true;
   return is_fullscreen_;
 }
 
 void RenderWidgetHostViewAura::OnActivated() {
-  // |pointer_activate_| will be true when we are activated as the result of
-  // a valid input event.
-  // TODO(sadrul): It would be nice if we could get the currently processed
-  //               event from the RootWindow's EventDispatcher, then we could
-  //               avoid this extra field and just check the type/details on
-  //               the current event here.
-  if (pointer_activate_)
+  const ui::Event* event = window_->GetRootWindow()->current_event();
+  if (event && PointerEventActivates(*event))
     host_->OnPointerEventActivate();
 }
 
 void RenderWidgetHostViewAura::OnLostActive() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ui::CompositorObserver implementation:
 
 void RenderWidgetHostViewAura::OnCompositingDidCommit(
@@ skipping 247 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content