Round near zero value in rotation matrix to zero

ash/display/display_controller.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 "ash/display/display_controller.h"
 
 #include <algorithm>
+#include <cmath>
 #include <map>
 
 #include "ash/ash_root_window_transformer.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/display_pref_util.h"
 #include "ash/host/root_window_host_factory.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/json/json_value_converter.h"
 #include "base/string_piece.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
+#include "third_party/skia/include/utils/SkMatrix44.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
@@ skipping 79 matching lines @@
 }
 
 bool GetDisplayIdFromString(const base::StringPiece& position, int64* field) {
   return base::StringToInt64(position, field);
 }
 
 internal::DisplayManager* GetDisplayManager() {
   return Shell::GetInstance()->display_manager();
 }
 
+// Round near zero value to zero.
+void RoundNearZero(gfx::Transform* transform) {
+  const float kEpsilon = 0.001f;
+  SkMatrix44& matrix = transform->matrix();
+  for (int x = 0; x < 4; ++x) {
+    for (int y = 0; y < 4; ++y) {
+      if (std::abs(SkMScalarToFloat(matrix.get(x, y))) < kEpsilon)
+        matrix.set(x, y, SkFloatToMScalar(0.0f));
+    }
+  }
+}
+
 void RotateRootWindow(aura::RootWindow* root_window,
                       const gfx::Display& display,
                       const internal::DisplayInfo& info) {
   // TODO(oshima): Add animation. (crossfade+rotation, or just cross-fade)
 #if defined(OS_WIN)
   // Windows 8 bots refused to resize the host window, and
   // updating the transform results in incorrectly resizing
   // the root window. Don't apply the transform unless
   // necessary so that unit tests pass on win8 bots.
   if (info.rotation() == root_window->GetProperty(kRotationPropertyKey))
     return;
   root_window->SetProperty(kRotationPropertyKey, info.rotation());
 #endif
   gfx::Transform rotate;
   // TODO(oshima): Manually complute the inverse of the
   // rotate+translate matrix to compensate for computation error in
   // the inverted matrix. Ideally, SkMatrix should have special
   // case handling for rotate+translate case. crbug.com/222483.
   gfx::Transform reverse_rotate;
 
   // The origin is (0, 0), so the translate width/height must be reduced by
   // 1 pixel.
   float one_pixel = 1.0f / display.device_scale_factor();
   switch (info.rotation()) {
     case gfx::Display::ROTATE_0:
       break;
     case gfx::Display::ROTATE_90:
       rotate.Translate(display.bounds().height() - one_pixel, 0);
       rotate.Rotate(90);
-      // Rotate 270 instead of 90 as it will cause calcuration error.
       reverse_rotate.Rotate(270);
       reverse_rotate.Translate(-(display.bounds().height() - one_pixel), 0);
       break;
     case gfx::Display::ROTATE_270:
       rotate.Translate(0, display.bounds().width() - one_pixel);
       rotate.Rotate(270);
       reverse_rotate.Rotate(90);
       reverse_rotate.Translate(0, -(display.bounds().width() - one_pixel));
       break;
     case gfx::Display::ROTATE_180:
       rotate.Translate(display.bounds().width() - one_pixel,
                        display.bounds().height() - one_pixel);
       rotate.Rotate(180);
       reverse_rotate.Rotate(180);
       reverse_rotate.Translate(-(display.bounds().width() - one_pixel),
                                -(display.bounds().height() - one_pixel));
       break;
   }
+  RoundNearZero(&rotate);
+  RoundNearZero(&reverse_rotate);
+
   scoped_ptr<aura::RootWindowTransformer> transformer(
       new AshRootWindowTransformer(root_window,
                                    rotate,
                                    reverse_rotate,
                                    info.GetOverscanInsetsInPixel(),
                                    info.ui_scale()));
   root_window->SetRootWindowTransformer(transformer.Pass());
 }
 
 void SetDisplayPropertiesOnHostWindow(aura::RootWindow* root,
@@ skipping 833 matching lines @@
 }
 
 void DisplayController::OnFadeOutForSwapDisplayFinished() {
 #if defined(OS_CHROMEOS)
   SetPrimaryDisplay(ScreenAsh::GetSecondaryDisplay());
   Shell::GetInstance()->output_configurator_animation()->StartFadeInAnimation();
 #endif
 }
 
 }  // namespace ash