Handle floating point coordinates from ozone to exosphere

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"
@@ skipping 59 matching lines @@
         DCHECK(!focus_);
         focus_ = target;
         focus_->AddSurfaceObserver(this);
       }
 
       DCHECK(!VectorContainsItem(touch_points_, event->touch_id()));
       touch_points_.push_back(event->touch_id());
 
       // Convert location to focus surface coordinate space.
       DCHECK(focus_);
-      gfx::Point location = event->location();
-      aura::Window::ConvertPointToTarget(target->window(), focus_->window(),
-                                         &location);
+      gfx::PointF location = event->location_f();
+      aura::Window::ConvertPointToTargetF(target->window(), focus_->window(),
+                                          &location);

[oshima, 2017/01/20 22:11:54]

If event system can pass through root_location_f, then it should be possible to
convert it to the focus's coordinate using layer's conversion, because the
target and focus should always be the same.

I'm not sure why/wehre that root location needs to be converted during dispatch
process. sadrul@ may know a way to make it work tho.

[sadrul, 2017/01/20 22:35:18]

|event| should have the correct root-location here. |root_location| of the event
gets transformed for high-DPI (and rotation), so the root-location that you get
here should give you the root-location you expect, and converting that
root-location from |focus_->window()->GetRootWindow()| to |focus_->window()|
should give you the correct location-f.

If that works, does that mean you don't need to change the rest of the code
outside of exo?

[denniskempin, 2017/01/20 23:22:19]

I am trying that right now, it would be great if that works! We would still need
the EventLocationFromNativeF method to not round when creating the TouchEvent,
but none of the ConvertPointToTarget methods. 

 
       // 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);
@@ skipping 15 matching lines @@
 
       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())
         return;
 
       DCHECK(focus_);
       // Convert location to focus surface coordinate space.
-      gfx::Point location = event->location();
-      aura::Window::ConvertPointToTarget(
+      gfx::PointF location = event->location_f();
+      aura::Window::ConvertPointToTargetF(
           static_cast<aura::Window*>(event->target()), focus_->window(),
           &location);
-
       delegate_->OnTouchMotion(event->time_stamp(), event->touch_id(),
-                               location);
+                               event->location_f());
       send_details = true;
     } break;
     case ui::ET_TOUCH_CANCELLED: {
       auto it = FindVectorItem(touch_points_, event->touch_id());
       if (it == touch_points_.end())
         return;
 
       DCHECK(focus_);
       focus_->RemoveSurfaceObserver(this);
       focus_ = nullptr;
@@ skipping 49 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