exo: Replace pointer based stylus and replace with touch based stylus

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 "components/exo/surface.h"
 #include "components/exo/touch_delegate.h"
+#include "components/exo/touch_stylus_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>
@@ skipping 16 matching lines @@
   WMHelper::GetInstance()->AddPreTargetHandler(this);
 }
 
 Touch::~Touch() {
   delegate_->OnTouchDestroying(this);
   if (focus_)
     focus_->RemoveSurfaceObserver(this);
   WMHelper::GetInstance()->RemovePreTargetHandler(this);
 }
 
+void Touch::SetStylusDelegate(TouchStylusDelegate* delegate) {
+  stylus_delegate_ = delegate;
+}
+
+bool Touch::HasStylusDelegate() const {
+  return !!stylus_delegate_;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ui::EventHandler overrides:
 
 void Touch::OnTouchEvent(ui::TouchEvent* event) {
   bool send_details = false;
 
   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);
@@ skipping 14 matching lines @@
       // 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);
+      if (stylus_delegate_ &&
+          event->pointer_details().pointer_type !=
+              ui::EventPointerType::POINTER_TYPE_TOUCH) {
+        stylus_delegate_->OnTouchTool(event->touch_id(),
+                                      event->pointer_details().pointer_type);
+      }
       send_details = true;
     } break;
     case ui::ET_TOUCH_RELEASED: {
       auto it = FindVectorItem(touch_points_, event->touch_id());
       if (it == touch_points_.end())
         return;
       touch_points_.erase(it);
 
       // Reset focus surface if this is the last touch point.
       if (touch_points_.empty()) {
@@ skipping 34 matching lines @@
       delegate_->OnTouchCancel();
     } break;
     default:
       NOTREACHED();
       return;
   }
   if (send_details) {
     delegate_->OnTouchShape(event->touch_id(),
                             event->pointer_details().radius_x,
                             event->pointer_details().radius_y);
+
+    if (stylus_delegate_ &&
+        event->pointer_details().pointer_type !=
+            ui::EventPointerType::POINTER_TYPE_TOUCH) {
+      if (!std::isnan(event->pointer_details().force)) {
+        stylus_delegate_->OnTouchForce(event->time_stamp(), event->touch_id(),
+                                       event->pointer_details().force);
+      }
+      stylus_delegate_->OnTouchTilt(
+          event->time_stamp(), event->touch_id(),
+          gfx::Vector2dF(event->pointer_details().tilt_x,
+                         event->pointer_details().tilt_y));
+    }
   }
   // 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) {
@@ skipping 13 matching lines @@
 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;
 }
 
 }  // namespace exo