Deferred frame loading stats v2

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.
  *
@@ skipping 4293 matching lines @@
     parent->m_needsUpdateViewportIntersectionInSubtree = true;
 }
 
 void FrameView::updateViewportIntersectionIfNeeded() {
   if (!m_needsUpdateViewportIntersection)
     return;
   m_needsUpdateViewportIntersection = false;
   m_viewportIntersectionValid = true;
   FrameView* parent = parentFrameView();
   if (!parent) {
+    HTMLFrameOwnerElement* element = frame().deprecatedLocalOwner();
+    // Frames have no layout object approximately iff they are display:none.
+    // And out-of-process frames are the only other frames that have no parent.

[dgrogan, 2016/10/13 01:06:22]

Do you know if the line4316 comment is correct? Why might cross-origin frames
not have a parent?

+    if (element && !element->layoutObject())
+      frame().document()->wouldLoadBecause(WouldLoadDisplayNone);
+    else

[dcheng, 2016/10/13 23:00:43]

Right now, this will record WouldLoadOutOfProcess if an iframe's parent is
in-process and has a layout object (since it doesn't meet both of the first
conditions)

Let's restructure this to:

// Determining visibility uses the owner element's LayoutObject,
// which is not currently possible if the parent is
// remote.
if (!element)
  wouldLoadBecause(WouldLoadOutOfProcess)
// Having no layout object means the frame is not drawn.
else if (!element->layoutObject())
  wouldLoadBecause(WouldLoadDisplayNone)

which also puts each comment near the the clause it documents.

[dgrogan, 2016/10/14 21:45:08]

If an iframe's parent is in-process we wouldn't enter this block because of the
!parent check above?
Do we need to worry about the "else" case? What could hit it? I added "else
NOTREACHED()" and 3 layout tests hit it but I don't see what's common between
them except perhaps objects/iframes being unloaded.
https://cs.chromium.org/chromium/src/third_party/WebKit/LayoutTests/fast/dom/...
https://cs.chromium.org/chromium/src/third_party/WebKit/LayoutTests/fast/load...
https://cs.chromium.org/chromium/src/third_party/WebKit/LayoutTests/imported/...

[dcheng, 2016/10/14 23:40:30]

Ah, I misread this originally. So I would expect parentFrameView() to only be
null for two cases:
- |this| is the main frame
- |this| is a child frame with a remote parent.

Taking that into account, I think the conditions we need to check for
display:none should be (I believe display:none iframes still have a FrameView):

if (parentFrameView() && !frame().deprecatedLocalOwner().layoutObject())
  wouldLoadBecause(DisplayNone);

And then for the remote frame case:

else if (frame->owner() && frame->owner()->isRemote()) {
  wouldLoadBecause(OutOfProcess);
}

Does this match the desired semantics?
probably not, but it's hard to say for sure =/

+      frame().document()->wouldLoadBecause(WouldLoadOutOfProcess);
     m_viewportIntersection = frameRect();
     return;
   }
   ASSERT(!parent->m_needsUpdateViewportIntersection);
 
+  bool parentLoaded = parent->frame().document()->wouldLoadReason() > Created;

[dgrogan, 2016/10/13 01:06:22]

I suspect ">" makes the meaning clearer at first glance.

+  // If the parent wasn't loaded, the children won't be either.
+  if (parentLoaded) {
+    if (frameRect().isEmpty())
+      frame().document()->wouldLoadBecause(WouldLoadZeroByZero);
+    else if (frameRect().maxY() < 0)
+      frame().document()->wouldLoadBecause(WouldLoadAbove);
+    else if (frameRect().maxX() < 0)
+      frame().document()->wouldLoadBecause(WouldLoadLeft);
+  }
+
   // If our parent is hidden, then we are too.
   if (parent->m_viewportIntersection.isEmpty()) {
     m_viewportIntersection = parent->m_viewportIntersection;
     return;
   }
 
   // Transform our bounds into the root frame's content coordinate space,
   // making sure we have valid layout data in our parent document. If our
   // parent is throttled, we'll use possible stale layout information and
   // rely on the fact that another lifecycle update will be scheduled once
   // our parent becomes unthrottled.
   ASSERT(parent->lifecycle().state() >= DocumentLifecycle::LayoutClean ||
          parent->shouldThrottleRendering());
   m_viewportIntersection = parent->contentsToRootFrame(frameRect());
 
   // TODO(skyostil): Expand the viewport to make it less likely to see stale
   // content while scrolling.
   IntRect viewport = parent->m_viewportIntersection;
   m_viewportIntersection.intersect(viewport);
+
+  if (parentLoaded && !m_viewportIntersection.isEmpty())
+    frame().document()->wouldLoadBecause(WouldLoadVisible);
 }
 
 void FrameView::updateViewportIntersectionsForSubtree(
     DocumentLifecycle::LifecycleState targetState) {
   bool hadValidIntersection = m_viewportIntersectionValid;
   bool hadEmptyIntersection = m_viewportIntersection.isEmpty();
   updateViewportIntersectionIfNeeded();
 
   // Notify javascript IntersectionObservers
   if (targetState == DocumentLifecycle::PaintClean &&
@@ skipping 65 matching lines @@
 
 void FrameView::notifyRenderThrottlingObservers() {
   TRACE_EVENT0("blink", "FrameView::notifyRenderThrottlingObservers");
   DCHECK(!isInPerformLayout());
   DCHECK(frame().document());
   DCHECK(!frame().document()->inStyleRecalc());
   bool wasThrottled = canThrottleRendering();
 
   updateThrottlingStatus();
 
-  frame().document()->onVisibilityMaybeChanged(!m_hiddenForThrottling);
-
   bool becameThrottled = !wasThrottled && canThrottleRendering();
   bool becameUnthrottled = wasThrottled && !canThrottleRendering();
   ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator();
   if (becameThrottled) {
     // If this FrameView became throttled, we must make sure all of its
     // children become throttled at the same time. Otherwise we might
     // attempt to paint one of the children with an out-of-date layout
     // before |notifyRenderThrottlingObservers| has made it throttled.
     forAllNonThrottledFrameViews([](FrameView& frameView) {
       frameView.m_subtreeThrottled = true;
@@ skipping 38 matching lines @@
 }
 
 bool FrameView::canThrottleRendering() const {
   if (!RuntimeEnabledFeatures::renderingPipelineThrottlingEnabled())
     return false;
   return m_subtreeThrottled ||
          (m_hiddenForThrottling && m_crossOriginForThrottling);
 }
 
 }  // namespace blink