ResizeObserver pt5: size change notification

third_party/WebKit/Source/core/observer/ResizeObserver.cpp

 // Copyright 2016 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/observer/ResizeObserver.h"
 
 #include "core/dom/Element.h"
 #include "core/frame/FrameView.h"
 #include "core/observer/ResizeObservation.h"
 #include "core/observer/ResizeObserverCallback.h"
 #include "core/observer/ResizeObserverController.h"
 #include "core/observer/ResizeObserverEntry.h"
 
 namespace blink {
 
 ResizeObserver* ResizeObserver::create(Document& document, ResizeObserverCallback* callback)
 {
     return new ResizeObserver(callback, document);
 }
 
 ResizeObserver::ResizeObserver(ResizeObserverCallback* callback, Document& document)
     : m_callback(callback)
+    , m_skippedObservations(false)
+    , m_elementSizeChanged(false)
 {
     m_controller = &document.ensureResizeObserverController();
     m_controller->addObserver(*this);
 }
 
 void ResizeObserver::observe(Element* target)
 {
     auto& observerMap = target->ensureResizeObserverData();
     if (observerMap.contains(this))
         return; // Already registered.
@@ skipping 16 matching lines @@
         m_observations.remove((*observation).value);
         observerMap->remove(observation);
     }
 }
 
 void ResizeObserver::disconnect()
 {
     ObservationList observations;
     m_observations.swap(observations);
 
     for (auto observation : observations) {

[ikilpatrick, 2016/07/29 23:18:38]

auto& ?

[atotic1, 2016/07/30 03:16:29]

Done.

         Element* target = (*observation).target();
         if (target)
             target->ensureResizeObserverData().remove(this);
     }
+    clearObservations();
+}
+
+size_t ResizeObserver::gatherObservations(size_t deeperThan)

[ikilpatrick, 2016/07/28 21:48:40]

Ok, so we should store the m_observations in an ordered list here, and then
invalidate when a node is being inserted into the tree.

Quickly spoke with Ojan and Element::insertedInto is the right place to
invalidate here.

https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/dom/Eleme...

@esphren might have thoughts here.

[atotic1, 2016/07/29 20:04:16]

TBD: wrote a lenghty reply.

+{
+    DCHECK(m_activeObservations.isEmpty());
+
+    size_t minObservedDepth = ResizeObserverController::kDepthBottom;
+    if (!m_elementSizeChanged)
+        return minObservedDepth;
+    for (auto& observation : m_observations) {
+        if (!observation->observationSizeOutOfSync())
+            continue;
+        auto depth = observation->targetDepth();

[ikilpatrick, 2016/07/28 21:48:40]

This is currently O(n*m*o) which we'll want to fix is well. 

Invalidating on tree insertion can mean that we can also dirty all the target
depths and recompute when this happens. 

[atotic1, 2016/07/29 20:04:16]

TBD: wrote a lenghty reply.

+        if (depth > deeperThan) {
+            m_activeObservations.append(*observation);
+            minObservedDepth = std::min(minObservedDepth, depth);
+        } else {
+            m_skippedObservations = true;
+        }
+    }
+    return minObservedDepth;
+}
+
+void ResizeObserver::deliverObservations()
+{
+    m_elementSizeChanged = m_skippedObservations;

[ikilpatrick, 2016/07/29 23:18:38]

Why does this flag get set here & like this? Potentially add comment.

[atotic1, 2016/07/30 03:16:29]

Added:
// We can only clear this flag after all observations have been
// broadcast.

Done

+    if (m_activeObservations.size() == 0)
+        return;
+
+    HeapVector<Member<ResizeObserverEntry>> entries;
+
+    for (auto& observation : m_activeObservations) {
+        auto entry = new ResizeObserverEntry(observation->target());
+        entries.append(entry);
+        observation->setObservationSize(entry->contentSize());
+    }
+    m_callback->handleEvent(entries, this);
+    clearObservations();
+}
+
+void ResizeObserver::clearObservations()
+{
+    m_activeObservations.clear();
+    m_skippedObservations = false;
+}
+
+void ResizeObserver::elementSizeChanged()
+{
+    m_elementSizeChanged = true;
+    if (m_controller)
+        m_controller->observerChanged();
 }
 
 DEFINE_TRACE(ResizeObserver)
 {
     visitor->trace(m_callback);
     visitor->trace(m_observations);
+    visitor->trace(m_activeObservations);
     visitor->trace(m_controller);
 }
 
 } // namespace blink