Manually compute inverted matrix for screen rotation

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 141 matching lines @@
     gfx::AcceleratedWidget widget) {
   return reinterpret_cast<RootWindow*>(
       ui::ViewProp::GetValue(widget, kRootWindowForAcceleratedWidget));
 }
 
 void RootWindow::Init() {
   compositor()->SetScaleAndSize(GetDeviceScaleFactorFromDisplay(this),
                                 host_->GetBounds().size());
   Window::Init(ui::LAYER_NOT_DRAWN);
   compositor()->SetRootLayer(layer());
-  SetTransformInternal(gfx::Transform());
+  gfx::Transform identity;
+  SetTransformInternal(identity, identity);
   UpdateWindowSize(host_->GetBounds().size());
   Env::GetInstance()->NotifyRootWindowInitialized(this);
   Show();
 }
 
 void RootWindow::ShowRootWindow() {
   host_->Show();
 }
 
 void RootWindow::HideRootWindow() {
@@ skipping 223 matching lines @@
 }
 
 void RootWindow::ConvertPointToHost(gfx::Point* point) const {
   gfx::Point3F point_3f(*point);
   GetRootTransform().TransformPoint(point_3f);
   *point = gfx::ToFlooredPoint(point_3f.AsPointF());
 }
 
 void RootWindow::ConvertPointFromHost(gfx::Point* point) const {
   gfx::Point3F point_3f(*point);
-  GetRootTransform().TransformPointReverse(point_3f);
+  GetInvertedRootTransform().TransformPoint(point_3f);
   *point = gfx::ToFlooredPoint(point_3f.AsPointF());
 }
 
 void RootWindow::ProcessedTouchEvent(ui::TouchEvent* event,
                                      Window* window,
                                      ui::EventResult result) {
   scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
   gestures.reset(gesture_recognizer_->ProcessTouchEventForGesture(
       *event, result, window));
   ProcessGestures(gestures.get());
@@ skipping 69 matching lines @@
 
 RootWindow* RootWindow::GetRootWindow() {
   return this;
 }
 
 const RootWindow* RootWindow::GetRootWindow() const {
   return this;
 }
 
 void RootWindow::SetTransform(const gfx::Transform& transform) {
-  SetTransformInternal(transform);
+  gfx::Transform invert;
+  if (!transform.GetInverse(&invert))
+    NOTREACHED() << "Singular matrix is set.";
+  SetTransformPair(transform, invert);
+}
+
+void RootWindow::SetTransformPair(const gfx::Transform& transform,
+                                  const gfx::Transform& invert) {
+  SetTransformInternal(transform, invert);
 
   // If the layer is not animating, then we need to update the host size
   // immediately.
   if (!layer()->GetAnimator()->is_animating())
     OnHostResized(host_->GetBounds().size());
 }
 
-void RootWindow::SetTransformInternal(const gfx::Transform& transform) {
+void RootWindow::SetTransformInternal(const gfx::Transform& transform,
+                                      const gfx::Transform& inverted) {
   gfx::Insets insets = host_->GetInsets();
   gfx::Transform translate;
+  invert_transform_ = inverted;
+  invert_transform_.Scale(root_window_scale_, root_window_scale_);
+
   if (insets.top() != 0 || insets.left() != 0) {
     float device_scale_factor = GetDeviceScaleFactor();
-    translate.Translate(insets.left() / device_scale_factor,
-                        insets.top() / device_scale_factor);
-    Window::SetTransform(translate * transform);
+    float x_offset = insets.left() / device_scale_factor;
+    float y_offset = insets.top() / device_scale_factor;
+    translate.Translate(x_offset, y_offset);
+    invert_transform_.Translate(-x_offset, -y_offset);
   }
-  float invert = 1.0f / root_window_scale_;
-  translate.Scale(invert, invert);
+  float inverted_scale = 1.0f / root_window_scale_;
+  translate.Scale(inverted_scale, inverted_scale);
+
   Window::SetTransform(translate * transform);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::EventTarget implementation:
 
 ui::EventTarget* RootWindow::GetParentTarget() {
   return client::GetEventClient(this) ?
       client::GetEventClient(this)->GetToplevelEventTarget() :
           Env::GetInstance();
@@ skipping 139 matching lines @@
   mouse_pressed_handler_ = NULL;
   mouse_moved_handler_ = NULL;
   mouse_event_dispatch_target_ = NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, private:
 
 void RootWindow::TransformEventForDeviceScaleFactor(bool keep_inside_root,
                                                     ui::LocatedEvent* event) {
-  event->UpdateForRootTransform(GetRootTransform());
+  event->UpdateForRootTransform(GetInvertedRootTransform());
 #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.
+    // with calculation error due to the fact that we rotate in dip
+    // coordinates instead of pixels. crbug.com/222483.
     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)
 }
@@ skipping 477 matching lines @@
 }
 
 gfx::Transform RootWindow::GetRootTransform() const {
   float scale = ui::GetDeviceScaleFactor(layer());
   gfx::Transform transform;
   transform.Scale(scale, scale);
   transform *= layer()->transform();
   return transform;
 }
 
+gfx::Transform RootWindow::GetInvertedRootTransform() const {
+  float scale = ui::GetDeviceScaleFactor(layer());
+  gfx::Transform transform;
+  transform.Scale(1.0f / scale, 1.0f / scale);
+  return invert_transform_ * transform;
+}
+
 }  // namespace aura