ozone: Use host coordinates in UIControlsOzone

ui/aura/test/ui_controls_factory_ozone.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 "base/bind.h"
 #include "base/logging.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/test/aura_test_utils.h"
 #include "ui/aura/test/ui_controls_factory_aura.h"
@@ skipping 82 matching lines @@
       long screen_x,
       long screen_y,
       const base::Closure& closure) override {
     gfx::Point root_location(screen_x, screen_y);
     aura::client::ScreenPositionClient* screen_position_client =
         aura::client::GetScreenPositionClient(host_->window());
     if (screen_position_client) {
       screen_position_client->ConvertPointFromScreen(host_->window(),
                                                      &root_location);
     }
-    gfx::Point root_current_location =
-        QueryLatestMousePositionRequestInHost(host_);
-    host_->ConvertPointFromHost(&root_current_location);
+
+    gfx::Point host_location = root_location;
+    host_->ConvertPointToHost(&host_location);
+
+    gfx::Point native_screen_location = root_location;
+    host_->ConvertPointToNativeScreen(&native_screen_location);
 
     if (button_down_mask_)
-      PostMouseEvent(ui::ET_MOUSE_DRAGGED, root_location, 0, 0);
+      PostMouseEvent(ui::ET_MOUSE_DRAGGED, host_location,
+                     native_screen_location, 0, 0);
     else
-      PostMouseEvent(ui::ET_MOUSE_MOVED, root_location, 0, 0);
+      PostMouseEvent(ui::ET_MOUSE_MOVED, host_location, native_screen_location,
+                     0, 0);
 
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
   virtual bool SendMouseEvents(ui_controls::MouseButton type,
                                int state) override {
     return SendMouseEventsNotifyWhenDone(type, state, base::Closure());
   }
   virtual bool SendMouseEventsNotifyWhenDone(
       ui_controls::MouseButton type,
       int state,
       const base::Closure& closure) override {
-    gfx::Point loc = aura::Env::GetInstance()->last_mouse_location();
+    gfx::Point root_location = aura::Env::GetInstance()->last_mouse_location();
     aura::client::ScreenPositionClient* screen_position_client =
         aura::client::GetScreenPositionClient(host_->window());
     if (screen_position_client) {
-      screen_position_client->ConvertPointFromScreen(host_->window(), &loc);
+      screen_position_client->ConvertPointFromScreen(host_->window(),
+                                                     &root_location);
     }
+
+    gfx::Point host_location = root_location;
+    host_->ConvertPointToHost(&host_location);
+
+    gfx::Point native_screen_location = root_location;
+    host_->ConvertPointToNativeScreen(&native_screen_location);
+
     int flag = 0;
 
     switch (type) {
       case ui_controls::LEFT:
         flag = ui::EF_LEFT_MOUSE_BUTTON;
         break;
       case ui_controls::MIDDLE:
         flag = ui::EF_MIDDLE_MOUSE_BUTTON;
         break;
       case ui_controls::RIGHT:
         flag = ui::EF_RIGHT_MOUSE_BUTTON;
         break;
       default:
         NOTREACHED();
         break;
     }
 
     if (state & ui_controls::DOWN) {
       button_down_mask_ |= flag;
-      PostMouseEvent(ui::ET_MOUSE_PRESSED, loc, button_down_mask_ | flag, flag);
+      PostMouseEvent(ui::ET_MOUSE_PRESSED, host_location,
+                     native_screen_location, button_down_mask_ | flag, flag);
     }
     if (state & ui_controls::UP) {
       button_down_mask_ &= ~flag;
-      PostMouseEvent(
-          ui::ET_MOUSE_RELEASED, loc, button_down_mask_ | flag, flag);
+      PostMouseEvent(ui::ET_MOUSE_RELEASED, host_location,
+                     native_screen_location, button_down_mask_ | flag, flag);
     }
 
     RunClosureAfterAllPendingUIEvents(closure);
     return true;
   }
   virtual bool SendMouseClick(ui_controls::MouseButton type) override {
     return SendMouseEvents(type, ui_controls::UP | ui_controls::DOWN);
   }
   virtual void RunClosureAfterAllPendingUIEvents(
       const base::Closure& closure) override {
@@ skipping 24 matching lines @@
                         ui::KeyboardCode key_code,
                         int flags) {
     // Do not rewrite injected events. See crbug.com/136465.
     flags |= ui::EF_FINAL;
 
     ui::KeyEvent key_event(type, key_code, flags);
     SendEventToProcessor(&key_event);
   }
 
   void PostMouseEvent(ui::EventType type,
-                      const gfx::PointF& location,
+                      const gfx::PointF& host_location,
+                      const gfx::PointF& native_screen_location,
                       int flags,
                       int changed_button_flags) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(&UIControlsOzone::PostMouseEventTask,
-                   base::Unretained(this),
-                   type,
-                   location,
-                   flags,
+        base::Bind(&UIControlsOzone::PostMouseEventTask, base::Unretained(this),
+                   type, host_location, native_screen_location, flags,
                    changed_button_flags));
   }
 
   void PostMouseEventTask(ui::EventType type,
-                          const gfx::PointF& location,
+                          const gfx::PointF& host_location,
+                          const gfx::PointF& native_screen_location,
                           int flags,
                           int changed_button_flags) {
-    ui::MouseEvent mouse_event(
-        type, location, location, flags, changed_button_flags);
+    ui::MouseEvent mouse_event(type, host_location, native_screen_location,

[sadrul, 2014/12/03 21:33:56]

Confusing as it is, this is actually not right. Looking at LocatedEvents that
created from an X11 event, LocatedEvent::root_location_ =
LocatedEvent::location_ upon construction. When we say |root_location_| in
LocatedEvent parlance, it's actually the location in the 'root event target'
space (so the root-window in aura, root-view in views), and |location_| is in
the 'event target' space (so the Window or View the event is being dispatched
to).

+                               flags, changed_button_flags);
 
     // This hack is necessary to set the repeat count for clicks.
     ui::MouseEvent mouse_event2(&mouse_event);
 
     SendEventToProcessor(&mouse_event2);
   }
 
   WindowTreeHost* host_;
 
   // Mask of the mouse buttons currently down.
   unsigned button_down_mask_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(UIControlsOzone);
 };
 
 }  // namespace
 
 ui_controls::UIControlsAura* CreateUIControlsAura(WindowTreeHost* host) {
   return new UIControlsOzone(host);
 }
 
 }  // namespace test
 }  // namespace aura