Short term workaround to deal with calculation error caused by inverted matrix.

ui/aura/root_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/root_window.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 651 matching lines @@
 
 void RootWindow::ClearMouseHandlers() {
   mouse_pressed_handler_ = NULL;
   mouse_moved_handler_ = NULL;
   mouse_event_dispatch_target_ = NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, private:
 
-void RootWindow::TransformEventForDeviceScaleFactor(ui::LocatedEvent* event) {
+void RootWindow::TransformEventForDeviceScaleFactor(ui::LocatedEvent* event,
+                                                    bool keep_inside_root) {
   event->UpdateForRootTransform(GetRootTransform());
+#if defined(OS_CHROMEOS)
+  const gfx::Rect& root_bounds = bounds();
+  if (keep_inside_root &
+      host_->GetBounds().Contains(event->system_location()) &&
+      !root_bounds.Contains(event->root_location())) {
+    // Make sure that the mouse location inside the host window gets
+    // translated inside root window.
+    // TODO(oshima): This is (hopefully) short term bandaid to deal
+    // with calculation error in inverted matrix. We'll try better
+    // alternative (crbug.com/222483) for m28.
+    int x = event->location().x();
+    int y = event->location().y();
+    x = std::min(std::max(x, root_bounds.x()), root_bounds.right());
+    y = std::min(std::max(y, root_bounds.y()), root_bounds.bottom());
+    const gfx::Point new_location(x, y);
+    event->set_location(new_location);
+    event->set_root_location(new_location);
+  }
+#endif  // defined(OS_CHROMEOS)
 }
 
 void RootWindow::HandleMouseMoved(const ui::MouseEvent& event, Window* target) {
   if (target == mouse_moved_handler_)
     return;
 
   DispatchMouseEnterOrExit(event, ui::ET_MOUSE_EXITED);
 
   if (mouse_event_dispatch_target_ != target) {
     mouse_moved_handler_ = NULL;
@@ skipping 193 matching lines @@
       held_mouse_move_.reset();
     }
   }
   DispatchHeldEvents();
   return DispatchMouseEventImpl(event);
 }
 
 bool RootWindow::OnHostScrollEvent(ui::ScrollEvent* event) {
   DispatchHeldEvents();
 
-  TransformEventForDeviceScaleFactor(event);
+  TransformEventForDeviceScaleFactor(event, false);
   SetLastMouseLocation(this, event->location());
   synthesize_mouse_move_ = false;
 
   Window* target = mouse_pressed_handler_ ?
       mouse_pressed_handler_ : client::GetCaptureWindow(this);
 
   if (!target)
     target = GetEventHandlerForPoint(event->location());
 
   if (!target)
@@ skipping 25 matching lines @@
       // fallthrough
     case ui::ET_TOUCH_RELEASED:
       touch_ids_down_ = (touch_ids_down_ | (1 << event->touch_id())) ^
                         (1 << event->touch_id());
       Env::GetInstance()->set_touch_down(touch_ids_down_ != 0);
       break;
 
     default:
       break;
   }
-  TransformEventForDeviceScaleFactor(event);
+  TransformEventForDeviceScaleFactor(event, false);
   bool handled = false;
   Window* target = client::GetCaptureWindow(this);
   if (!target) {
     target = ConsumerToWindow(
         gesture_recognizer_->GetTouchLockedTarget(event));
     if (!target) {
       target = ConsumerToWindow(
           gesture_recognizer_->GetTargetForLocation(event->location()));
     }
   }
@@ skipping 80 matching lines @@
 }
 
 RootWindow* RootWindow::AsRootWindow() {
   return this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, private:
 
 bool RootWindow::DispatchMouseEventImpl(ui::MouseEvent* event) {
-  TransformEventForDeviceScaleFactor(event);
+  TransformEventForDeviceScaleFactor(event, true);
   Window* target = mouse_pressed_handler_ ?
       mouse_pressed_handler_ : client::GetCaptureWindow(this);
   if (!target)
     target = GetEventHandlerForPoint(event->location());
   return DispatchMouseEventToTarget(event, target);
 }
 
 bool RootWindow::DispatchMouseEventRepost(ui::MouseEvent* event) {
   if (event->type() != ui::ET_MOUSE_PRESSED)
     return false;
@@ skipping 108 matching lines @@
 
 gfx::Transform RootWindow::GetRootTransform() const {
   float scale = ui::GetDeviceScaleFactor(layer());
   gfx::Transform transform;
   transform.Scale(scale, scale);
   transform *= layer()->transform();
   return transform;
 }
 
 }  // namespace aura