ozone: evdev: Fix TouchEvent radius

ui/events/ozone/evdev/touch_event_converter_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/touch_event_converter_evdev.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/input.h>
 #include <poll.h>
@@ skipping 12 matching lines @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_switches.h"
 #include "ui/gfx/screen.h"
 
 namespace {
 
-// Number is determined empirically.
-// TODO(rjkroege): Configure this per device.
-const float kFingerWidth = 25.f;
-
 struct TouchCalibration {
   int bezel_left;
   int bezel_right;
   int bezel_top;
   int bezel_bottom;
 };
 
 void GetTouchCalibration(TouchCalibration* cal) {
   std::vector<std::string> parts;
   if (Tokenize(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
@@ skipping 14 matching lines @@
 float TuxelsToPixels(float val,
                      float min_tuxels,
                      float num_tuxels,
                      float min_pixels,
                      float num_pixels) {
   // Map [min_tuxels, min_tuxels + num_tuxels) to
   //     [min_pixels, min_pixels + num_pixels).
   return min_pixels + (val - min_tuxels) * num_pixels / num_tuxels;
 }
 
+float TuxelToPizelSize(float val, float num_tuxels, float num_pixels) {

[alexst (slow to review), 2014/08/26 23:51:26]

Pizel Size -> Pizza Size? Pixel Size? :)

+  return val * num_pixels / num_tuxels;
+}
+
 }  // namespace
 
 namespace ui {
 
 TouchEventConverterEvdev::TouchEventConverterEvdev(
     int fd,
     base::FilePath path,
     const EventDeviceInfo& info,
     const EventDispatchCallback& callback)
     : EventConverterEvdev(callback),
@@ skipping 113 matching lines @@
     }
   } else {
     NOTIMPLEMENTED() << "invalid type: " << input.type;
   }
 }
 
 void TouchEventConverterEvdev::ProcessAbs(const input_event& input) {
   switch (input.code) {
     case ABS_MT_TOUCH_MAJOR:
       altered_slots_.set(current_slot_);
-      events_[current_slot_].major_ = input.value;
+      // TODO(spang): If we have all of major, minor, and orientation,
+      // we can scale the ellipse correctly. However on the Pixel we get
+      // neither minor nor orientation, so this is all we can do.
+      events_[current_slot_].radius_x_ =
+          TuxelToPizelSize(input.value, x_num_tuxels_, x_num_pixels_) / 2.0f;
+      break;
+    case ABS_MT_TOUCH_MINOR:
+      altered_slots_.set(current_slot_);
+      events_[current_slot_].radius_y_ =
+          TuxelToPizelSize(input.value, y_num_tuxels_, y_num_pixels_) / 2.0f;
       break;
     case ABS_MT_POSITION_X:
       altered_slots_.set(current_slot_);
       events_[current_slot_].x_ = TuxelsToPixels(input.value,
                                                  x_min_tuxels_,
                                                  x_num_tuxels_,
                                                  x_min_pixels_,
                                                  x_num_pixels_);
       break;
     case ABS_MT_POSITION_Y:
@@ skipping 64 matching lines @@
 
 void TouchEventConverterEvdev::ReportEvents(base::TimeDelta delta) {
   for (int i = 0; i < MAX_FINGERS; i++) {
     if (altered_slots_[i]) {
       // TODO(rikroege): Support elliptical finger regions.
       TouchEvent evt(events_[i].type_,
                      gfx::PointF(events_[i].x_, events_[i].y_),
                      /* flags */ 0,
                      /* touch_id */ events_[i].finger_,
                      delta,
-                     events_[i].pressure_ * kFingerWidth,
-                     events_[i].pressure_ * kFingerWidth,
+                     /* radius_x */ events_[i].radius_x_,
+                     /* radius_y */ events_[i].radius_y_,
                      /* angle */ 0.,
                      events_[i].pressure_);
       DispatchEventToCallback(&evt);
 
       // Subsequent events for this finger will be touch-move until it
       // is released.
       events_[i].type_ = ET_TOUCH_MOVED;
     }
   }
   altered_slots_.reset();
 }
 
 }  // namespace ui