exo: Implement v6 of touch protocol including shape and frame event

components/exo/touch.cc

 // Copyright 2015 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 "components/exo/touch.h"
 
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
 #include "components/exo/surface.h"
 #include "components/exo/touch_delegate.h"
 #include "components/exo/wm_helper.h"
 #include "ui/aura/window.h"
 #include "ui/events/event.h"
 
 namespace exo {
 namespace {
-
-// Helper function that returns an iterator to the first item in |vector|
-// with |value|.
-template <typename T, typename U>
-typename T::iterator FindVectorItem(T& vector, U value) {
-  return std::find(vector.begin(), vector.end(), value);
+template <typename T>
+static bool AlmostEqual(T x, T y) {

[reveman, 2016/12/07 03:16:18]

This would need some explaining and maybe a rename to TouchAxisAlmostEqual. But
first, do we really need this? Sending a Touch::OnTouchShape event for every
touch event would be so much easier and it doesn't seem like that would add any
significant overhead. Am I missing something here?

[denniskempin, 2016/12/07 18:32:18]

We don't really have to do this, but the protocol asks for those events to be
only sent when the shape is changing, much like mouse events are only sent when
the location is changing. 

We will have more fields here where we will apply the same pattern. Tilt and
force as well. So at that time we would be at up to 4 events (shape, tilt,
force, motion) for every update, so the overhead will be increasing. 

Either way, I think it would be fully functional with little overhead if we just
send those events for every update. I am just following the practice we were
using in the Pointer class. 

AlmostEqual is really just a generic function to compare to floating point
values for equality since you cannot compare them directly. So maybe
FloatAlmostEqual would be more fitting?

[reveman, 2016/12/07 22:58:00]

I don't think we'll break any clients by sending an event even if the shape
didn't change. If we really care to avoid this then I think we should add a new
touch shape event to chrome and track this at the evdev level instead of here. 
 
I suspect that this is still not going to add any significant overhead. We'll
send a few more bytes across the channel but we're not talking much data here.
Again, if we want to reduce processing overhead in regards to this then we
should probably do that at a lower level.
 
Keeping things simple for now is best I think and we can always micro optimize
this later if it turns out to be a problem.
Why not simply "abs(a - b) < epsilon" ?

[denniskempin, 2016/12/07 23:40:54]

sgtm. Let's go with always sending the update. It's significantly simpler. 

+  return std::abs(x - y) <=
+         std::numeric_limits<T>::epsilon() * std::max(std::abs(x), std::abs(y));
 }
-
-// Helper function that returns true if |vector| contains an item with |value|.
-template <typename T, typename U>
-bool VectorContainsItem(T& vector, U value) {
-  return FindVectorItem(vector, value) != vector.end();
 }
 
-}  // namespace
-
 ////////////////////////////////////////////////////////////////////////////////
 // Touch, public:
 
 Touch::Touch(TouchDelegate* delegate) : delegate_(delegate) {
   WMHelper::GetInstance()->AddPreTargetHandler(this);
 }
 
 Touch::~Touch() {
   delegate_->OnTouchDestroying(this);
   if (focus_)
     focus_->RemoveSurfaceObserver(this);
   WMHelper::GetInstance()->RemovePreTargetHandler(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ui::EventHandler overrides:
 
 void Touch::OnTouchEvent(ui::TouchEvent* event) {
+  auto touch_details_iter = FindTouch(event->touch_id());
+
   switch (event->type()) {
     case ui::ET_TOUCH_PRESSED: {
       // Early out if event doesn't contain a valid target for touch device.
       Surface* target = GetEffectiveTargetForEvent(event);
       if (!target)
         return;
 
       // If this is the first touch point then target becomes the focus surface
       // until all touch points have been released.
       if (touch_points_.empty()) {
         DCHECK(!focus_);
         focus_ = target;
         focus_->AddSurfaceObserver(this);
       }
 
-      DCHECK(!VectorContainsItem(touch_points_, event->touch_id()));
-      touch_points_.push_back(event->touch_id());
+      DCHECK(touch_details_iter == touch_points_.end());
+      touch_details_iter =
+          touch_points_.insert(touch_details_iter, {event->touch_id(), 0, 0});
 
       // Convert location to focus surface coordinate space.
       DCHECK(focus_);
       gfx::Point location = event->location();
       aura::Window::ConvertPointToTarget(target->window(), focus_->window(),
                                          &location);
 
       // Generate a touch down event for the focus surface. Note that this can
       // be different from the target surface.
       delegate_->OnTouchDown(focus_, event->time_stamp(), event->touch_id(),
                              location);
     } break;
     case ui::ET_TOUCH_RELEASED: {
-      auto it = FindVectorItem(touch_points_, event->touch_id());
-      if (it != touch_points_.end()) {
-        touch_points_.erase(it);
+      if (touch_details_iter != touch_points_.end()) {
+        touch_points_.erase(touch_details_iter);
+        touch_details_iter = touch_points_.end();
 
         // Reset focus surface if this is the last touch point.
         if (touch_points_.empty()) {
           DCHECK(focus_);
           focus_->RemoveSurfaceObserver(this);
           focus_ = nullptr;
         }
 
         delegate_->OnTouchUp(event->time_stamp(), event->touch_id());
       }
     } break;
     case ui::ET_TOUCH_MOVED: {
-      auto it = FindVectorItem(touch_points_, event->touch_id());
-      if (it != touch_points_.end()) {
+      if (touch_details_iter != touch_points_.end()) {
         DCHECK(focus_);
         // Convert location to focus surface coordinate space.
         gfx::Point location = event->location();
         aura::Window::ConvertPointToTarget(
             static_cast<aura::Window*>(event->target()), focus_->window(),
             &location);
 
         delegate_->OnTouchMotion(event->time_stamp(), event->touch_id(),
                                  location);
       }
     } break;
     case ui::ET_TOUCH_CANCELLED: {
-      auto it = FindVectorItem(touch_points_, event->touch_id());
-      if (it != touch_points_.end()) {
+      if (touch_details_iter != touch_points_.end()) {
         DCHECK(focus_);
         focus_->RemoveSurfaceObserver(this);
         focus_ = nullptr;
 
         // Cancel the full set of touch sequences as soon as one is canceled.
         touch_points_.clear();
+        touch_details_iter = touch_points_.end();
         delegate_->OnTouchCancel();
       }
     } break;
     default:
       NOTREACHED();
-      break;
+      return;
   }
+  if (touch_details_iter != touch_points_.end()) {
+    float major = event->pointer_details().radius_x;
+    float minor = event->pointer_details().radius_y;
+    if (!AlmostEqual(major, touch_details_iter->major) ||
+        !AlmostEqual(minor, touch_details_iter->minor)) {
+      touch_details_iter->major = major;
+      touch_details_iter->minor = minor;
+      delegate_->OnTouchShape(event->touch_id(), major, minor);
+    }
+  }
+  // todo(denniskempin): Extend ui::TouchEvent to signal end of sequence of
+  // touch events to send TouchFrame once after all touches have been updated.
+  delegate_->OnTouchFrame();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SurfaceObserver overrides:
 
 void Touch::OnSurfaceDestroying(Surface* surface) {
   DCHECK(surface == focus_);
   focus_ = nullptr;
   surface->RemoveSurfaceObserver(this);
 
   // Cancel touch sequences.
   DCHECK_NE(touch_points_.size(), 0u);
   touch_points_.clear();
   delegate_->OnTouchCancel();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Touch, private:
 
 Surface* Touch::GetEffectiveTargetForEvent(ui::Event* event) const {
   Surface* target =
       Surface::AsSurface(static_cast<aura::Window*>(event->target()));
   if (!target)
     return nullptr;
 
   return delegate_->CanAcceptTouchEventsForSurface(target) ? target : nullptr;
 }
 
+std::vector<Touch::TouchDetails>::iterator Touch::FindTouch(int id) {
+  return std::find_if(touch_points_.begin(), touch_points_.end(),
+                      [id](TouchDetails touch) { return touch.id == id; });
+}
+
 }  // namespace exo