components/html_viewer/touch_handler.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/html_viewer/touch_handler.h"
   6
   7 #include "third_party/WebKit/public/web/WebInputEvent.h"
   8 #include "third_party/WebKit/public/web/WebView.h"
   9 #include "ui/events/base_event_utils.h"
  10 #include "ui/events/blink/blink_event_util.h"
  11 #include "ui/events/gesture_detection/gesture_provider_config_helper.h"
  12 #include "ui/events/gesture_detection/motion_event_generic.h"
  13 #include "ui/mojo/events/input_events.mojom.h"
  14
  15 namespace html_viewer {
  16 namespace {
  17
  18 void SetPropertiesFromEvent(const mojo::Event& event,
  19                             ui::PointerProperties* properties) {
  20   properties->id = event.pointer_data->pointer_id;
  21   properties->x = event.pointer_data->x;
  22   properties->y = event.pointer_data->y;
  23   properties->raw_x = event.pointer_data->screen_x;
  24   properties->raw_y = event.pointer_data->screen_y;
  25   properties->pressure = event.pointer_data->pressure;
  26   properties->touch_major = event.pointer_data->radius_major;
  27   properties->touch_minor = event.pointer_data->radius_minor;
  28   properties->orientation = event.pointer_data->orientation;
  29   // TODO(sky): Add support for tool_type.
  30 }
  31
  32 }  // namespace
  33
  34 TouchHandler::TouchHandler(blink::WebView* web_view)
  35     : web_view_(web_view),
  36       gesture_provider_(ui::GetGestureProviderConfig(
  37                             ui::GestureProviderConfigType::CURRENT_PLATFORM),
  38                         this) {
  39 }
  40
  41 TouchHandler::~TouchHandler() {
  42 }
  43
  44 void TouchHandler::OnTouchEvent(const mojo::Event& event) {
  45   if (!UpdateMotionEvent(event))
  46     return;
  47
  48   SendMotionEventToGestureProvider();
  49
  50   PostProcessMotionEvent(event);
  51 }
  52
  53 void TouchHandler::OnGestureEvent(const ui::GestureEventData& gesture) {
  54   blink::WebGestureEvent web_gesture =
  55       CreateWebGestureEventFromGestureEventData(gesture);
  56   // TODO(jdduke): Remove this workaround after Android fixes UiAutomator to
  57   // stop providing shift meta values to synthetic MotionEvents. This prevents
  58   // unintended shift+click interpretation of all accessibility clicks.
  59   // See crbug.com/443247.
  60   if (web_gesture.type == blink::WebInputEvent::GestureTap &&
  61       web_gesture.modifiers == blink::WebInputEvent::ShiftKey) {
  62     web_gesture.modifiers = 0;
  63   }
  64   web_view_->handleInputEvent(web_gesture);
  65 }
  66
  67 bool TouchHandler::UpdateMotionEvent(const mojo::Event& event) {
  68   ui::PointerProperties properties;
  69   SetPropertiesFromEvent(event, &properties);
  70
  71   const base::TimeTicks timestamp(
  72       base::TimeTicks::FromInternalValue(event.time_stamp));
  73   if (current_motion_event_.get()) {
  74     current_motion_event_->set_unique_event_id(ui::GetNextTouchEventId());
  75     current_motion_event_->set_event_time(timestamp);
  76   }
  77
  78   switch (event.action) {
  79     case mojo::EVENT_TYPE_POINTER_DOWN:
  80       if (!current_motion_event_.get()) {
  81         current_motion_event_.reset(new ui::MotionEventGeneric(
  82             ui::MotionEvent::ACTION_DOWN, timestamp, properties));
  83       } else {
  84         const int index =
  85             current_motion_event_->FindPointerIndexOfId(properties.id);
  86         if (index != -1) {
  87           DVLOG(1) << "pointer down and pointer already down id="
  88                    << properties.id;
  89           return false;
  90         }
  91         current_motion_event_->PushPointer(properties);
  92         current_motion_event_->set_action(ui::MotionEvent::ACTION_POINTER_DOWN);
  93         current_motion_event_->set_action_index(static_cast<int>(index));
  94       }
  95       return true;
  96
  97     case mojo::EVENT_TYPE_POINTER_UP: {
  98       if (!current_motion_event_.get()) {
  99         DVLOG(1) << "pointer up with no event, id=" << properties.id;
 100         return false;
 101       }
 102       const int index =
 103           current_motion_event_->FindPointerIndexOfId(properties.id);
 104       if (index == -1) {
 105         DVLOG(1) << "pointer up and pointer not down id=" << properties.id;
 106         return false;
 107       }
 108       current_motion_event_->pointer(index) = properties;
 109       current_motion_event_->set_action(
 110           current_motion_event_->GetPointerCount() == 1
 111               ? ui::MotionEvent::ACTION_UP
 112               : ui::MotionEvent::ACTION_POINTER_UP);
 113       current_motion_event_->set_action_index(static_cast<int>(index));
 114       return true;
 115     }
 116
 117     case mojo::EVENT_TYPE_POINTER_MOVE: {
 118       if (!current_motion_event_.get()) {
 119         DVLOG(1) << "pointer move with no event, id=" << properties.id;
 120         return false;
 121       }
 122       const int index =
 123           current_motion_event_->FindPointerIndexOfId(properties.id);
 124       if (index == -1) {
 125         DVLOG(1) << "pointer move and pointer not down id=" << properties.id;
 126         return false;
 127       }
 128       current_motion_event_->pointer(index) = properties;
 129       current_motion_event_->set_action(ui::MotionEvent::ACTION_MOVE);
 130       current_motion_event_->set_action_index(static_cast<int>(index));
 131       return true;
 132     }
 133
 134     case mojo::EVENT_TYPE_POINTER_CANCEL: {
 135       if (!current_motion_event_.get()) {
 136         DVLOG(1) << "canel with no event, id=" << properties.id;
 137         return false;
 138       }
 139       const int index =
 140           current_motion_event_->FindPointerIndexOfId(properties.id);
 141       if (index == -1) {
 142         DVLOG(1) << "cancel and pointer not down id=" << properties.id;
 143         return false;
 144       }
 145       current_motion_event_->pointer(index) = properties;
 146       current_motion_event_->set_action(ui::MotionEvent::ACTION_CANCEL);
 147       current_motion_event_->set_action_index(0);
 148       return true;
 149     }
 150
 151     default:
 152       NOTREACHED();
 153   }
 154   return false;
 155 }
 156
 157 void TouchHandler::SendMotionEventToGestureProvider() {
 158   ui::FilteredGestureProvider::TouchHandlingResult result =
 159       gesture_provider_.OnTouchEvent(*current_motion_event_);
 160   if (!result.succeeded)
 161     return;
 162
 163   blink::WebTouchEvent web_event = ui::CreateWebTouchEventFromMotionEvent(
 164       *current_motion_event_, result.did_generate_scroll);
 165   gesture_provider_.OnTouchEventAck(web_event.uniqueTouchEventId,
 166                                     web_view_->handleInputEvent(web_event));
 167 }
 168
 169 void TouchHandler::PostProcessMotionEvent(const mojo::Event& event) {
 170   switch (event.action) {
 171     case mojo::EVENT_TYPE_POINTER_UP: {
 172       const int index = current_motion_event_->FindPointerIndexOfId(
 173           event.pointer_data->pointer_id);
 174       current_motion_event_->RemovePointerAt(index);
 175       if (current_motion_event_->GetPointerCount() == 0)
 176         current_motion_event_.reset();
 177       break;
 178     }
 179
 180     case mojo::EVENT_TYPE_POINTER_CANCEL:
 181       current_motion_event_.reset();
 182       break;
 183
 184     default:
 185       break;
 186   }
 187 }
 188
 189 }  // namespace html_viewer