Compute snap offsets (both repeat and element based)

third_party/WebKit/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 98 matching lines @@
 #include "core/layout/LayoutView.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "core/page/PointerLockController.h"
 #include "core/page/SpatialNavigation.h"
 #include "core/page/scrolling/ScrollCustomizationCallbacks.h"
 #include "core/page/scrolling/ScrollState.h"
 #include "core/page/scrolling/ScrollStateCallback.h"
+#include "core/page/scrolling/SnapCoordinator.h"
 #include "core/paint/PaintLayer.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "core/svg/SVGElement.h"
 #include "platform/EventDispatchForbiddenScope.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/scroll/ScrollableArea.h"
 #include "wtf/BitVector.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/text/CString.h"
@@ skipping 1394 matching lines @@
     // We've already been through detach when doing an attach, but we might
     // need to clear any state that's been added since then.
     if (hasRareData() && styleChangeType() == NeedsReattachStyleChange) {
         ElementRareData* data = elementRareData();
         data->clearComputedStyle();
     }
 
     if (!isActiveInsertionPoint(*this))
         LayoutTreeBuilderForElement(*this, context.resolvedStyle).createLayoutObjectIfNeeded();
 
-    addCallbackSelectors();
+    const ComputedStyle* style = computedStyle();
+    addCallbackSelectors(style);
+    addScrollSnapMapping(style);
 
     if (hasRareData() && !layoutObject()) {
         if (ElementAnimations* elementAnimations = elementRareData()->elementAnimations()) {
             elementAnimations->cssAnimations().cancel();
             elementAnimations->setAnimationStyleChange(false);
         }
     }
 
     StyleResolverParentScope parentScope(*this);
 
@@ skipping 11 matching lines @@
     // We create the first-letter element after the :before, :after and
     // children are attached because the first letter text could come
     // from any of them.
     createPseudoElementIfNeeded(FIRST_LETTER);
 }
 
 void Element::detach(const AttachContext& context)
 {
     HTMLFrameOwnerElement::UpdateSuspendScope suspendWidgetHierarchyUpdates;
     cancelFocusAppearanceUpdate();
-    removeCallbackSelectors();
+
+    const ComputedStyle* style = computedStyle();
+    removeCallbackSelectors(style);
+    removeScrollSnapMapping(style);
+
     if (hasRareData()) {
         ElementRareData* data = elementRareData();
         data->clearPseudoElements();
 
         // attach() will clear the computed style for us when inside recalcStyle.
         if (!document().inStyleRecalc())
             data->clearComputedStyle();
 
         if (ElementAnimations* elementAnimations = data->elementAnimations()) {
             if (context.performingReattach) {
@@ skipping 189 matching lines @@
         reattachContext.resolvedStyle = newStyle.get();
         bool layoutObjectWillChange = needsAttach() || layoutObject();
         reattach(reattachContext);
         if (layoutObjectWillChange || layoutObject())
             return Reattach;
         return ReattachNoLayoutObject;
     }
 
     ASSERT(oldStyle);
 
-    if (localChange != NoChange)
+    if (localChange != NoChange) {
         updateCallbackSelectors(oldStyle.get(), newStyle.get());
+        updateScrollSnapMapping(oldStyle.get(), newStyle.get());
+    }
 
     if (LayoutObject* layoutObject = this->layoutObject()) {
         if (localChange != NoChange || pseudoStyleCacheIsInvalid(oldStyle.get(), newStyle.get()) || svgFilterNeedsLayerUpdate()) {
             layoutObject->setStyle(newStyle.get());
         } else {
             // Although no change occurred, we use the new style so that the cousin style sharing code won't get
             // fooled into believing this style is the same.
             // FIXME: We may be able to remove this hack, see discussion in
             // https://codereview.chromium.org/30453002/
             layoutObject->setStyleInternal(newStyle.get());
@@ skipping 23 matching lines @@
 {
     Vector<String> emptyVector;
     const Vector<String>& oldCallbackSelectors = oldStyle ? oldStyle->callbackSelectors() : emptyVector;
     const Vector<String>& newCallbackSelectors = newStyle ? newStyle->callbackSelectors() : emptyVector;
     if (oldCallbackSelectors.isEmpty() && newCallbackSelectors.isEmpty())
         return;
     if (oldCallbackSelectors != newCallbackSelectors)
         CSSSelectorWatch::from(document()).updateSelectorMatches(oldCallbackSelectors, newCallbackSelectors);
 }
 
-void Element::addCallbackSelectors()
+void Element::addCallbackSelectors(const ComputedStyle* style)
 {
-    updateCallbackSelectors(0, computedStyle());
+    updateCallbackSelectors(0, style);
 }
 
-void Element::removeCallbackSelectors()
+void Element::removeCallbackSelectors(const ComputedStyle* style)
 {
-    updateCallbackSelectors(computedStyle(), 0);
+    updateCallbackSelectors(style, 0);
 }
 
+void Element::updateScrollSnapMapping(const ComputedStyle* oldStyle, const ComputedStyle* newStyle)
+{
+    SnapCoordinator* snapCoordinator = document().snapCoordinator();
+    if (!snapCoordinator)
+        return;
+
+    ScrollSnapType oldSnapType = oldStyle ? oldStyle->scrollSnapType() :  ScrollSnapTypeNone;
+    ScrollSnapType newSnapType = newStyle ? newStyle->scrollSnapType() :  ScrollSnapTypeNone;
+    if (oldSnapType != newSnapType)
+        snapCoordinator->snapContainerDidChange(*this, newSnapType);
+
+    Vector<LengthPoint> emptyVector;
+    Vector<LengthPoint> oldSnapCoordinate = oldStyle ? oldStyle->scrollSnapCoordinate() :  emptyVector;
+    Vector<LengthPoint> newSnapCoordinate = newStyle ? newStyle->scrollSnapCoordinate() :  emptyVector;

[esprehn, 2015/10/20 21:03:35]

This means making copies all the time, I think you want const refs to the
vectors

+    if (oldSnapCoordinate != newSnapCoordinate)
+        snapCoordinator->snapElementDidChange(*this, newSnapCoordinate);
+}
+
+void Element::addScrollSnapMapping(const ComputedStyle* style)
+{
+    updateScrollSnapMapping(0, style);
+}
+
+void Element::removeScrollSnapMapping(const ComputedStyle* style)
+{
+    updateScrollSnapMapping(style, 0);
+}
+
+
 ElementShadow* Element::shadow() const
 {
     return hasRareData() ? elementRareData()->shadow() : nullptr;
 }
 
 ElementShadow& Element::ensureShadow()
 {
     return ensureElementRareData().ensureShadow();
 }
 
@@ skipping 1724 matching lines @@
 {
 #if ENABLE(OILPAN)
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
 #endif
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink