Not for review - Rebase of crrev.com/62833003

Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 91 matching lines @@
 #include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "core/page/PointerLockController.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/compositing/RenderLayerCompositor.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "core/svg/SVGElement.h"
 #include "platform/EventDispatchForbiddenScope.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "platform/TraceEvent.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/scroll/ScrollableArea.h"
+#include "platform/transforms/MatrixTransformOperation.h"
+#include "public/platform/WebTeleportCallback.h"
 #include "wtf/BitVector.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/TextPosition.h"
 
 namespace blink {
 
+typedef WTF::HashMap<const Element*, OwnPtr<Vector<String> > > BoundAnimatedPropertyMap;
+static BoundAnimatedPropertyMap* gBoundAnimatedPropertyMap = 0;
+
 using namespace HTMLNames;
 using namespace XMLNames;
 
 typedef WillBeHeapVector<RefPtrWillBeMember<Attr> > AttrNodeList;
 
 static Attr* findAttrNodeInList(const AttrNodeList& attrNodeList, const QualifiedName& name)
 {
     for (const auto& attr : attrNodeList) {
         if (attr->qualifiedName() == name)
             return attr.get();
     }
     return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<Element> Element::create(const QualifiedName& tagName, Document* document)
 {
     return adoptRefWillBeNoop(new Element(tagName, document, CreateElement));
 }
 
 Element::Element(const QualifiedName& tagName, Document* document, ConstructionType type)
     : ContainerNode(document, type)
     , m_tagName(tagName)
 {
 }
 
 Element::~Element()
 {
     ASSERT(needsAttach());
+    if (gBoundAnimatedPropertyMap)
+        gBoundAnimatedPropertyMap->remove(this);
 
 #if !ENABLE(OILPAN)
     if (hasRareData())
         elementRareData()->clearShadow();
 
     if (isCustomElement())
         CustomElement::wasDestroyed(this);
 
     if (hasSyntheticAttrChildNodes())
         detachAllAttrNodesFromElement();
@@ skipping 2506 matching lines @@
     // top layer position, or in its usual place if not in the top layer.
     lazyReattachIfAttached();
 }
 
 void Element::requestPointerLock()
 {
     if (document().page())
         document().page()->pointerLockController().requestPointerLock(this);
 }
 
+String Element::bindAnimatedProperty(const String& propertyName, ExceptionState& exceptionState)
+{
+    static uint64_t nextBoundId = 1;
+    TRACE_EVENT0("teleport", "Element::bindAnimatedProperty");
+    if (propertyName != "transform" && propertyName != "opacity" && propertyName != "scrollTop" && propertyName != "pendingScrollDelta") {
+        exceptionState.throwTypeError("The given property, '" + propertyName + "' cannot be bound");
+        return "";
+    }
+
+    String token;
+    if (getBoundAnimatedProperty(propertyName, token))
+        return token;
+
+    if (!gBoundAnimatedPropertyMap)
+        gBoundAnimatedPropertyMap = new BoundAnimatedPropertyMap();
+
+    gBoundAnimatedPropertyMap->add(this, adoptPtr(new Vector<String>()));
+    token = String::number(WTF::intHash(nextBoundId++)) + ":" + propertyName;
+    gBoundAnimatedPropertyMap->get(this)->append(token);
+
+    setNeedsCompositingUpdate();
+
+    return token;
+}
+
+void Element::unbindAnimatedProperty(const String& propertyName, ExceptionState& exceptionState)
+{
+    TRACE_EVENT0("teleport", "Element::unbindAnimatedProperty");
+    String token;
+    if (!getBoundAnimatedProperty(propertyName, token)) {
+        exceptionState.throwTypeError("Cannot unbind a property that has not been bound.");
+        return;
+    }
+
+    Vector<String>& boundProperties = *gBoundAnimatedPropertyMap->get(this);
+    boundProperties.remove(boundProperties.find(token));
+    RenderBoxModelObject* renderer = renderBoxModelObject();
+    if (renderer && renderer->hasLayer())
+        renderer->layer()->unbindAnimatedProperties();
+
+    setNeedsCompositingUpdate();
+}
+
+void Element::updateBoundAnimatedPropertiesIfNeeded()
+{
+    if (!gBoundAnimatedPropertyMap)
+        return;
+
+    BoundAnimatedPropertyMap::const_iterator iter = gBoundAnimatedPropertyMap->begin();
+    for (; iter != gBoundAnimatedPropertyMap->end(); ++iter) {
+        RenderBoxModelObject* renderer = iter->key->renderBoxModelObject();
+        if (renderer && renderer->hasLayer())
+            renderer->layer()->bindAnimatedProperties(*iter->value);
+    }
+}
+
+void Element::applyToBoundAnimatedProperties(const WebVector<WebTeleportValue>& values)
+{
+    TRACE_EVENT0("teleport,teleport-backchannel", "Element::applyToBoundAnimatedProperties");
+
+    // FIXME: we need to store this stuff and apply it during style.
+    if (!gBoundAnimatedPropertyMap)
+        return;
+
+    BoundAnimatedPropertyMap::const_iterator iter = gBoundAnimatedPropertyMap->begin();
+    for (; iter != gBoundAnimatedPropertyMap->end(); ++iter) {
+        const Vector<String>& properties = *iter->value;
+        for (size_t i = 0; i < values.size(); ++i) {
+            const WebTeleportValue& value = values[i];
+            String id = value.id;
+            size_t j = properties.find(id);
+            if (j == kNotFound)
+                continue;
+
+            if (!iter->key->renderer())
+                continue;
+
+            RenderStyle* style = iter->key->renderer()->style();
+            if (!style)
+                continue;
+
+            RefPtr<RenderStyle> updated = RenderStyle::clone(style);
+
+            switch (value.type) {
+            case WebTeleportValue::ValueTypeTransform: {
+                TransformOperations operations;
+                operations.operations().append(MatrixTransformOperation::create(
+                    TransformationMatrix(
+                        value.value.matrix[0],
+                        value.value.matrix[4],
+                        value.value.matrix[8],
+                        value.value.matrix[12],
+                        value.value.matrix[1],
+                        value.value.matrix[5],
+                        value.value.matrix[9],
+                        value.value.matrix[13],
+                        value.value.matrix[2],
+                        value.value.matrix[6],
+                        value.value.matrix[10],
+                        value.value.matrix[14],
+                        value.value.matrix[3],
+                        value.value.matrix[7],
+                        value.value.matrix[11],
+                        value.value.matrix[15])));
+                updated->setTransform(operations);
+                break;
+            }
+            case WebTeleportValue::ValueTypeOpacity: {
+                updated->setOpacity(value.value.scalar);
+                break;
+            }
+            case WebTeleportValue::ValueTypeScrollTop: {
+                const_cast<Element*>(iter->key)->setScrollTop(static_cast<int>(value.value.scalar));
+                break;
+            }
+            case WebTeleportValue::ValueTypePendingScrollDelta: {
+                // const_cast<Element*>(iter->key)->setPendingScrollDelta(static_cast<int>(value.value.scalar));
+                // TODO
+                break;
+            }
+            case WebTeleportValue::ValueTypeTimestamp:
+            case WebTeleportValue::ValueTypeError:
+                break;
+            default:
+                RELEASE_ASSERT_NOT_REACHED();
+            }
+
+            iter->key->renderer()->setStyle(updated.release());
+        }
+    }
+}
+
+bool Element::getBoundAnimatedProperty(const String& propertyName, String& token) const
+{
+    if (!gBoundAnimatedPropertyMap)
+        return false;
+
+    BoundAnimatedPropertyMap::const_iterator iter = gBoundAnimatedPropertyMap->find(this);
+    if (iter == gBoundAnimatedPropertyMap->end())
+        return false;
+
+    Vector<String>& boundProperties = *iter->value;
+    for (size_t i = 0; i < boundProperties.size(); ++i) {
+        Vector<String> components;
+        boundProperties[i].split(":", components);
+        if (components[1] == propertyName) {
+            token = boundProperties[i];
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool Element::hasBoundAnimatedProperty() const
+{
+    return gBoundAnimatedPropertyMap && gBoundAnimatedPropertyMap->contains(this);
+}
+
 SpellcheckAttributeState Element::spellcheckAttributeState() const
 {
     const AtomicString& value = fastGetAttribute(spellcheckAttr);
     if (value == nullAtom)
         return SpellcheckAttributeDefault;
     if (equalIgnoringCase(value, "true") || equalIgnoringCase(value, ""))
         return SpellcheckAttributeTrue;
     if (equalIgnoringCase(value, "false"))
         return SpellcheckAttributeFalse;
 
@@ skipping 580 matching lines @@
         return wrapper;
 
     CustomElementBinding* binding = perContextData->customElementBinding(customElementDefinition());
 
     wrapper->SetPrototype(binding->prototype());
 
     return V8DOMWrapper::associateObjectWithWrapperNonTemplate(this, wrapperType, wrapper, isolate);
 }
 
 } // namespace blink