Add localToAbsoluteTransform and localToAncestorTransform.

third_party/WebKit/Source/platform/geometry/TransformState.h

 /*
  * Copyright (C) 2011 Apple 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 29 matching lines @@
 class PLATFORM_EXPORT TransformState {
     STACK_ALLOCATED();
 public:
     enum TransformDirection { ApplyTransformDirection, UnapplyInverseTransformDirection };
     enum TransformAccumulation { FlattenTransform, AccumulateTransform };
 
     TransformState(TransformDirection mappingDirection, const FloatPoint& p, const FloatQuad& quad)
         : m_lastPlanarPoint(p)
         , m_lastPlanarQuad(quad)
         , m_accumulatingTransform(false)
+        , m_forceAccumulatingTransform(false)
         , m_mapPoint(true)
         , m_mapQuad(true)
         , m_direction(mappingDirection)
     {
     }
 
     TransformState(TransformDirection mappingDirection, const FloatPoint& p)
         : m_lastPlanarPoint(p)
         , m_accumulatingTransform(false)
+        , m_forceAccumulatingTransform(false)
         , m_mapPoint(true)
         , m_mapQuad(false)
         , m_direction(mappingDirection)
     {
     }
 
     TransformState(TransformDirection mappingDirection, const FloatQuad& quad)
         : m_lastPlanarQuad(quad)
         , m_accumulatingTransform(false)
+        , m_forceAccumulatingTransform(false)
         , m_mapPoint(false)
         , m_mapQuad(true)
         , m_direction(mappingDirection)
     {
     }
 
+    // Accumulate a transform but don't map any points directly.
+    TransformState(TransformDirection mappingDirection)
+        : m_accumulatedTransform(TransformationMatrix::create())
+        , m_accumulatingTransform(true)
+        , m_forceAccumulatingTransform(true)
+        , m_mapPoint(false)
+        , m_mapQuad(false)
+        , m_direction(mappingDirection)
+    {
+    }
+
     TransformState(const TransformState& other) { *this = other; }
 
     TransformState& operator=(const TransformState&);
 
     void setQuad(const FloatQuad& quad)
     {
         // FIXME: this assumes that the quad being added is in the coordinate system of the current state.
         // This breaks if we're simultaneously mapping a point. https://bugs.webkit.org/show_bug.cgi?id=106680
         ASSERT(!m_mapPoint);
         m_accumulatedOffset = LayoutSize();
@@ skipping 15 matching lines @@
     void flatten(bool* wasClamped = 0);
 
     // Return the coords of the point or quad in the last flattened layer
     FloatPoint lastPlanarPoint() const { return m_lastPlanarPoint; }
     FloatQuad lastPlanarQuad() const { return m_lastPlanarQuad; }
 
     // Return the point or quad mapped through the current transform
     FloatPoint mappedPoint(bool* wasClamped = 0) const;
     FloatQuad mappedQuad(bool* wasClamped = 0) const;
 
+    // Return the accumulated transform.
+    const TransformationMatrix& accumulatedTransform() const;
+
 private:
     void translateTransform(const LayoutSize&);
     void translateMappedCoordinates(const LayoutSize&);
     void flattenWithTransform(const TransformationMatrix&, bool* wasClamped);
     void applyAccumulatedOffset();
 
     FloatPoint m_lastPlanarPoint;
     FloatQuad m_lastPlanarQuad;
 
     // We only allocate the transform if we need to
     OwnPtr<TransformationMatrix> m_accumulatedTransform;
     LayoutSize m_accumulatedOffset;
     bool m_accumulatingTransform;
+    bool m_forceAccumulatingTransform;
     bool m_mapPoint, m_mapQuad;
     TransformDirection m_direction;
 };
 
 } // namespace blink
 
 #endif // TransformState_h