Set the correct pressure for pointer events based on force

ui/events/test/event_generator.cc

Index: ui/events/test/event_generator.cc
diff --git a/ui/events/test/event_generator.cc b/ui/events/test/event_generator.cc
index 37e0a9bd8551695d2402e1b50cb892f4dadb8d48..425088e9cb80d9bf4e3efa3314b43bbf8c49db01 100644
--- a/ui/events/test/event_generator.cc
+++ b/ui/events/test/event_generator.cc
@@ -370,7 +370,8 @@ void EventGenerator::GestureScrollSequenceWithCallback(
     const ScrollStepCallback& callback) {
   const int kTouchId = 5;
   base::TimeDelta timestamp = Now();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, start, kTouchId, timestamp);
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, start, 0, kTouchId,
+                       timestamp, 5.0f, 5.0f, 0.0f, 1.0f);
   Dispatch(&press);
 
   callback.Run(ui::ET_GESTURE_SCROLL_BEGIN, gfx::Vector2dF());
@@ -381,14 +382,16 @@ void EventGenerator::GestureScrollSequenceWithCallback(
   for (int i = 0; i < steps; ++i) {
     location.Offset(dx, dy);
     timestamp += step_delay;
-    ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(), kTouchId, timestamp);
+    ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(), 0, kTouchId,
+                        timestamp, 5.0f, 5.0f, 0.0f, 1.0f);
     move.set_location_f(location);
     move.set_root_location_f(location);
     Dispatch(&move);
     callback.Run(ui::ET_GESTURE_SCROLL_UPDATE, gfx::Vector2dF(dx, dy));
   }
 
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, end, kTouchId, timestamp);
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, end, 0, kTouchId,
+                         timestamp, 5.0f, 5.0f, 0.0f, 1.0f);
   Dispatch(&release);

[sadrul, 2016/01/29 16:30:43]

Can you explain why this change was necessary?

[Navid Zolghadr, 2016/02/01 15:41:33]

Without this it was failing in one of the ASSERTs.

[sadrul, 2016/02/01 16:07:08]

Which one?

[Navid Zolghadr, 2016/02/01 16:21:30]

The test was this one WebContentsViewAuraTest.RepeatedQuickOverscrollGestures 
and the ASSERT that was failing is the one that is added in this same CL in
PlatformTouchPoint.h file.

[sadrul, 2016/02/01 16:46:40]

Interesting. Should PlatformTouchPointBuilder take care of that (like
PointerEventManager.cpp does in this CL)?

For example, what happens if a touchscreen device does not report the pressure?
Do we make sure (somewhere else in the browser-side) that we do not send nan for
touch-events to the renderer?

[Navid Zolghadr, 2016/02/01 16:53:14]

Not sure how you like PlatformTouchPointBuilder takes care of that. Do you mean
when it is NAN just sets it to 0? As far as I followed we always set the
pressure for touch events as we set the default value in the API call to 0. But
ideally when we there is a touch screen with no pressure support we should
somehow pass that value down to Blink and Blink removes this ASSERT. However, I
suspect in that time we need to change a few other places in Blink as well as in
some places that Blink uses pressure for touch events it doesn't check for NAN
and this last point was the main reason for adding this ASSERT in this CL to
catch anything that goes wrong at this stage in debug builds but eventually I
believe the NAN value of touch events should be passed to Blink as well.

[sadrul, 2016/02/01 17:06:34]

I was thinking 0.5? Or is that not the default pressure to use for touch-events?
I think the handling of the special value (NAN in this case) should happen in
one place. I think if it happens during Web*Event/Point -> Platform*Event/Point
conversion, that would be best, since that means none of the other parts of the
system needs to know about this NAN -> 0.5 conversion (and I believe you can
remove the changes in PointerEventManager too, since the Platform*Event will
already have the correct value). But if the default value for pressure for
TouchEvent is not the same as for PlatformEvent, then that wouldn't work, of
course, and what you have here is fine in that case.

[Navid Zolghadr, 2016/02/01 17:54:48]

I believe Mustaq can give a better answer here but as far as I know this
NAN->0.5 is related to pointer event spec only and we need this conversion for
whenever we want to send the pointer event equivalent of the events. So I
believe having this as pointer event specific change in PointerEventManager is
fine with you. Right?

 
   callback.Run(ui::ET_GESTURE_SCROLL_END, gfx::Vector2dF());