[GeometryInterface] Add setMatrixValue(transfromList) function.

third_party/WebKit/Source/core/dom/DOMMatrix.cpp

Index: third_party/WebKit/Source/core/dom/DOMMatrix.cpp
diff --git a/third_party/WebKit/Source/core/dom/DOMMatrix.cpp b/third_party/WebKit/Source/core/dom/DOMMatrix.cpp
index 966810654a5eed9950886b24b46a341f051a327b..d1b78b3410ba8ef084c8c8bb20b0975fb7a2b4c9 100644
--- a/third_party/WebKit/Source/core/dom/DOMMatrix.cpp
+++ b/third_party/WebKit/Source/core/dom/DOMMatrix.cpp
@@ -4,6 +4,14 @@
 
 #include "core/dom/DOMMatrix.h"
 
+#include "core/css/CSSIdentifierValue.h"
+#include "core/css/CSSToLengthConversionData.h"
+#include "core/css/CSSValueList.h"
+#include "core/css/parser/CSSParser.h"
+#include "core/css/resolver/TransformBuilder.h"
+#include "core/layout/api/LayoutViewItem.h"
+#include "core/style/ComputedStyle.h"
+
 namespace blink {
 
 DOMMatrix* DOMMatrix::create(ExceptionState& exceptionState) {
@@ -245,4 +253,61 @@ DOMMatrix* DOMMatrix::invertSelf() {
   return this;
 }
 
+DOMMatrix* DOMMatrix::setMatrixValue(const String& inputString,
+                                     ExceptionState& exceptionState) {
+  DEFINE_STATIC_LOCAL(String, identityMatrix2D, ("matrix(1, 0, 0, 1, 0, 0)"));
+  String string = inputString;
+  if (string.isEmpty())
+    string = identityMatrix2D;
+
+  const CSSValue* value =
+      CSSParser::parseSingleValue(CSSPropertyTransform, string);
+
+  if (!value) {
+    exceptionState.throwDOMException(SyntaxError,
+                                     "Failed to parse '" + inputString + "'.");
+    return nullptr;
+  }
+
+  if (value->isIdentifierValue()) {
+    if ((toCSSIdentifierValue(value))->getValueID() == CSSValueNone) {
+      m_matrix->makeIdentity();
+      m_is2D = true;
+      return this;
+    }
+  } else {
+    if (!value->isValueList()) {
+      exceptionState.throwDOMException(

[Timothy Loh, 2016/10/27 02:38:42]

Does this exception ever get thrown? From what I can tell parseSingleValue will
either return nullptr, none, or a list. This entire if-else chain I think would
be better as

if (value->isIdentifierValue()) {
  DCHECK(toCSSIdentifierValue(value)->getValueID() == CSSValueNone);
  m_matrix->makeIdentity();
  m_is2D = true;
  return this;
}

And below we don't need to check value->isValueList() because at that point we
will always have a CSSValueList.

In general I think it's useful to avoid having expressions which always evaluate
to the same value (with the exception of in DCHECKs). These sorts of expressions
lead to dead code or suggest that we can get into states which we actually can't
get into.

[Hwanseung Lee, 2016/10/27 16:24:48]

when we don't check value->isValueList(), it will be make assert when using
"initial" keyword.
(https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/css/resol...).
so i did not remove else statement. did you have good idea?
and i used && instead of DCHECK(). how do you think about it?

[Timothy Loh, 2016/10/28 02:50:04]

My point here is that in the code we should make it clear why and how we reach
these error cases. Seeing "if (!value->isValueList())" makes me wonder, are we
rejecting valid transform lists which somehow have a different type? So it'd be
clearer if we could instead check "if (value->isCSSWideKeyword())". Actually
it'd be better to just edit the above check "if (!value)" to be "if (!value ||
value->isCSSWideKeyword())" since we do the same thing in either case.
I prefer having the DCHECK because it more explicitly indicates that the only
CSSIdentifierValue we could have here is 'none'.

[Hwanseung Lee, 2016/10/28 12:17:58]

Done.

+          SyntaxError, "Failed to parse '" + inputString + "'.");
+      return nullptr;
+    }
+  }
+
+  if (value->isValueList() &&
+      TransformBuilder::hasRelativeLengths(toCSSValueList(*value))) {
+    exceptionState.throwDOMException(SyntaxError,
+                                     "Relative lengths not supported.");
+    return nullptr;
+  }
+
+  const ComputedStyle& initialStyle = ComputedStyle::initialStyle();
+  TransformOperations operations = TransformBuilder::createTransformOperations(
+      *value, CSSToLengthConversionData(&initialStyle, &initialStyle,
+                                        LayoutViewItem(nullptr), 1.0f));
+
+  if (operations.dependsOnBoxSize()) {
+    exceptionState.throwDOMException(SyntaxError,
+                                     "The transformation depends on the box "
+                                     "size, which is not supported.");
+    return nullptr;
+  }
+
+  m_matrix->makeIdentity();
+  operations.apply(FloatSize(0, 0), *m_matrix);
+
+  m_is2D = !operations.has3DOperation();
+
+  return this;
+}
+
 }  // namespace blink