[GeometryInferface] add Constructor(DOMString transformList).

third_party/WebKit/Source/core/dom/DOMMatrixReadOnly.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/DOMMatrixReadOnly.h"
 
 #include "bindings/core/v8/V8ObjectBuilder.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/dom/DOMMatrix.h"
 #include "core/dom/DOMMatrixInit.h"
 #include "core/dom/DOMPoint.h"
 #include "core/dom/DOMPointInit.h"
+#include "core/layout/api/LayoutViewItem.h"
+#include "core/style/ComputedStyle.h"
 
 namespace blink {
 namespace {
 
 void setDictionaryMembers(DOMMatrixInit& other) {
   if (!other.hasM11())
     other.setM11(other.hasA() ? other.a() : 1);
 
   if (!other.hasM12())
     other.setM12(other.hasB() ? other.b() : 0);
@@ skipping 60 matching lines @@
                   other.m33() != 1 || other.m44() != 1);
     other.setIs2D(is2D);
   }
   return true;
 }
 
 DOMMatrixReadOnly* DOMMatrixReadOnly::create(ExceptionState& exceptionState) {
   return new DOMMatrixReadOnly(TransformationMatrix());
 }
 
+DOMMatrixReadOnly* DOMMatrixReadOnly::create(const String& transformList,
+                                             ExceptionState& exceptionState) {
+  return new DOMMatrixReadOnly(transformList, exceptionState);
+}
+
 DOMMatrixReadOnly* DOMMatrixReadOnly::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 DOMMatrixReadOnly(sequence, sequence.size());
 }
@@ skipping 144 matching lines @@
              point.w() * m41();
   double y = point.x() * m12() + point.y() * m22() + point.z() * m32() +
              point.w() * m42();
   double z = point.x() * m13() + point.y() * m23() + point.z() * m33() +
              point.w() * m43();
   double w = point.x() * m14() + point.y() * m24() + point.z() * m34() +
              point.w() * m44();
   return DOMPoint::create(x, y, z, w);
 }
 
+DOMMatrixReadOnly::DOMMatrixReadOnly(const String& inputString,
+                                     ExceptionState& exceptionState) {
+  m_matrix = TransformationMatrix::create();
+  setMatrixValue(inputString, exceptionState);
+}
+
 DOMMatrixReadOnly::DOMMatrixReadOnly(const TransformationMatrix& matrix,
                                      bool is2D) {
   m_matrix = TransformationMatrix::create(matrix);
   m_is2D = is2D;
 }
 
 DOMFloat32Array* DOMMatrixReadOnly::toFloat32Array() const {
   float array[] = {
       static_cast<float>(m_matrix->m11()), static_cast<float>(m_matrix->m12()),
       static_cast<float>(m_matrix->m13()), static_cast<float>(m_matrix->m14()),
@@ skipping 57 matching lines @@
   result.addNumber("m34", m34());
   result.addNumber("m41", m41());
   result.addNumber("m42", m42());
   result.addNumber("m43", m43());
   result.addNumber("m44", m44());
   result.addBoolean("is2D", is2D());
   result.addBoolean("isIdentity", isIdentity());
   return result.scriptValue();
 }
 
+DOMMatrixReadOnly* DOMMatrixReadOnly::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();
+
+  return this;
+}
+
 }  // namespace blink