Adding Blink-side 3d Box and Bounds calculations to TransformOperations

Source/platform/transforms/TransformationMatrix.cpp

 /*
  * Copyright (C) 2005, 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) 2009 Torch Mobile, Inc.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 10 matching lines @@
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "platform/transforms/TransformationMatrix.h"
 
+#include "platform/geometry/FloatBox.h"
 #include "platform/geometry/FloatQuad.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/transforms/AffineTransform.h"
 
 #include "wtf/Assertions.h"
 #include "wtf/MathExtras.h"
 
 #if CPU(X86_64)
@@ skipping 598 matching lines @@
 
     float bottom;
     if (std::isinf(mappedQuadBounds.y()) && std::isinf(mappedQuadBounds.height()))
         bottom = (LayoutUnit::max() / 2).toFloat();
     else
         bottom = clampEdgeValue(ceilf(mappedQuadBounds.maxY()));
 
     return LayoutRect(LayoutUnit::clamp(left), LayoutUnit::clamp(top),  LayoutUnit::clamp(right - left), LayoutUnit::clamp(bottom - top));
 }
 
+void TransformationMatrix::transformBox(FloatBox& box) const
+{
+    FloatBox bounds;
+    bool firstPoint = true;
+    for (size_t i = 0; i < 2; ++i) {
+        for (size_t j = 0; j < 2; ++j) {
+            for (size_t k = 0; k < 2; ++k) {
+                FloatPoint3D point(box.x(), box.y(), box.z());
+                point += FloatPoint3D(i * box.width(), j * box.height(), k * box.depth());
+                point = mapPoint(point);
+                if (firstPoint) {
+                    bounds.setOrigin(point);
+                    firstPoint = false;
+                } else {
+                    bounds.expandTo(point);
+                }
+            }
+        }
+    }
+    box = bounds;
+}
+
 FloatPoint TransformationMatrix::mapPoint(const FloatPoint& p) const
 {
     if (isIdentityOrTranslation())
         return FloatPoint(p.x() + static_cast<float>(m_matrix[3][0]), p.y() + static_cast<float>(m_matrix[3][1]));
 
     return internalMapPoint(p);
 }
 
 FloatPoint3D TransformationMatrix::mapPoint(const FloatPoint3D& p) const
 {
@@ skipping 864 matching lines @@
     ret.setDouble(2, 2, matrix.m33());
     ret.setDouble(2, 3, matrix.m43());
     ret.setDouble(3, 0, matrix.m14());
     ret.setDouble(3, 1, matrix.m24());
     ret.setDouble(3, 2, matrix.m34());
     ret.setDouble(3, 3, matrix.m44());
     return ret;
 }
 
 }