Avoid using forced layout to trigger paint invalidation for SVG containers

third_party/WebKit/Source/platform/transforms/AffineTransform.cpp

 /*
  * Copyright (C) 2005, 2006 Apple Computer, Inc.  All rights reserved.
  *               2010 Dirk Schulze <krit@webkit.org>
  * 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 50 matching lines @@
     m_transform[5] = f;
 }
 
 bool AffineTransform::isIdentity() const
 {
     return (m_transform[0] == 1 && m_transform[1] == 0
          && m_transform[2] == 0 && m_transform[3] == 1
          && m_transform[4] == 0 && m_transform[5] == 0);
 }
 
+double AffineTransform::xScaleSquared() const
+{
+    return m_transform[0] * m_transform[0] + m_transform[1] * m_transform[1];

[pdr., 2016/06/15 12:15:17]

A little out of scope for this patch, just noting because it seems odd: wouldn't
xScale be m_transform[0] and yScale be m_transform[3]? I.e., no need to include
the sheer components? Squaring could also introduce an edge-case bug when the
scale value is negative.

[fs, 2016/06/15 22:10:33]

It's more like "x/y basis magnitude" than "x/y scale". This is what's being used
"downstream" in clients though. (And I think the shearing component will affect
non-scaling stroke?) Similarly for negative scales (== flips), since those won't
affect the size of the descendants.

+}
+
 double AffineTransform::xScale() const
 {
-    return sqrt(m_transform[0] * m_transform[0] + m_transform[1] * m_transform[1]);
+    return sqrt(xScaleSquared());
+}
+
+double AffineTransform::yScaleSquared() const
+{
+    return m_transform[2] * m_transform[2] + m_transform[3] * m_transform[3];
 }
 
 double AffineTransform::yScale() const
 {
-    return sqrt(m_transform[2] * m_transform[2] + m_transform[3] * m_transform[3]);
+    return sqrt(yScaleSquared());
 }
 
 double AffineTransform::det() const
 {
     return m_transform[0] * m_transform[3] - m_transform[1] * m_transform[2];
 }
 
 bool AffineTransform::isInvertible() const
 {
     return det() != 0.0;
@@ skipping 295 matching lines @@
     this->setB(decomp.remainderB);
     this->setC(decomp.remainderC);
     this->setD(decomp.remainderD);
     this->setE(decomp.translateX);
     this->setF(decomp.translateY);
     this->rotateRadians(decomp.angle);
     this->scale(decomp.scaleX, decomp.scaleY);
 }
 
 } // namespace blink