Set the correct pressure for pointer events based on force

ui/events/test/event_generator.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/test/event_generator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 352 matching lines @@
 }
 
 void EventGenerator::GestureScrollSequenceWithCallback(
     const gfx::Point& start,
     const gfx::Point& end,
     const base::TimeDelta& step_delay,
     int steps,
     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());
 
   float dx = static_cast<float>(end.x() - start.x()) / steps;
   float dy = static_cast<float>(end.y() - start.y()) / steps;
   gfx::PointF location(start);
   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());
 }
 
 void EventGenerator::GestureMultiFingerScroll(int count,
                                               const gfx::Point start[],
                                               int event_separation_time_ms,
                                               int steps,
                                               int move_x,
                                               int move_y) {
@@ skipping 306 matching lines @@
   return default_delegate;
 }
 
 EventGeneratorDelegate* EventGenerator::delegate() {
   return const_cast<EventGeneratorDelegate*>(
       const_cast<const EventGenerator*>(this)->delegate());
 }
 
 }  // namespace test
 }  // namespace ui