Use LCD text if the transform IsAlmostIdentityAndIntegerTranslation

ui/gfx/transform.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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/gfx/transform.h"
 
 #include <cmath>
@@ skipping 12 matching lines @@
 namespace {
 
 // Taken from SkMatrix44.
 const double kTooSmallForDeterminant = 1e-8;
 
 double TanDegrees(double degrees) {
   double radians = degrees * M_PI / 180;
   return std::tan(radians);
 }
 
+bool AlmostEqual(double d, double i) {
+  const double kErrorThreshold = 1e-6;

[alokp, 2013/03/08 19:40:06]

The error threshold should really depend on the transformation matrix itself. My
intuition suggests that is should be scaled with the determinant of the matrix.

For now it can stay fixed like you have here because you are only using it for
almost identity matrices. But may be a comment may be good for posterity.

[Xianzhu, 2013/03/08 23:36:56]

My another thought is not to add these methods but add a new local function in
layer_tree_host_common.cc named IsTransformAcceptableForLCDText() so that we can
just use a special rule for that purpose. See my another comment.

+  return std::abs(d - i) < kErrorThreshold;
+}
+
+double Round(double d) {
+  return (d > 0.0) ? std::floor(d + 0.5) : std::ceil(d - 0.5);
+}
+
 }  // namespace
 
 Transform::Transform(
     double col1row1, double col2row1, double col3row1, double col4row1,
     double col1row2, double col2row2, double col3row2, double col4row2,
     double col1row3, double col2row3, double col3row3, double col4row3,
     double col1row4, double col2row4, double col3row4, double col4row4)
     : matrix_(SkMatrix44::kUninitialized_Constructor)
 {
   matrix_.setDouble(0, 0, col1row1);
@@ skipping 165 matching lines @@
     return false;
 
   bool no_fractional_translation =
       static_cast<int>(matrix_.getDouble(0, 3)) == matrix_.getDouble(0, 3) &&
       static_cast<int>(matrix_.getDouble(1, 3)) == matrix_.getDouble(1, 3) &&
       static_cast<int>(matrix_.getDouble(2, 3)) == matrix_.getDouble(2, 3);
 
   return no_fractional_translation;
 }
 
+
+bool Transform::IsAlmostIdentity() const {
+  return IsAlmostIdentityOrTranslation() &&
+         AlmostEqual(matrix_.getDouble(0, 3), 0) &&
+         AlmostEqual(matrix_.getDouble(1, 3), 0) &&
+         AlmostEqual(matrix_.getDouble(2, 3), 0);
+}
+
+bool Transform::IsAlmostIdentityOrTranslation() const {
+  return IsScaleOrTranslation() &&
+         AlmostEqual(matrix_.getDouble(0, 0), 1) &&
+         AlmostEqual(matrix_.getDouble(1, 1), 1) &&
+         AlmostEqual(matrix_.getDouble(2, 2), 1);
+}
+
+bool Transform::IsAlmostIdentityOrIntegerTranslation() const {
+  return IsAlmostIdentityOrTranslation() &&
+         AlmostEqual(matrix_.getDouble(0, 3), Round(matrix_.getDouble(0, 3))) &&
+         AlmostEqual(matrix_.getDouble(1, 3), Round(matrix_.getDouble(1, 3))) &&
+         AlmostEqual(matrix_.getDouble(2, 3), Round(matrix_.getDouble(2, 3)));
+}
+
 bool Transform::IsBackFaceVisible() const {
   // Compute whether a layer with a forward-facing normal of (0, 0, 1, 0)
   // would have its back face visible after applying the transform.
   if (matrix_.isIdentity())
     return false;
 
   // This is done by transforming the normal and seeing if the resulting z
   // value is positive or negative. However, note that transforming a normal
   // actually requires using the inverse-transpose of the original transform.
   //
@@ skipping 214 matching lines @@
       matrix_.getDouble(2, 1),
       matrix_.getDouble(2, 2),
       matrix_.getDouble(2, 3),
       matrix_.getDouble(3, 0),
       matrix_.getDouble(3, 1),
       matrix_.getDouble(3, 2),
       matrix_.getDouble(3, 3));
 }
 
 }  // namespace gfx