Handle floating point coordinates from ozone to exosphere

ui/aura/window.cc

 // Copyright (c) 2012 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/aura/window.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 414 matching lines @@
     if (result)
       return result;
   }
   return NULL;
 }
 
 // static
 void Window::ConvertPointToTarget(const Window* source,
                                   const Window* target,
                                   gfx::Point* point) {
+  gfx::PointF point_f(*point);
+  ConvertPointToTargetF(source, target, &point_f);
+  *point = gfx::ToFlooredPoint(point_f);
+}
+
+// static
+void Window::ConvertPointToTargetF(const Window* source,
+                                   const Window* target,
+                                   gfx::PointF* point) {
   if (!source)
     return;
   if (source->GetRootWindow() != target->GetRootWindow()) {
+    gfx::Point floored = gfx::ToFlooredPoint(*point);

[tdresser, 2017/01/20 16:07:48]

Do we need to floor in this case?

[denniskempin, 2017/01/20 18:26:33]

I am flooring here to be able to pass a Point into the ScreenPositionClient
methods. I was trying to avoid updating the ScreenPositionClient interface to
have PointF support as well, since it has a whole bunch of implementations. 
But I can try it to see how far reaching that change would be. 

     client::ScreenPositionClient* source_client =
         client::GetScreenPositionClient(source->GetRootWindow());
     // |source_client| can be NULL in tests.
     if (source_client)
-      source_client->ConvertPointToScreen(source, point);
+      source_client->ConvertPointToScreen(source, &floored);
 
     client::ScreenPositionClient* target_client =
         client::GetScreenPositionClient(target->GetRootWindow());
     // |target_client| can be NULL in tests.
     if (target_client)
-      target_client->ConvertPointFromScreen(target, point);
+      target_client->ConvertPointFromScreen(target, &floored);
+
+    *point = gfx::PointF(floored);
   } else {
-    ui::Layer::ConvertPointToLayer(source->layer(), target->layer(), point);
+    ui::Layer::ConvertPointToLayerF(source->layer(), target->layer(), point);
   }
 }
 
 // static
 void Window::ConvertRectToTarget(const Window* source,
                                  const Window* target,
                                  gfx::Rect* rect) {
   DCHECK(rect);
   gfx::Point origin = rect->origin();
   ConvertPointToTarget(source, target, &origin);
@@ skipping 657 matching lines @@
     layer_name = "Unnamed Window";
 
   if (id_ != -1)
     layer_name += " " + base::IntToString(id_);
 
   layer()->set_name(layer_name);
 #endif
 }
 
 }  // namespace aura