Provide approximate type functions for SkMatrix44.

cc/resources/picture_layer_tiling.cc

 // Copyright 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 "cc/resources/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
@@ skipping 321 matching lines @@
 
 gfx::Size PictureLayerTiling::CoverageIterator::texture_size() const {
   return tiling_->tiling_data_.max_texture_size();
 }
 
 void PictureLayerTiling::Reset() {
   live_tiles_rect_ = gfx::Rect();
   tiles_.clear();
 }
 
-namespace {
-
-bool NearlyOne(SkMScalar lhs) {
-  return std::abs(lhs-1.0) < std::numeric_limits<float>::epsilon();
-}
-
-bool NearlyZero(SkMScalar lhs) {
-  return std::abs(lhs) < std::numeric_limits<float>::epsilon();
-}
-
-bool ApproximatelyTranslation(const SkMatrix44& matrix) {
-  return
-      NearlyOne(matrix.get(0, 0)) &&
-      NearlyZero(matrix.get(1, 0)) &&
-      NearlyZero(matrix.get(2, 0)) &&
-      matrix.get(3, 0) == 0 &&
-      NearlyZero(matrix.get(0, 1)) &&
-      NearlyOne(matrix.get(1, 1)) &&
-      NearlyZero(matrix.get(2, 1)) &&
-      matrix.get(3, 1) == 0 &&
-      NearlyZero(matrix.get(0, 2)) &&
-      NearlyZero(matrix.get(1, 2)) &&
-      NearlyOne(matrix.get(2, 2)) &&
-      matrix.get(3, 2) == 0 &&
-      matrix.get(3, 3) == 1;
-}
-
-}  // namespace
-
 void PictureLayerTiling::UpdateTilePriorities(
     WhichTree tree,
     gfx::Size device_viewport,
     gfx::Rect viewport_in_layer_space,
     gfx::Rect visible_layer_rect,
     gfx::Size last_layer_bounds,
     gfx::Size current_layer_bounds,
     float last_layer_contents_scale,
     float current_layer_contents_scale,
     const gfx::Transform& last_screen_transform,
@@ skipping 36 matching lines @@
       last_layer_bounds == current_layer_bounds) {
     time_delta =
         current_frame_time_in_seconds - last_impl_frame_time_in_seconds_;
   }
 
   gfx::Rect view_rect(device_viewport);
   float current_scale = current_layer_contents_scale / contents_scale_;
   float last_scale = last_layer_contents_scale / contents_scale_;
 
   // Fast path tile priority calculation when both transforms are translations.
-  if (ApproximatelyTranslation(last_screen_transform.matrix()) &&
-      ApproximatelyTranslation(current_screen_transform.matrix())) {
+  if (MathUtil::IsApproximatelyPureTranslation(
+          last_screen_transform, std::numeric_limits<float>::epsilon()) &&
+      MathUtil::IsApproximatelyPureTranslation(
+          current_screen_transform, std::numeric_limits<float>::epsilon())) {
     gfx::Vector2dF current_offset(
         current_screen_transform.matrix().get(0, 3),
         current_screen_transform.matrix().get(1, 3));
     gfx::Vector2dF last_offset(
         last_screen_transform.matrix().get(0, 3),
         last_screen_transform.matrix().get(1, 3));
 
     for (TilingData::Iterator iter(&tiling_data_, interest_rect);
          iter; ++iter) {
       TileMap::iterator find = tiles_.find(iter.index());
@@ skipping 349 matching lines @@
 
     // If our delta is less then our event distance, we're done.
     if (delta < event.distance)
       break;
   }
 
   return gfx::Rect(origin_x, origin_y, width, height);
 }
 
 }  // namespace cc