[GeometryInferface] add Constructor(DOMString transformList).

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());
 }
 
 DOMMatrix* DOMMatrix::create(const SkMatrix44& matrix,
                              ExceptionState& exceptionState) {
   TransformationMatrix transformationMatrix(matrix);
   return new DOMMatrix(transformationMatrix, transformationMatrix.isAffine());
 }
 
+DOMMatrix* DOMMatrix::create(const String& transformList,
+                             ExceptionState& exceptionState) {
+  return new DOMMatrix(transformList, exceptionState);
+}
+
 DOMMatrix* DOMMatrix::create(Vector<double> sequence,
                              ExceptionState& exceptionState) {
   if (sequence.size() != 6 && sequence.size() != 16) {
     exceptionState.throwTypeError(
         "The sequence must contain 6 elements for a 2D matrix or 16 elements "
         "for a 3D matrix.");
     return nullptr;
   }
   return new DOMMatrix(sequence, sequence.size());
 }
@@ skipping 13 matching lines @@
                                        ExceptionState& exceptionState) {
   if (float64Array->length() != 6 && float64Array->length() != 16) {
     exceptionState.throwTypeError(
         "The sequence must contain 6 elements for a 2D matrix or 16 elements "
         "for a 3D matrix.");
     return nullptr;
   }
   return new DOMMatrix(float64Array->data(), float64Array->length());
 }
 
+DOMMatrix::DOMMatrix(const String& transformList,
+                     ExceptionState& exceptionState)
+    : DOMMatrixReadOnly(transformList, exceptionState) {}
+
 template <typename T>
 DOMMatrix::DOMMatrix(T sequence, int size)
     : DOMMatrixReadOnly(sequence, size) {}
 
 DOMMatrix::DOMMatrix(const TransformationMatrix& matrix, bool is2D)
     : DOMMatrixReadOnly(matrix, is2D) {}
 
 DOMMatrix* DOMMatrix::fromMatrix(DOMMatrixInit& other,
                                  ExceptionState& exceptionState) {
   if (!validateAndFixup(other, exceptionState)) {
@@ skipping 179 matching lines @@
     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 || value->isCSSWideKeyword()) {
-    exceptionState.throwDOMException(SyntaxError,
-                                     "Failed to parse '" + inputString + "'.");
-    return nullptr;
-  }
-
-  if (value->isIdentifierValue()) {
-    DCHECK(toCSSIdentifierValue(value)->getValueID() == CSSValueNone);
-    m_matrix->makeIdentity();
-    m_is2D = true;
-    return this;
-  }
-
-  if (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();
-
+  DOMMatrixReadOnly::setMatrixValueInternal(inputString, exceptionState);
   return this;
 }
 
 }  // namespace blink