Touch emulator: create/destroy gesture provider on the fly.

content/browser/renderer_host/input/touch_emulator.cc

 // Copyright 2014 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/input/touch_emulator.h"
 
 #include "content/browser/renderer_host/input/motion_event_web.h"
 #include "content/browser/renderer_host/input/web_input_event_util.h"
 #include "content/common/input/web_touch_event_traits.h"
 #include "content/grit/content_resources.h"
@@ skipping 28 matching lines @@
 }
 
 // Time between two consecutive mouse moves, during which second mouse move
 // is not converted to touch.
 const double kMouseMoveDropIntervalSeconds = 5.f / 1000;
 
 } // namespace
 
 TouchEmulator::TouchEmulator(TouchEmulatorClient* client)
     : client_(client),
-      gesture_provider_(GetGestureProviderConfig(), this),
-      enabled_(false),
       emulated_stream_active_sequence_count_(0),
       native_stream_active_sequence_count_(0) {
   DCHECK(client_);
   ResetState();
 
   bool use_2x = gfx::Screen::GetNativeScreen()->
       GetPrimaryDisplay().device_scale_factor() > 1.5f;
   float cursor_scale_factor = use_2x ? 2.f : 1.f;
   cursor_size_ = InitCursorFromResource(&touch_cursor_,
       cursor_scale_factor,
       use_2x ? IDR_DEVTOOLS_TOUCH_CURSOR_ICON_2X :
           IDR_DEVTOOLS_TOUCH_CURSOR_ICON);
   InitCursorFromResource(&pinch_cursor_,
       cursor_scale_factor,
       use_2x ? IDR_DEVTOOLS_PINCH_CURSOR_ICON_2X :
           IDR_DEVTOOLS_PINCH_CURSOR_ICON);
 
   WebCursor::CursorInfo cursor_info;
   cursor_info.type = blink::WebCursorInfo::TypePointer;
   pointer_cursor_.InitFromCursorInfo(cursor_info);
-
-  // TODO(dgozman): Use synthetic secondary touch to support multi-touch.
-  gesture_provider_.SetMultiTouchZoomSupportEnabled(false);
-  // TODO(dgozman): Enable double tap if requested by the renderer.
-  // TODO(dgozman): Don't break double-tap-based pinch with shift handling.
-  gesture_provider_.SetDoubleTapSupportForPlatformEnabled(false);
 }
 
 TouchEmulator::~TouchEmulator() {
   // We cannot cleanup properly in destructor, as we need roundtrip to the
   // renderer for ack. Instead, the owner should call Disable, and only
   // destroy this object when renderer is dead.
 }
 
 void TouchEmulator::ResetState() {
   last_mouse_event_was_move_ = false;
   last_mouse_move_timestamp_ = 0;
   mouse_pressed_ = false;
   shift_pressed_ = false;
   suppress_next_fling_cancel_ = false;
   pinch_scale_ = 1.f;
   pinch_gesture_active_ = false;
 }
 
 void TouchEmulator::Enable() {
-  if (!enabled_) {
-    enabled_ = true;
+  if (!gesture_provider_) {
+    gesture_provider_.reset(new ui::FilteredGestureProvider(
+        GetGestureProviderConfig(), this));
+    // TODO(dgozman): Use synthetic secondary touch to support multi-touch.
+    gesture_provider_->SetMultiTouchZoomSupportEnabled(false);
+    // TODO(dgozman): Enable double tap if requested by the renderer.
+    // TODO(dgozman): Don't break double-tap-based pinch with shift handling.
+    gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
+
     ResetState();
   }
   UpdateCursor();
 }
 
 void TouchEmulator::Disable() {
-  if (!enabled_)
+  if (!gesture_provider_)

[jdduke (slow), 2014/12/30 16:37:19]

In these early returns, would it make sense to use the |enabled()| query
instead?

[dgozman, 2015/01/14 14:14:27]

Great idea! Done.

     return;
 
-  enabled_ = false;
   UpdateCursor();
   CancelTouch();
+  gesture_provider_.reset();
 }
 
 gfx::SizeF TouchEmulator::InitCursorFromResource(
     WebCursor* cursor, float scale, int resource_id) {
   gfx::Image& cursor_image =
       content::GetContentClient()->GetNativeImageNamed(resource_id);
   WebCursor::CursorInfo cursor_info;
   cursor_info.type = blink::WebCursorInfo::TypeCustom;
   cursor_info.image_scale_factor = scale;
   cursor_info.custom_image = cursor_image.AsBitmap();
   cursor_info.hotspot =
       gfx::Point(cursor_image.Width() / 2, cursor_image.Height() / 2);
 #if defined(OS_WIN)
   cursor_info.external_handle = 0;
 #endif
 
   cursor->InitFromCursorInfo(cursor_info);
   return gfx::ScaleSize(cursor_image.Size(), 1.f / scale);
 }
 
 bool TouchEmulator::HandleMouseEvent(const WebMouseEvent& mouse_event) {
-  if (!enabled_)
+  if (!gesture_provider_)
     return false;
 
   if (mouse_event.button == WebMouseEvent::ButtonRight &&
       mouse_event.type == WebInputEvent::MouseDown) {
     client_->ShowContextMenuAtPoint(gfx::Point(mouse_event.x, mouse_event.y));
   }
 
   if (mouse_event.button != WebMouseEvent::ButtonLeft)
     return true;
 
@@ skipping 23 matching lines @@
   }
 
   FillTouchEventAndPoint(mouse_event);
   HandleEmulatedTouchEvent(touch_event_);
 
   // Do not pass mouse events to the renderer.
   return true;
 }
 
 bool TouchEmulator::HandleMouseWheelEvent(const WebMouseWheelEvent& event) {
-  if (!enabled_)
+  if (!gesture_provider_)
     return false;
 
   // Send mouse wheel for easy scrolling when there is no active touch.
   return emulated_stream_active_sequence_count_ > 0;
 }
 
 bool TouchEmulator::HandleKeyboardEvent(const WebKeyboardEvent& event) {
-  if (!enabled_)
+  if (!gesture_provider_)
     return false;
 
   if (!UpdateShiftPressed((event.modifiers & WebInputEvent::ShiftKey) != 0))
     return false;
 
   if (!mouse_pressed_)
     return false;
 
   // Note: The necessary pinch events will be lazily inserted by
   // |OnGestureEvent| depending on the state of |shift_pressed_|, using the
@@ skipping 17 matching lines @@
   // Do not allow middle-sequence event to pass through, if start was blocked.
   if (!native_stream_active_sequence_count_ && !is_sequence_start)
     return true;
 
   if (is_sequence_start)
     native_stream_active_sequence_count_++;
   return false;
 }
 
 void TouchEmulator::HandleEmulatedTouchEvent(blink::WebTouchEvent event) {
-  auto result = gesture_provider_.OnTouchEvent(MotionEventWeb(event));
+  DCHECK(gesture_provider_.get());

[jdduke (slow), 2014/12/30 16:37:19]

Do you need the ".get()" (also below)?

[dgozman, 2015/01/14 14:14:27]

Removed.

+  auto result = gesture_provider_->OnTouchEvent(MotionEventWeb(event));
   if (!result.succeeded)
     return;
 
   const bool event_consumed = true;
   // Block emulated event when emulated native stream is active.
   if (native_stream_active_sequence_count_) {
-    gesture_provider_.OnSyncTouchEventAck(event_consumed);
+    gesture_provider_->OnSyncTouchEventAck(event_consumed);
     return;
   }
 
   bool is_sequence_start = WebTouchEventTraits::IsTouchSequenceStart(event);
   // Do not allow middle-sequence event to pass through, if start was blocked.
   if (!emulated_stream_active_sequence_count_ && !is_sequence_start) {
-    gesture_provider_.OnSyncTouchEventAck(event_consumed);
+    gesture_provider_->OnSyncTouchEventAck(event_consumed);
     return;
   }
 
   if (is_sequence_start)
     emulated_stream_active_sequence_count_++;
 
   event.causesScrollingIfUncanceled = result.did_generate_scroll;
   client_->ForwardEmulatedTouchEvent(event);
 }
 
 bool TouchEmulator::HandleTouchEventAck(
     const blink::WebTouchEvent& event, InputEventAckState ack_result) {
   bool is_sequence_end = WebTouchEventTraits::IsTouchSequenceEnd(event);
   if (emulated_stream_active_sequence_count_) {
     if (is_sequence_end)
       emulated_stream_active_sequence_count_--;
 
     const bool event_consumed = ack_result == INPUT_EVENT_ACK_STATE_CONSUMED;
-    gesture_provider_.OnAsyncTouchEventAck(event_consumed);
+    if (gesture_provider_)
+      gesture_provider_->OnAsyncTouchEventAck(event_consumed);
     return true;
   }
 
   // We may have not seen native touch sequence start (when created in the
   // middle of a sequence), so don't decrement sequence count below zero.
   if (is_sequence_end && native_stream_active_sequence_count_)
     native_stream_active_sequence_count_--;
   return false;
 }
 
@@ skipping 64 matching lines @@
 }
 
 void TouchEmulator::CancelTouch() {
   if (!emulated_stream_active_sequence_count_)
     return;
 
   WebTouchEventTraits::ResetTypeAndTouchStates(
       WebInputEvent::TouchCancel,
       (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF(),
       &touch_event_);
-  if (gesture_provider_.GetCurrentDownEvent())
+  DCHECK(gesture_provider_.get());
+  if (gesture_provider_->GetCurrentDownEvent())
     HandleEmulatedTouchEvent(touch_event_);
 }
 
 void TouchEmulator::UpdateCursor() {
-  if (!enabled_)
+  if (!gesture_provider_)
     client_->SetCursor(pointer_cursor_);
   else
     client_->SetCursor(InPinchGestureMode() ? pinch_cursor_ : touch_cursor_);
 }
 
 bool TouchEmulator::UpdateShiftPressed(bool shift_pressed) {
   if (shift_pressed_ == shift_pressed)
     return false;
   shift_pressed_ = shift_pressed;
   UpdateCursor();
@@ skipping 78 matching lines @@
   point.screenPosition.x = mouse_event.globalX;
   point.position.y = mouse_event.y;
   point.screenPosition.y = mouse_event.globalY;
 }
 
 bool TouchEmulator::InPinchGestureMode() const {
   return shift_pressed_;
 }
 
 }  // namespace content