[PATCH 1/11] ozone: evdev: Move touch ui::Event transformation to EventFactoryEvdev

ui/events/ozone/evdev/event_factory_evdev.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 "ui/events/ozone/evdev/event_factory_evdev.h"
 
 #include <fcntl.h>
 #include <linux/input.h>
 
+#include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "base/task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
+#include "base/time/time.h"
 #include "ui/events/devices/device_data_manager.h"
 #include "ui/events/devices/device_util_linux.h"
 #include "ui/events/devices/input_device.h"
 #include "ui/events/ozone/device/device_event.h"
 #include "ui/events/ozone/device/device_manager.h"
 #include "ui/events/ozone/evdev/cursor_delegate_evdev.h"
 #include "ui/events/ozone/evdev/event_converter_evdev_impl.h"
 #include "ui/events/ozone/evdev/input_injector_evdev.h"
 #include "ui/events/ozone/evdev/tablet_event_converter_evdev.h"
 #include "ui/events/ozone/evdev/touch_event_converter_evdev.h"
@@ skipping 17 matching lines @@
 
 struct OpenInputDeviceParams {
   // Unique identifier for the new device.
   int id;
 
   // Device path to open.
   base::FilePath path;
 
   // Callback for dispatching events. Call on UI thread only.
   EventDispatchCallback dispatch_callback;
+  TouchEventDispatchCallback touch_callback;
 
   // State shared between devices. Must not be dereferenced on worker thread.
   EventModifiersEvdev* modifiers;
   MouseButtonMapEvdev* button_map;
   KeyboardEvdev* keyboard;
   CursorDelegateEvdev* cursor;
 #if defined(USE_EVDEV_GESTURES)
   GesturePropertyProvider* gesture_property_provider;
 #endif
 };
@@ skipping 25 matching lines @@
             params.keyboard, params.gesture_property_provider,
             params.dispatch_callback));
     return make_scoped_ptr(new EventReaderLibevdevCros(
         fd, params.path, params.id, type, devinfo, gesture_interp.Pass()));
   }
 #endif
 
   // Touchscreen: use TouchEventConverterEvdev.
   if (devinfo.HasMTAbsXY()) {
     scoped_ptr<TouchEventConverterEvdev> converter(new TouchEventConverterEvdev(
-        fd, params.path, params.id, type, params.dispatch_callback));
+        fd, params.path, params.id, type, params.touch_callback));
     converter->Initialize(devinfo);
     return converter.Pass();
   }
 
   // Graphics tablet
   if (devinfo.HasAbsXY())
     return make_scoped_ptr<EventConverterEvdev>(new TabletEventConverterEvdev(
         fd, params.path, params.id, type, params.modifiers, params.cursor,
         devinfo, params.dispatch_callback));
 
@@ skipping 82 matching lines @@
   DCHECK(device_manager_);
 }
 
 EventFactoryEvdev::~EventFactoryEvdev() { STLDeleteValues(&converters_); }
 
 scoped_ptr<SystemInputInjector> EventFactoryEvdev::CreateSystemInputInjector() {
   return make_scoped_ptr(new InputInjectorEvdev(
       &modifiers_, cursor_, &keyboard_, dispatch_callback_));
 }
 
+void EventFactoryEvdev::PostTouchEvent(const TouchEventParams& params) {
+  float x = params.location.x();
+  float y = params.location.y();
+  double radius_x = params.radii.x();
+  double radius_y = params.radii.y();
+
+  // Transform the event to align touches to the image based on display mode.
+  DeviceDataManager::GetInstance()->ApplyTouchTransformer(params.device_id, &x,
+                                                          &y);
+  DeviceDataManager::GetInstance()->ApplyTouchRadiusScale(params.device_id,
+                                                          &radius_x);
+  DeviceDataManager::GetInstance()->ApplyTouchRadiusScale(params.device_id,
+                                                          &radius_y);
+
+  scoped_ptr<TouchEvent> touch_event(new TouchEvent(
+      params.type, gfx::PointF(x, y),
+      /* flags */ 0, params.touch_id, params.timestamp, radius_x, radius_y,
+      /* angle */ 0., params.pressure));
+  touch_event->set_source_device_id(params.device_id);
+  PostUiEvent(touch_event.Pass());
+}
+
 void EventFactoryEvdev::PostUiEvent(scoped_ptr<Event> event) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&EventFactoryEvdev::DispatchUiEventTask,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&event)));
 }
 
 void EventFactoryEvdev::DispatchUiEventTask(scoped_ptr<Event> event) {
   DispatchEvent(event.get());
@@ skipping 28 matching lines @@
       TRACE_EVENT1("ozone", "OnDeviceAdded", "path", event.path().value());
 
       scoped_ptr<OpenInputDeviceParams> params(new OpenInputDeviceParams);
       params->id = NextDeviceId();
       params->path = event.path();
       params->dispatch_callback = dispatch_callback_;
       params->modifiers = &modifiers_;
       params->button_map = &button_map_;
       params->keyboard = &keyboard_;
       params->cursor = cursor_;
+
+      params->touch_callback = base::Bind(&EventFactoryEvdev::PostTouchEvent,
+                                          weak_ptr_factory_.GetWeakPtr());
+
 #if defined(USE_EVDEV_GESTURES)
       params->gesture_property_provider = gesture_property_provider_.get();
 #endif
 
       OpenInputDeviceReplyCallback reply_callback =
           base::Bind(&EventFactoryEvdev::AttachInputDevice,
                      weak_ptr_factory_.GetWeakPtr());
 
       // Dispatch task to open from the worker pool, since open may block.
       base::WorkerPool::PostTask(FROM_HERE,
@@ skipping 153 matching lines @@
   gesture_property_provider_->GetDeviceIdsByType(type, &ids);
 #endif
   // In the future we can add other device matching logics here.
 
   if (device_ids)
     device_ids->assign(ids.begin(), ids.end());
   return !ids.empty();
 }
 
 }  // namespace ui