Initial ResizeObserver implementation

third_party/WebKit/Source/core/frame/FrameView.cpp

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2009 Google 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/frame/FrameView.h"
 
+#include "bindings/core/v8/ScriptCallStack.h"

[szager1, 2016/06/02 20:52:41]

There should be a way to eliminate this.  I still don't see why it's necessary,
but if it really is necessary, then probably something needs to be pushed down
into ExecutionContext.

FrameView does not have any javascript bindings, so it's a layering violation to
include binding code here.

[atotic1, 2016/06/08 18:59:21]

Done. I've just pulled master, and the new API no longer requires the stack.

 #include "core/HTMLNames.h"
 #include "core/MediaTypeNames.h"
 #include "core/css/FontFaceSet.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/AXObjectCache.h"
 #include "core/dom/Fullscreen.h"
 #include "core/dom/IntersectionObserverController.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/RenderedPosition.h"
 #include "core/editing/markers/DocumentMarkerController.h"
+#include "core/events/ErrorEvent.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Location.h"
 #include "core/frame/PageScaleConstraintsSet.h"
 #include "core/frame/Settings.h"
 #include "core/frame/TopControls.h"
 #include "core/html/HTMLFrameElement.h"
 #include "core/html/HTMLPlugInElement.h"
@@ skipping 14 matching lines @@
 #include "core/layout/TracedLayoutObject.h"
 #include "core/layout/api/LayoutBoxModel.h"
 #include "core/layout/api/LayoutItem.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/layout/compositing/CompositedSelection.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
+#include "core/observer/ResizeObserverController.h"
 #include "core/page/AutoscrollController.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/FocusController.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 #include "core/paint/FramePainter.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/PaintPropertyTreeBuilder.h"
 #include "core/plugins/PluginView.h"
@@ skipping 2317 matching lines @@
 void FrameView::scheduleVisualUpdateForPaintInvalidationIfNeeded()
 {
     LocalFrame* localFrameRoot = frame().localFrameRoot();
     if (!localFrameRoot->view()->m_isUpdatingAllLifecyclePhases || lifecycle().state() >= DocumentLifecycle::PaintInvalidationClean) {
         // Schedule visual update to process the paint invalidation in the next cycle.
         localFrameRoot->scheduleVisualUpdateUnlessThrottled();
     }
     // Otherwise the paint invalidation will be handled in paint invalidation phase of this cycle.
 }
 
+void FrameView::notifyResizeObserver()
+{
+    if (!m_frame->document()->resizeObserverController())
+        return;
+
+    ResizeObserverController& resizeController = m_frame->document()->ensureResizeObserverController();
+
+    if (lifecycle().state() < DocumentLifecycle::LayoutClean)

[szager1, 2016/06/02 20:52:41]

This makes me uneasy.  If you're going to call
updateStyleAndLayoutIfNeededRecursive() before entering this method, then this
should be:

DCHECK(lifecycle().state() >= DocumentLifecycle::LayoutClean);

Basically, we want to enforce a strict invariant that the document is in a
specific state when this method is called.  We don't want to be flexible about
that.

[atotic1, 2016/06/08 18:59:21]

Done.

+        updateStyleAndLayoutIfNeededRecursive();
+
+    size_t resizeNotifyCount = 0;
+
+    while (resizeController.gatherObservations()) {

[szager1, 2016/06/02 20:52:41]

This still doesn't seem right.  What happens to the notifications that are
generated but never delivered because the loop limit is exceeded?  There should
not be undelivered notifications when this method exits.

[atotic1, 2016/06/08 18:59:21]

Done. I've added a clearObservations().

I was clearing observations in gatherObservations(). This is better, the strong
pointers to Element are not being kept an extra cycle.

+        if (++resizeNotifyCount > ResizeObserverController::kRenderLoopLimit) {
+            // report the error and break
+            ErrorEvent * error = ErrorEvent::create("ResizeObserver loop limit exceeded.", "", 0, 0, nullptr);
+            m_frame->document()->reportException(error, 0, nullptr, NotSharableCrossOrigin);
+            break;
+        }
+
+        resizeController.deliverObservations();
+
+        if (lifecycle().state() < DocumentLifecycle::LayoutClean || layoutView()->needsLayout())
+            updateStyleAndLayoutIfNeededRecursive();
+    }
+
+    DCHECK(!layoutView()->needsLayout());
+}
+
 // TODO(leviw): We don't assert lifecycle information from documents in child PluginViews.
 void FrameView::updateLifecyclePhasesInternal(LifeCycleUpdateOption phases)
 {
     Optional<TemporaryChange<bool>> isUpdatingAllLifecyclePhasesScope;
     if (phases == AllPhases)
         isUpdatingAllLifecyclePhasesScope.emplace(m_isUpdatingAllLifecyclePhases, true);
 
     // This must be called from the root frame, since it recurses down, not up.
     // Otherwise the lifecycles of the frames might be out of sync.
     ASSERT(m_frame->isLocalRoot());
 
     if (shouldThrottleRendering()) {
         updateViewportIntersectionsForSubtree(std::min(phases, OnlyUpToCompositingCleanPlusScrolling));
         return;
     }
 
     updateStyleAndLayoutIfNeededRecursive();
+
+    notifyResizeObserver();
+
     ASSERT(lifecycle().state() >= DocumentLifecycle::LayoutClean);
 
     if (phases == OnlyUpToLayoutClean) {
         updateViewportIntersectionsForSubtree(phases);
         return;
     }
 
     if (LayoutViewItem view = layoutViewItem()) {
         {
             TRACE_EVENT1("devtools.timeline", "UpdateLayerTree", "data", InspectorUpdateLayerTreeEvent::data(m_frame.get()));
@@ skipping 1666 matching lines @@
     return m_subtreeThrottled || (m_hiddenForThrottling && m_crossOriginForThrottling);
 }
 
 LayoutBox& FrameView::boxForScrollControlPaintInvalidation() const
 {
     ASSERT(layoutView());
     return *layoutView();
 }
 
 } // namespace blink