Changeset 243304 in webkit

Timestamp:

Mar 21, 2019, 11:33:11 AM (7 years ago)

Author:

Alan Bujtas

Message:

[ContentChangeObserver] Add support for observing implicit transitions
​https://bugs.webkit.org/show_bug.cgi?id=195914
<rdar://problem/49091959>

Reviewed by Simon Fraser.

This patch is in preparation for observing elements with property "left" implicit transitions.

This is not a continuous tracking, we are only interested in the start and the end state.
The idea here is to register hidden elements only and check if they become visible by
the end of the transition (and ignore if the transition gets "canceled").

• page/animation/AnimationBase.h:
• page/animation/ImplicitAnimation.cpp:

(WebCore::ImplicitAnimation::ImplicitAnimation):
(WebCore::ImplicitAnimation::~ImplicitAnimation):
(WebCore::ImplicitAnimation::clear):
(WebCore::ImplicitAnimation::onAnimationEnd):

• page/animation/ImplicitAnimation.h:
• page/ios/ContentChangeObserver.cpp:

(WebCore::ContentChangeObserver::didAddTransition):
(WebCore::ContentChangeObserver::removeTransitionIfNeeded):
(WebCore::ContentChangeObserver::didFinishTransition):
(WebCore::ContentChangeObserver::didRemoveTransition):
(WebCore::ContentChangeObserver::didInstallDOMTimer):

• page/ios/ContentChangeObserver.h:

(WebCore::ContentChangeObserver::isObservingTransitions const):
(WebCore::ContentChangeObserver::isObservedPropertyForTransition const):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• page/animation/AnimationBase.h (modified) (1 diff)
• page/animation/ImplicitAnimation.cpp (modified) (5 diffs)
• page/animation/ImplicitAnimation.h (modified) (1 diff)
• page/ios/ContentChangeObserver.cpp (modified) (3 diffs)
• page/ios/ContentChangeObserver.h (modified) (5 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2019-03-21  Zalan Bujtas  <zalan@apple.com>
+
+        [ContentChangeObserver] Add support for observing implicit transitions
+        https://bugs.webkit.org/show_bug.cgi?id=195914
+        <rdar://problem/49091959>
+
+        Reviewed by Simon Fraser.
+
+        This patch is in preparation for observing elements with property "left" implicit transitions.
+
+        This is not a continuous tracking, we are only interested in the start and the end state.
+        The idea here is to register hidden elements only and check if they become visible by
+        the end of the transition (and ignore if the transition gets "canceled").
+
+        * page/animation/AnimationBase.h:
+        * page/animation/ImplicitAnimation.cpp:
+        (WebCore::ImplicitAnimation::ImplicitAnimation):
+        (WebCore::ImplicitAnimation::~ImplicitAnimation):
+        (WebCore::ImplicitAnimation::clear):
+        (WebCore::ImplicitAnimation::onAnimationEnd):
+        * page/animation/ImplicitAnimation.h:
+        * page/ios/ContentChangeObserver.cpp:
+        (WebCore::ContentChangeObserver::didAddTransition):
+        (WebCore::ContentChangeObserver::removeTransitionIfNeeded):
+        (WebCore::ContentChangeObserver::didFinishTransition):
+        (WebCore::ContentChangeObserver::didRemoveTransition):
+        (WebCore::ContentChangeObserver::didInstallDOMTimer):
+        * page/ios/ContentChangeObserver.h:
+        (WebCore::ContentChangeObserver::isObservingTransitions const):
+        (WebCore::ContentChangeObserver::isObservedPropertyForTransition const):
+
 2019-03-21  Devin Rousso  <drousso@apple.com>
 

trunk/Source/WebCore/page/animation/AnimationBase.h

@@ -62 +62 @@
     const RenderStyle& currentStyle() const override;
     RenderElement* renderer() const override;
-    void clear();
+    virtual void clear();
 
     double duration() const;

trunk/Source/WebCore/page/animation/ImplicitAnimation.cpp

@@ -33 +33 @@
 #include "CSSPropertyAnimation.h"
 #include "CompositeAnimation.h"
+#if PLATFORM(IOS_FAMILY)
+#include "ContentChangeObserver.h"
+#endif
 #include "EventNames.h"
 #include "GeometryUtilities.h"
@@ -47 +50 @@
     , m_animatingProperty(animatingProperty)
 {
+#if PLATFORM(IOS_FAMILY)
+    element.document().contentChangeObserver().didAddTransition(element, transition);
+#endif
     ASSERT(animatingProperty != CSSPropertyInvalid);
 }
@@ -52 +58 @@
 ImplicitAnimation::~ImplicitAnimation()
 {
+#if PLATFORM(IOS_FAMILY)
+    if (auto* element = this->element())
+        element->document().contentChangeObserver().didRemoveTransition(*element, m_animatingProperty);
+#endif
     // // Make sure to tell the renderer that we are ending. This will make sure any accelerated animations are removed.
     if (!postActive())
@@ -159 +169 @@
 }
 
+void ImplicitAnimation::clear()
+{
+#if PLATFORM(IOS_FAMILY)
+    if (auto* element = this->element())
+        element->document().contentChangeObserver().didRemoveTransition(*element, m_animatingProperty);
+#endif
+    AnimationBase::clear();
+}
+
 void ImplicitAnimation::endAnimation(bool)
 {
@@ -167 +186 @@
 void ImplicitAnimation::onAnimationEnd(double elapsedTime)
 {
+#if PLATFORM(IOS_FAMILY)
+    if (auto* element = this->element())
+        element->document().contentChangeObserver().didFinishTransition(*element, m_animatingProperty);
+#endif
     // If we have a keyframe animation on this property, this transition is being overridden. The keyframe
     // animation keeps an unanimated style in case a transition starts while the keyframe animation is

trunk/Source/WebCore/page/animation/ImplicitAnimation.h

@@ -80 +80 @@
     const RenderStyle& unanimatedStyle() const override { return *m_fromStyle; }
 
+    void clear() override;
+
 protected:
     bool shouldSendEventForListener(Document::ListenerType) const;    

trunk/Source/WebCore/page/ios/ContentChangeObserver.cpp

@@ -40 +40 @@
 namespace WebCore {
 
+static const Seconds maximumDelayForTimers { 300_ms };
+static const Seconds maximumDelayForTransitions { 300_ms };
+
 ContentChangeObserver::ContentChangeObserver(Document& document)
     : m_document(document)
@@ -82 +85 @@
 }
 
+void ContentChangeObserver::didAddTransition(const Element& element, const Animation& transition)
+{
+    if (!m_document.settings().contentChangeObserverEnabled())
+        return;
+    if (hasVisibleChangeState())
+        return;
+    if (!isObservingTransitions())
+        return;
+    if (!transition.isDurationSet() || !transition.isPropertySet())
+        return;
+    if (!isObservedPropertyForTransition(transition.property()))
+        return;
+    auto transitionEnd = Seconds { transition.duration() + std::max<double>(0, transition.isDelaySet() ? transition.delay() : 0) };
+    if (transitionEnd > maximumDelayForTransitions)
+        return;
+    LOG_WITH_STREAM(ContentObservation, stream << "didAddTransition: transition created on " << &element << " (" << transitionEnd.milliseconds() << "ms).");
+
+    m_elementsWithTransition.add(&element);
+    // FIXME: report state change.
+}
+
+void ContentChangeObserver::didFinishTransition(const Element& element, CSSPropertyID propertyID)
+{
+    if (!isObservedPropertyForTransition(propertyID))
+        return;
+    if (!m_elementsWithTransition.take(&element))
+        return;
+    LOG_WITH_STREAM(ContentObservation, stream << "didFinishTransition: transition finished (" << &element << ").");
+    // FIXME: report state change.
+}
+
+void ContentChangeObserver::didRemoveTransition(const Element& element, CSSPropertyID propertyID)
+{
+    if (!isObservedPropertyForTransition(propertyID))
+        return;
+    if (!m_elementsWithTransition.take(&element))
+        return;
+    LOG_WITH_STREAM(ContentObservation, stream << "didRemoveTransition: transition got interrupted (" << &element << ").");
+    // FIXME: report state change.
+}
+
 void ContentChangeObserver::didInstallDOMTimer(const DOMTimer& timer, Seconds timeout, bool singleShot)
 {
@@ -88 +132 @@
     if (m_document.activeDOMObjectsAreSuspended())
         return;
-    if (timeout > 300_ms || !singleShot)
+    if (timeout > maximumDelayForTimers || !singleShot)
         return;
     if (!isObservingDOMTimerScheduling())

trunk/Source/WebCore/page/ios/ContentChangeObserver.h

@@ -31 +31 @@
 #include "Timer.h"
 #include "WKContentObservation.h"
+#include <wtf/HashSet.h>
 
 namespace WebCore {
 
+class Animation;
 class DOMTimer;
 class Document;
@@ -47 +49 @@
     void didInstallDOMTimer(const DOMTimer&, Seconds timeout, bool singleShot);
     void didRemoveDOMTimer(const DOMTimer&);
+
+    void didAddTransition(const Element&, const Animation&);
+    void didFinishTransition(const Element&, CSSPropertyID);
+    void didRemoveTransition(const Element&, CSSPropertyID);
+
     WEBCORE_EXPORT void willNotProceedWithClick();
     WEBCORE_EXPORT static void didRecognizeLongPress(Frame& mainFrame);
@@ -115 +122 @@
     void setShouldObserveDOMTimerScheduling(bool observe) { m_isObservingDOMTimerScheduling = observe; }
     bool isObservingDOMTimerScheduling() const { return m_isObservingDOMTimerScheduling; }
+    bool isObservingTransitions() const { return m_isObservingTransitions; }
+    bool isObservedPropertyForTransition(CSSPropertyID propertyId) const { return propertyId == CSSPropertyLeft; }
     void domTimerExecuteDidStart(const DOMTimer&);
     void domTimerExecuteDidFinish(const DOMTimer&);
@@ -168 +177 @@
     Timer m_contentObservationTimer;
     HashSet<const DOMTimer*> m_DOMTimerList;
+    // FIXME: Move over to WeakHashSet when it starts supporting const.
+    HashSet<const Element*> m_elementsWithTransition;
     bool m_touchEventIsBeingDispatched { false };
     bool m_isWaitingForStyleRecalc { false };
@@ -175 +186 @@
     bool m_mouseMovedEventIsBeingDispatched { false };
     bool m_isBetweenTouchEndAndMouseMoved { false };
+    bool m_isObservingTransitions { false };
 };