[GeometryInterface] Add setMatrixValue(transfromList) function.

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

 // Copyright 2014 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 "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) {
   return new DOMMatrix(TransformationMatrix());
 }
 
 DOMMatrix* DOMMatrix::create(DOMMatrixReadOnly* other,
                              ExceptionState& exceptionState) {
   return new DOMMatrix(other->matrix(), other->is2D());
 }
@@ skipping 221 matching lines @@
 DOMMatrix* DOMMatrix::invertSelf() {
   if (m_matrix->isInvertible()) {
     m_matrix = TransformationMatrix::create(m_matrix->inverse());
   } else {
     setNAN();
     setIs2D(false);
   }
   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