Move <marquee> implementation to HTMLMarqueeElement.cpp

third_party/WebKit/Source/core/html/HTMLMarqueeElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2007, 2010 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "core/html/HTMLMarqueeElement.h"
 
-#include "bindings/core/v8/PrivateScriptRunner.h"
+#include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "bindings/core/v8/V8HTMLMarqueeElement.h"
+#include "core/CSSPropertyNames.h"
 #include "core/HTMLNames.h"
+#include "core/animation/DocumentTimeline.h"
+#include "core/animation/KeyframeEffect.h"
+#include "core/animation/KeyframeEffectModel.h"
+#include "core/animation/KeyframeEffectOptions.h"
+#include "core/animation/StringKeyframe.h"
+#include "core/animation/TimingInput.h"
+#include "core/css/CSSStyleDeclaration.h"
+#include "core/css/StylePropertySet.h"
 #include "core/dom/Document.h"
+#include "core/dom/shadow/ShadowRoot.h"
+#include "core/frame/LocalDOMWindow.h"
 #include "core/frame/UseCounter.h"
-#include "platform/ScriptForbiddenScope.h"
+#include "core/html/HTMLContentElement.h"
+#include "core/html/HTMLDimension.h"
+#include "core/html/HTMLDivElement.h"
+#include "core/html/HTMLStyleElement.h"
+#include <cstdlib>
 
 namespace blink {
 
+namespace {
+
+String convertHTMLLengthToCSSLength(const String& htmlLength) {
+  HTMLDimension dimension;
+  parseDimensionValue(htmlLength, dimension);
+  if (dimension.isRelative())
+    return String();
+  CSSPrimitiveValue* cssValue = CSSPrimitiveValue::create(
+      dimension.value(), dimension.isPercentage()
+                             ? CSSPrimitiveValue::UnitType::Percentage
+                             : CSSPrimitiveValue::UnitType::Pixels);
+  return cssValue->customCSSText();
+}
+
+}  // namespace
+
 inline HTMLMarqueeElement::HTMLMarqueeElement(Document& document)
     : HTMLElement(HTMLNames::marqueeTag, document) {
-  if (document.contextDocument()) {
-    ScriptForbiddenScope::AllowUserAgentScript script;
-    v8::Local<v8::Value> classObject =
-        PrivateScriptRunner::installClassIfNeeded(&document,
-                                                  "HTMLMarqueeElement");
-    RELEASE_ASSERT(!classObject.IsEmpty());
-  }
   UseCounter::count(document, UseCounter::HTMLMarqueeElement);
+  ShadowRoot* shadow =
+      createShadowRootInternal(ShadowRootType::V0, ASSERT_NO_EXCEPTION);
+  Element* style = HTMLStyleElement::create(document, false);
+  style->setTextContent(
+      ":host { display: inline-block; width: -webkit-fill-available; overflow: "
+      "hidden; text-align: initial; white-space: nowrap; }"
+      ":host([direction=\"up\"]), :host([direction=\"down\"]) { overflow: "
+      "initial; overflow-y: hidden; white-space: initial; }"
+      ":host > div { will-change: transform; }");
+  shadow->appendChild(style);
+
+  Element* mover = HTMLDivElement::create(document);
+  shadow->appendChild(mover);
+
+  mover->appendChild(HTMLContentElement::create(document));
+  m_mover = mover;
 }
 
 HTMLMarqueeElement* HTMLMarqueeElement::create(Document& document) {
-  HTMLMarqueeElement* marqueeElement = new HTMLMarqueeElement(document);
-  V8HTMLMarqueeElement::PrivateScript::createdCallbackMethod(document.frame(),
-                                                             marqueeElement);
-  return marqueeElement;
+  return new HTMLMarqueeElement(document);
 }
 
 void HTMLMarqueeElement::attributeChanged(const QualifiedName& name,

[tkent, 2016/12/06 22:43:11]

Overriding attributeChanged looks weird.  Doesn't parseAttribute() work?

[esprehn, 2016/12/07 00:10:00]

Yes see the discussion for follow up patches

                                           const AtomicString& oldValue,
                                           const AtomicString& newValue,
                                           AttributeModificationReason reason) {
   HTMLElement::attributeChanged(name, oldValue, newValue, reason);
-  V8HTMLMarqueeElement::PrivateScript::attributeChangedCallbackMethod(
-      document().frame(), this, name.toString(), oldValue, newValue);
+  attributeChangedCallback(name, newValue);
 }
 
 Node::InsertionNotificationRequest HTMLMarqueeElement::insertedInto(
     ContainerNode* insertionPoint) {
   HTMLElement::insertedInto(insertionPoint);
+
   if (isConnected()) {
-    V8HTMLMarqueeElement::PrivateScript::attachedCallbackMethod(
-        document().frame(), this);
-  }
+    static const QualifiedName* presentationalAttributes[] = {
+        &HTMLNames::bgcolorAttr, &HTMLNames::heightAttr, &HTMLNames::hspaceAttr,
+        &HTMLNames::vspaceAttr, &HTMLNames::widthAttr};
+    for (const auto* attr : presentationalAttributes) {
+      const AtomicString& value = getAttribute(*attr);

[tkent, 2016/12/06 22:43:11]

getAttribute -> fastGetAttribute

[esprehn, 2016/12/07 00:10:00]

We were trying to avoid using private hooks that authors wouldn't have access
to, but yeah the rest of the DOM C++ uses this.

+      if (value.isNull())
+        continue;
+      attributeChangedCallback(*attr, value);
+    }
+
+    start();
+  }
+
   return InsertionDone;
 }
 
 void HTMLMarqueeElement::removedFrom(ContainerNode* insertionPoint) {
   HTMLElement::removedFrom(insertionPoint);
   if (insertionPoint->isConnected()) {
-    V8HTMLMarqueeElement::PrivateScript::detachedCallbackMethod(
-        insertionPoint->document().frame(), this);
+    stop();
   }
 }
 
 bool HTMLMarqueeElement::isHorizontal() const {
-  AtomicString direction = getAttribute(HTMLNames::directionAttr);
-  return direction != "down" && direction != "up";
+  Direction direction = this->direction();
+  return direction != Up && direction != Down;
+}
+
+int HTMLMarqueeElement::scrollAmount() const {
+  bool ok;
+  int scrollAmount = getAttribute(HTMLNames::scrollamountAttr).toInt(&ok);

[tkent, 2016/12/06 22:43:11]

Please do not use AtomicString::toInt().  It isn't compatible with the HTML
standard, and has an integer-overflow bug.  We should use parseHTMLInteger().

Probably we should introduce Element::getUnsignedIntegralAttribute(const
QualifiedName&, int fallbackValue).

[esprehn, 2016/12/07 00:10:00]

Please fix the toInt() to not have an overflow. :)

[adithyas, 2016/12/08 15:12:11]

I'm not really sure about the overflow bug, I couldn't reproduce it (assuming
this is the bug you're talking about: http://crbug.com/666681). Also
parseHTMLInteger doesn't work in this scenario because there's no way of knowing
if the actual user input was NaN (in which case, the default value should be
returned instead of 0).

+  if (!ok || scrollAmount < 0)
+    return kDefaultScrollAmount;
+  return scrollAmount;
+}
+
+void HTMLMarqueeElement::setScrollAmount(int value,
+                                         ExceptionState& exceptionState) {
+  if (value < 0) {
+    exceptionState.throwDOMException(
+        IndexSizeError,
+        "The provided value (" + String::number(value) + ") is negative.");
+    return;
+  }
+  setIntegralAttribute(HTMLNames::scrollamountAttr, value);
+}
+
+int HTMLMarqueeElement::scrollDelay() const {
+  bool ok;
+  int scrollDelay = getAttribute(HTMLNames::scrolldelayAttr).toInt(&ok);
+  if (!ok || scrollDelay < 0)
+    return kDefaultScrollDelayMS;
+  return scrollDelay;
+}
+
+void HTMLMarqueeElement::setScrollDelay(int value,
+                                        ExceptionState& exceptionState) {
+  if (value < 0) {
+    exceptionState.throwDOMException(
+        IndexSizeError,
+        "The provided value (" + String::number(value) + ") is negative.");
+    return;
+  }
+  setIntegralAttribute(HTMLNames::scrolldelayAttr, value);
+}
+
+int HTMLMarqueeElement::loop() const {
+  bool ok;
+  int loop = getAttribute(HTMLNames::loopAttr).toInt(&ok);
+  if (!ok || loop <= 0)
+    return kDefaultLoopLimit;
+  return loop;
+}
+
+void HTMLMarqueeElement::setLoop(int value, ExceptionState& exceptionState) {
+  if (value <= 0 && value != -1) {
+    exceptionState.throwDOMException(
+        IndexSizeError, "The provided value (" + String::number(value) +
+                            ") is neither positive nor -1.");
+    return;
+  }
+  setIntegralAttribute(HTMLNames::loopAttr, value);
+}
+
+void HTMLMarqueeElement::start() {
+  if (m_continueCallbackRequestId)
+    return;
+
+  RequestAnimationFrameCallback* callback =
+      new RequestAnimationFrameCallback(this);
+  m_continueCallbackRequestId = document().requestAnimationFrame(callback);
+}
+
+void HTMLMarqueeElement::stop() {
+  if (m_continueCallbackRequestId) {
+    document().cancelAnimationFrame(m_continueCallbackRequestId);
+    m_continueCallbackRequestId = 0;
+    return;
+  }
+
+  if (m_player)
+    m_player->pause();
+}
+
+void HTMLMarqueeElement::attributeChangedCallback(const QualifiedName& attr,
+                                                  const String& newValue) {
+  if (attr == HTMLNames::bgcolorAttr) {
+    style()->setProperty("background-color", newValue, String(),
+                         ASSERT_NO_EXCEPTION);
+  } else if (attr == HTMLNames::heightAttr) {
+    style()->setProperty("height", convertHTMLLengthToCSSLength(newValue),
+                         String(), ASSERT_NO_EXCEPTION);
+  } else if (attr == HTMLNames::hspaceAttr) {
+    style()->setProperty("margin-left", convertHTMLLengthToCSSLength(newValue),
+                         String(), ASSERT_NO_EXCEPTION);
+    style()->setProperty("margin-right", convertHTMLLengthToCSSLength(newValue),
+                         String(), ASSERT_NO_EXCEPTION);
+  } else if (attr == HTMLNames::vspaceAttr) {
+    style()->setProperty("margin-top", convertHTMLLengthToCSSLength(newValue),
+                         String(), ASSERT_NO_EXCEPTION);
+    style()->setProperty("margin-bottom",
+                         convertHTMLLengthToCSSLength(newValue), String(),
+                         ASSERT_NO_EXCEPTION);
+  } else if (attr == HTMLNames::widthAttr) {
+    style()->setProperty("width", convertHTMLLengthToCSSLength(newValue),
+                         String(), ASSERT_NO_EXCEPTION);
+  }
+}
+
+void HTMLMarqueeElement::RequestAnimationFrameCallback::handleEvent(double) {
+  m_marquee->m_continueCallbackRequestId = 0;
+  m_marquee->continueAnimation();
+}
+
+void HTMLMarqueeElement::AnimationFinished::handleEvent(
+    ExecutionContext* context,
+    Event* event) {
+  ++m_marquee->m_loopCount;
+  m_marquee->start();
+}
+
+StringKeyframeEffectModel* HTMLMarqueeElement::createEffectModel(
+    AnimationParameters& parameters) {

[tkent, 2016/12/06 22:43:11]

The argument type should be |const AnimationParameters&|.

+  StyleSheetContents* styleSheetContents =
+      m_mover->document().elementSheet().contents();
+  MutableStylePropertySet::SetResult setResult;
+
+  RefPtr<StringKeyframe> keyframe1 = StringKeyframe::create();
+  setResult = keyframe1->setCSSPropertyValue(
+      CSSPropertyTransform, parameters.transformBegin, styleSheetContents);
+  DCHECK(setResult.didParse);
+
+  RefPtr<StringKeyframe> keyframe2 = StringKeyframe::create();
+  setResult = keyframe2->setCSSPropertyValue(
+      CSSPropertyTransform, parameters.transformEnd, styleSheetContents);
+  DCHECK(setResult.didParse);
+
+  return StringKeyframeEffectModel::create(
+      {std::move(keyframe1), std::move(keyframe2)},
+      LinearTimingFunction::shared());
+}
+
+void HTMLMarqueeElement::continueAnimation() {
+  if (!shouldContinue())
+    return;
+
+  if (m_player && m_player->playState() == "paused") {
+    m_player->play();
+    return;
+  }
+
+  AnimationParameters parameters = getAnimationParameters();
+  int scrollDelay = this->scrollDelay();
+  int scrollAmount = this->scrollAmount();
+
+  if (scrollDelay < kMinimumScrollDelayMS && !trueSpeed())
+    scrollDelay = kDefaultScrollDelayMS;
+  double duration = 0;
+  if (scrollAmount)
+    duration = parameters.distance * scrollDelay / scrollAmount;
+  if (!duration)
+    return;
+
+  StringKeyframeEffectModel* effectModel = createEffectModel(parameters);
+  Timing timing;
+  timing.fillMode = Timing::FillMode::FORWARDS;
+  TimingInput::setIterationDuration(
+      timing, UnrestrictedDoubleOrString::fromUnrestrictedDouble(duration),
+      ASSERT_NO_EXCEPTION);
+
+  KeyframeEffect* keyframeEffect =
+      KeyframeEffect::create(m_mover, effectModel, timing);
+  Animation* player = m_mover->document().timeline().play(keyframeEffect);
+  player->setId(emptyString());
+  player->setOnfinish(new AnimationFinished(this));
+
+  m_player = player;
+}
+
+bool HTMLMarqueeElement::shouldContinue() {
+  int loopCount = loop();
+
+  // By default, slide loops only once.
+  if (loopCount <= 0 && behavior() == Slide)
+    loopCount = 1;
+
+  if (loopCount <= 0)
+    return true;
+  return m_loopCount < loopCount;
+}
+
+HTMLMarqueeElement::Behavior HTMLMarqueeElement::behavior() const {
+  const AtomicString& behavior = getAttribute(HTMLNames::behaviorAttr);
+  if (behavior == "alternate")

[tkent, 2016/12/06 22:43:11]

Should it be case-sensitive match?

[adithyas, 2016/12/08 15:12:11]

Nope, this is a bug, thanks for catching it.

+    return Alternate;
+  if (behavior == "slide")
+    return Slide;
+  return Scroll;
+}
+
+HTMLMarqueeElement::Direction HTMLMarqueeElement::direction() const {
+  const AtomicString& direction = getAttribute(HTMLNames::directionAttr);
+  if (direction == "down")
+    return Down;
+  if (direction == "up")
+    return Up;
+  if (direction == "right")
+    return Right;
+  return Left;
+}
+
+bool HTMLMarqueeElement::trueSpeed() const {
+  return hasAttribute(HTMLNames::truespeedAttr);

[tkent, 2016/12/06 22:43:11]

hasAttribute -> fastHasAttribute

+}
+
+HTMLMarqueeElement::Metrics HTMLMarqueeElement::getMetrics() {
+  Metrics metrics;
+  CSSStyleDeclaration* marqueeStyle =
+      document().domWindow()->getComputedStyle(this, String());
+  // For marquees that are declared inline, getComputedStyle returns "auto" for
+  // width and height. Setting all the metrics to zero disables animation for
+  // inline marquees.
+  if (marqueeStyle->getPropertyValue("width") == "auto" &&
+      marqueeStyle->getPropertyValue("height") == "auto") {
+    metrics.contentHeight = 0;
+    metrics.contentWidth = 0;
+    metrics.marqueeWidth = 0;
+    metrics.marqueeHeight = 0;
+    return metrics;
+  }
+
+  if (isHorizontal()) {
+    m_mover->style()->setProperty("width", "-webkit-max-content", "important",
+                                  ASSERT_NO_EXCEPTION);
+  } else {
+    m_mover->style()->setProperty("height", "-webkit-max-content", "important",
+                                  ASSERT_NO_EXCEPTION);
+  }
+  CSSStyleDeclaration* moverStyle =
+      document().domWindow()->getComputedStyle(m_mover, String());
+
+  metrics.contentWidth = moverStyle->getPropertyValue("width").toDouble();
+  metrics.contentHeight = moverStyle->getPropertyValue("height").toDouble();
+  metrics.marqueeWidth = marqueeStyle->getPropertyValue("width").toDouble();
+  metrics.marqueeHeight = marqueeStyle->getPropertyValue("height").toDouble();
+
+  if (isHorizontal()) {
+    m_mover->style()->setProperty("width", "", "important",
+                                  ASSERT_NO_EXCEPTION);
+  } else {
+    m_mover->style()->setProperty("height", "", "important",
+                                  ASSERT_NO_EXCEPTION);
+  }
+
+  return metrics;
+}
+
+HTMLMarqueeElement::AnimationParameters
+HTMLMarqueeElement::getAnimationParameters() {
+  AnimationParameters parameters;
+  Metrics metrics = getMetrics();
+
+  double totalWidth = metrics.marqueeWidth + metrics.contentWidth;
+  double totalHeight = metrics.marqueeHeight + metrics.contentHeight;
+
+  double innerWidth = metrics.marqueeWidth - metrics.contentWidth;
+  double innerHeight = metrics.marqueeHeight - metrics.contentHeight;
+
+  switch (behavior()) {
+    case Alternate:
+      switch (direction()) {
+        case Right:
+          parameters.transformBegin =
+              createTransform(innerWidth >= 0 ? 0 : innerWidth);
+          parameters.transformEnd =
+              createTransform(innerWidth >= 0 ? innerWidth : 0);
+          parameters.distance = std::abs(innerWidth);
+          break;
+        case Up:
+          parameters.transformBegin =
+              createTransform(innerHeight >= 0 ? innerHeight : 0);
+          parameters.transformEnd =
+              createTransform(innerHeight >= 0 ? 0 : innerHeight);
+          parameters.distance = std::abs(innerHeight);
+          break;
+        case Down:
+          parameters.transformBegin =
+              createTransform(innerHeight >= 0 ? 0 : innerHeight);
+          parameters.transformEnd =
+              createTransform(innerHeight >= 0 ? innerHeight : 0);
+          parameters.distance = std::abs(innerHeight);
+          break;
+        case Left:
+        default:
+          parameters.transformBegin =
+              createTransform(innerWidth >= 0 ? innerWidth : 0);
+          parameters.transformEnd =
+              createTransform(innerWidth >= 0 ? 0 : innerWidth);
+          parameters.distance = std::abs(innerWidth);
+      }
+
+      if (m_loopCount % 2)
+        std::swap(parameters.transformBegin, parameters.transformEnd);
+      break;
+    case Slide:
+      switch (direction()) {
+        case Right:
+          parameters.transformBegin = createTransform(-metrics.contentWidth);
+          parameters.transformEnd = createTransform(innerWidth);
+          parameters.distance = metrics.marqueeWidth;
+          break;
+        case Up:
+          parameters.transformBegin = createTransform(metrics.marqueeHeight);
+          parameters.transformEnd = "translateY(0)";
+          parameters.distance = metrics.marqueeHeight;
+          break;
+        case Down:
+          parameters.transformBegin = createTransform(-metrics.contentHeight);
+          parameters.transformEnd = createTransform(innerHeight);
+          parameters.distance = metrics.marqueeHeight;
+          break;
+        case Left:
+        default:
+          parameters.transformBegin = createTransform(metrics.marqueeWidth);
+          parameters.transformEnd = "translateX(0)";
+          parameters.distance = metrics.marqueeWidth;
+      }
+      break;
+    case Scroll:
+    default:
+      switch (direction()) {
+        case Right:
+          parameters.transformBegin = createTransform(-metrics.contentWidth);
+          parameters.transformEnd = createTransform(metrics.marqueeWidth);
+          parameters.distance = totalWidth;
+          break;
+        case Up:
+          parameters.transformBegin = createTransform(metrics.marqueeHeight);
+          parameters.transformEnd = createTransform(-metrics.contentHeight);
+          parameters.distance = totalHeight;
+          break;
+        case Down:
+          parameters.transformBegin = createTransform(-metrics.contentHeight);
+          parameters.transformEnd = createTransform(metrics.marqueeHeight);
+          parameters.distance = totalHeight;
+          break;
+        case Left:
+        default:
+          parameters.transformBegin = createTransform(metrics.marqueeWidth);
+          parameters.transformEnd = createTransform(-metrics.contentWidth);
+          parameters.distance = totalWidth;
+      }
+      break;
+  }
+
+  return parameters;
+}
+
+AtomicString HTMLMarqueeElement::createTransform(double value) const {
+  char axis = isHorizontal() ? 'X' : 'Y';
+  return AtomicString(String::format("translate%c(%fpx)", axis, value));

[tkent, 2016/12/06 22:43:11]

Does this work in French locale, which use ',' for decimal point?

[adithyas, 2016/12/08 15:12:11]

I don't think it does, thanks for pointing this out.

+}
+
+DEFINE_TRACE(HTMLMarqueeElement) {
+  visitor->trace(m_mover);
+  visitor->trace(m_player);
+  HTMLElement::trace(visitor);
 }
 
 }  // namespace blink