Hit test on the layer tree rather than the RSLL

cc/base/math_util.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/base/math_util.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
@@ skipping 23 matching lines @@
 
   SkMScalar z = -(transform.matrix().get(2, 0) * p.x() +
              transform.matrix().get(2, 1) * p.y() +
              transform.matrix().get(2, 3)) /
              transform.matrix().get(2, 2);
   HomogeneousCoordinate result(p.x(), p.y(), z, 1.0);
   transform.matrix().mapMScalars(result.vec, result.vec);
   return result;
 }
 
+static HomogeneousCoordinate ProjectHomogeneousPoint(
+    const gfx::Transform& transform,
+    const gfx::PointF& p,
+    bool* clipped) {
+  HomogeneousCoordinate h = ProjectHomogeneousPoint(transform, p);
+  *clipped = h.w() <= 0;
+  return h;
+}
+
 static HomogeneousCoordinate MapHomogeneousPoint(
     const gfx::Transform& transform,
     const gfx::Point3F& p) {
   HomogeneousCoordinate result(p.x(), p.y(), p.z(), 1.0);
   transform.matrix().mapMScalars(result.vec, result.vec);
   return result;
 }
 
 static HomogeneousCoordinate ComputeClippedPointForEdge(
     const HomogeneousCoordinate& h1,
@@ skipping 383 matching lines @@
   *clipped |= clipped_point;
   projected_quad.set_p4(ProjectPoint(transform, q.p4(), &clipped_point));
   *clipped |= clipped_point;
 
   return projected_quad;
 }
 
 gfx::PointF MathUtil::ProjectPoint(const gfx::Transform& transform,
                                    const gfx::PointF& p,
                                    bool* clipped) {
-  HomogeneousCoordinate h = ProjectHomogeneousPoint(transform, p);
-
-  if (h.w() > 0) {
-    // The cartesian coordinates will be valid in this case.
-    *clipped = false;
-    return h.CartesianPoint2d();
-  }
-
-  // The cartesian coordinates will be invalid after dividing by w.
-  *clipped = true;
-
+  HomogeneousCoordinate h = ProjectHomogeneousPoint(transform, p, clipped);
   // Avoid dividing by w if w == 0.
   if (!h.w())
     return gfx::PointF();
 
-  // This return value will be invalid because clipped == true, but (1) users of
+  // This return value will be invalid if clipped == true, but (1) users of
   // this code should be ignoring the return value when clipped == true anyway,
   // and (2) this behavior is more consistent with existing behavior of WebKit
   // transforms if the user really does not ignore the return value.
   return h.CartesianPoint2d();
 }
 
+gfx::Point3F MathUtil::ProjectPoint3D(const gfx::Transform& transform,
+                                      const gfx::PointF& p,
+                                      bool* clipped) {
+  HomogeneousCoordinate h = ProjectHomogeneousPoint(transform, p, clipped);
+  if (!h.w())
+    return gfx::Point3F();
+  return h.CartesianPoint3d();

[enne (OOO), 2014/05/06 20:30:58]

What if h is clipped?

[Ian Vollick, 2014/05/06 21:06:20]

In that case, the answer isn't valid, but won't div-by-zero. This mimics the
behavior of ProjectPoint call above; the only exception is that I don't discard
z here. (I omitted the comment because the fn's are similar -- should I put it
back?)

+}
+
 gfx::RectF MathUtil::ScaleRectProportional(const gfx::RectF& input_outer_rect,
                                            const gfx::RectF& scale_outer_rect,
                                            const gfx::RectF& scale_inner_rect) {
   gfx::RectF output_inner_rect = input_outer_rect;
   float scale_rect_to_input_scale_x =
       scale_outer_rect.width() / input_outer_rect.width();
   float scale_rect_to_input_scale_y =
       scale_outer_rect.height() / input_outer_rect.height();
 
   gfx::Vector2dF top_left_diff =
@@ skipping 158 matching lines @@
   return scoped_ptr<base::Value>(base::Value::CreateDoubleValue(
       std::min(value, std::numeric_limits<double>::max())));
 }
 
 scoped_ptr<base::Value> MathUtil::AsValueSafely(float value) {
   return scoped_ptr<base::Value>(base::Value::CreateDoubleValue(
       std::min(value, std::numeric_limits<float>::max())));
 }
 
 }  // namespace cc