Convert native mouse locations to the locations in screen coordinate in RootWindowHostLinux.

ui/aura/root_window_host_linux.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/root_window_host_linux.h"
 
 #include <X11/cursorfont.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xrandr.h>
@@ skipping 419 matching lines @@
   XEvent* xev = event;
 
   CheckXEventForConsistency(xev);
 
   if (FindEventTarget(event) == x_root_window_)
     return DispatchEventForRootWindow(event);
 
   switch (xev->type) {
     case EnterNotify: {
       ui::MouseEvent mouseenter_event(xev);
-      delegate_->OnHostMouseEvent(&mouseenter_event);
+      TranslateAndDispatchMouseEvent(&mouseenter_event);
       break;
     }
     case Expose:
       delegate_->AsRootWindow()->ScheduleFullDraw();
       break;
     case KeyPress: {
       ui::KeyEvent keydown_event(xev, false);
       delegate_->OnHostKeyEvent(&keydown_event);
       break;
     }
@@ skipping 11 matching lines @@
           gesture_client->OnUserAction(
               static_cast<int>(xev->xbutton.button) == kBackMouseButton ?
               client::UserActionClient::BACK :
               client::UserActionClient::FORWARD);
         }
         break;
       }
     }  // fallthrough
     case ButtonRelease: {
       ui::MouseEvent mouseev(xev);
-      delegate_->OnHostMouseEvent(&mouseev);
+      TranslateAndDispatchMouseEvent(&mouseev);
       break;
     }
     case FocusOut:
       if (xev->xfocus.mode != NotifyGrab)
         delegate_->OnHostLostCapture();
       break;
     case ConfigureNotify: {
       DCHECK_EQ(xwindow_, xev->xconfigure.event);
       DCHECK_EQ(xwindow_, xev->xconfigure.window);
       // It's possible that the X window may be resized by some other means
@@ skipping 83 matching lines @@
             next_event.xmotion.subwindow == xev->xmotion.subwindow &&
             next_event.xmotion.state == xev->xmotion.state) {
           XNextEvent(xev->xany.display, &last_event);
           xev = &last_event;
         } else {
           break;
         }
       }
 
       ui::MouseEvent mouseev(xev);
-      delegate_->OnHostMouseEvent(&mouseev);
+      TranslateAndDispatchMouseEvent(&mouseev);
       break;
     }
   }
   return true;
 }
 
 bool RootWindowHostLinux::DispatchEventForRootWindow(
     const base::NativeEvent& event) {
   switch (event->type) {
     case ConfigureNotify:
@@ skipping 77 matching lines @@
             gesture_client->OnUserAction(
                 (button == kBackMouseButton && !reverse_direction) ||
                 (button == kForwardMouseButton && reverse_direction) ?
                 client::UserActionClient::BACK :
                 client::UserActionClient::FORWARD);
           }
           break;
         }
       }
       ui::MouseEvent mouseev(xev);
-      delegate_->OnHostMouseEvent(&mouseev);
+      TranslateAndDispatchMouseEvent(&mouseev);
       break;
     }
     case ui::ET_MOUSEWHEEL: {
       ui::MouseWheelEvent mouseev(xev);
-      delegate_->OnHostMouseEvent(&mouseev);
+      TranslateAndDispatchMouseEvent(&mouseev);
       break;
     }
     case ui::ET_SCROLL_FLING_START:
     case ui::ET_SCROLL_FLING_CANCEL:
     case ui::ET_SCROLL: {
       ui::ScrollEvent scrollev(xev);
       delegate_->OnHostScrollEvent(&scrollev);
       break;
     }
     case ui::ET_UNKNOWN:
@@ skipping 292 matching lines @@
   // Per ICCCM 2.8, "Manager Selections", window managers should take ownership
   // of WM_Sn selections (where n is a screen number).
   return XGetSelectionOwner(
       xdisplay_, atom_cache_.GetAtom("WM_S0")) != None;
 }
 
 void RootWindowHostLinux::SetCursorInternal(gfx::NativeCursor cursor) {
   XDefineCursor(xdisplay_, xwindow_, cursor.platform());
 }
 
+void RootWindowHostLinux::TranslateAndDispatchMouseEvent(
+    ui::MouseEvent* event) {
+  RootWindow* root = GetRootWindow();
+  client::ScreenPositionClient* screen_position_client =
+      GetScreenPositionClient(root);
+  if (screen_position_client && !bounds_.Contains(event->location())) {
+    gfx::Point location(event->location());
+    screen_position_client->ConvertNativePointToScreen(root, &location);
+    screen_position_client->ConvertPointFromScreen(root, &location);
+    event->set_location(location);
+    event->set_root_location(location);
+  }
+  delegate_->OnHostMouseEvent(event);
+}
+
 // static
 RootWindowHost* RootWindowHost::Create(RootWindowHostDelegate* delegate,
                                        const gfx::Rect& bounds) {
   return new RootWindowHostLinux(delegate, bounds);
 }
 
 // static
 RootWindowHost* RootWindowHost::GetForAcceleratedWidget(
     gfx::AcceleratedWidget accelerated_widget) {
   return reinterpret_cast<RootWindowHost*>(
       ui::ViewProp::GetValue(accelerated_widget, kRootWindowHostLinuxKey));
 }
 
 // static
 gfx::Size RootWindowHost::GetNativeScreenSize() {
   ::Display* xdisplay = base::MessagePumpAuraX11::GetDefaultXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 }  // namespace aura