Removes the |event| parameter from ActivationDelegate::ShouldActivate and makes the method const.

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 267 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) {
+      can_lock_compositor_(YES),
+      pointer_activate_(false) {
   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 120 matching lines @@
   // Pinch gestures are currently disabled by default. See crbug.com/128477.
   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();
-  if (delegate && event->type() == ui::ET_GESTURE_BEGIN &&
-      event->details().touch_points() == 1) {
+
+  bool gesture_begin = event->type() == ui::ET_GESTURE_BEGIN &&
+      event->details().touch_points() == 1;
+  if (delegate && gesture_begin)
     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 17 matching lines @@
   // If a gesture is not processed by the webpage, then WebKit processes it
   // (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 ui::Event* event) {
-  bool activate = false;
-  if (event) {
-    if (event->type() == ui::ET_MOUSE_PRESSED) {
-      activate = true;
-    } else if (event->type() == ui::ET_GESTURE_BEGIN) {
-      activate = static_cast<const ui::GestureEvent*>(event)->
-          details().touch_points() == 1;
-    }
-  } else {
-    return true;
-  }
-  if (activate)
-    host_->OnPointerEventActivate();
+bool RenderWidgetHostViewAura::ShouldActivate() const {
   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_)
+    host_->OnPointerEventActivate();
 }
 
 void RenderWidgetHostViewAura::OnLostActive() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ui::CompositorObserver implementation:
 
 void RenderWidgetHostViewAura::OnCompositingDidCommit(
     ui::Compositor* compositor) {
@@ skipping 246 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content