Throttle rendering pipeline for invisible iframes

Source/core/frame/FrameView.h

 /*
    Copyright (C) 1997 Martin Jones (mjones@kde.org)
              (C) 1998 Waldo Bastian (bastian@kde.org)
              (C) 1998, 1999 Torben Weis (weis@kde.org)
              (C) 1999 Lars Knoll (knoll@kde.org)
              (C) 1999 Antti Koivisto (koivisto@kde.org)
    Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple 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
@@ skipping 208 matching lines @@
     void setIsPainting(bool val) { m_isPainting = val; }
     bool isPainting() const;
     void setLastPaintTime(double val) { m_lastPaintTime = val; }
     bool hasEverPainted() const { return m_lastPaintTime; }
     void setNodeToDraw(Node*);
     Node* nodeToDraw() { return m_nodeToDraw.get(); }
 
     Color documentBackgroundColor() const;
 
     // Run all needed lifecycle stages. After calling this method, all frames will be in the lifecycle state PaintInvalidationClean.
-    void updateAllLifecyclePhases();
+    // If lifecycle throttling is allowed, some frames may skip the lifecycle update (e.g., based on visibility) and will not end
+    // up being PaintInvalidationClean.
+    enum class LifecycleThrottlingMode { Disallow, Allow };
+    void updateAllLifecyclePhases(LifecycleThrottlingMode = LifecycleThrottlingMode::Disallow);
 
     // Computes the style, layout and compositing lifecycle stages if needed. After calling this method, all frames wil lbe in a lifecycle
     // state >= CompositingClean, and scrolling has been updated.
-    void updateLifecycleToCompositingCleanPlusScrolling();
+    void updateLifecycleToCompositingCleanPlusScrolling(LifecycleThrottlingMode = LifecycleThrottlingMode::Disallow);
 
     bool invalidateViewportConstrainedObjects();
 
     void incrementVisuallyNonEmptyCharacterCount(unsigned);
     void incrementVisuallyNonEmptyPixelCount(const IntSize&);
     bool isVisuallyNonEmpty() const { return m_isVisuallyNonEmpty; }
     void setIsVisuallyNonEmpty() { m_isVisuallyNonEmpty = true; }
     void enableAutoSizeMode(const IntSize& minSize, const IntSize& maxSize);
     void disableAutoSizeMode();
 
@@ skipping 308 matching lines @@
     // Returns true if the default scrolling direction is vertical. i.e. writing mode
     // is horiziontal. In a vertical document, a spacebar scrolls down.
     bool isVerticalDocument() const;
 
     // Returns true if the document's writing mode is right-to-left or bottom-to-top.
     bool isFlippedDocument() const;
 
     void setFrameTimingRequestsDirty(bool isDirty) { m_frameTimingRequestsDirty = isDirty; }
     bool frameTimingRequestsDirty() { return m_frameTimingRequestsDirty; }
 
+    // Returns true if this frame should skip rendering pipeline processing during the
+    // current BeginMainFrame.
+    bool shouldThrottleRenderingPipeline() const;
+
+    // Returns true if this frame should skip style computation, layout and
+    // compositing updates for the current BeginMainFrame.
+    bool shouldThrottleStyleLayoutAndCompositingUpdates() const;
+
+    // Updates the throttling status of all frames in the hierarchy and
+    // schedules new animations or lifecycle updates as necessary. Must be
+    // called after the layer update phase of the current BeginMainFrame.
+    void updateThrottling();
+
 protected:
     // Scroll the content via the compositor.
     bool scrollContentsFastPath(const IntSize& scrollDelta);
 
     // Scroll the content by invalidating everything.
     void scrollContentsSlowPath(const IntRect& updateRect);
 
     // These functions are used to create/destroy scrollbars.
     void setHasHorizontalScrollbar(bool);
     void setHasVerticalScrollbar(bool);
@@ skipping 33 matching lines @@
     explicit FrameView(LocalFrame*);
 
     void setScrollOffset(const IntPoint&, ScrollType) override;
     void setScrollOffset(const DoublePoint&, ScrollType) override;
 
     enum LifeCycleUpdateOption {
         AllPhases,
         OnlyUpToCompositingCleanPlusScrolling,
     };
 
-    void updateLifecyclePhasesInternal(LifeCycleUpdateOption);
+    void updateLifecyclePhasesInternal(LifeCycleUpdateOption, LifecycleThrottlingMode);
     void invalidateTreeIfNeededRecursive();
     void scrollContentsIfNeededRecursive();
     void updateStyleAndLayoutIfNeededRecursive();
     void paintForSlimmingPaintV2();
     void compositeForSlimmingPaintV2();
 
     void reset();
     void init();
 
     void clearLayoutSubtreeRootsAndMarkContainingBlocks();
@@ skipping 84 matching lines @@
     // LayoutObject for the viewport-defining element (see Document::viewportDefiningElement).
     LayoutObject* viewportLayoutObject();
 
     void collectAnnotatedRegions(LayoutObject&, Vector<AnnotatedRegionValue>&);
 
     typedef WTF::HashMap <const GraphicsLayer*, Vector<std::pair<int64_t, WebRect>>> GraphicsLayerFrameTimingRequests;
     void updateFrameTimingRequestsIfNeeded();
     void collectFrameTimingRequests(GraphicsLayerFrameTimingRequests&);
     void collectFrameTimingRequestsRecursive(GraphicsLayerFrameTimingRequests&);
 
+    void computeViewportVisibility();
+    void setLifecycleThrottlingModeRecursive(LifecycleThrottlingMode);
+    void updateThrottlingRecursive(bool hasCrossedSecurityOrigin);
+
     LayoutSize m_size;
 
     typedef HashSet<RefPtr<LayoutEmbeddedObject>> EmbeddedObjectSet;
     EmbeddedObjectSet m_partUpdateSet;
 
     // FIXME: These are just "children" of the FrameView and should be RefPtrWillBeMember<Widget> instead.
     HashSet<RefPtr<LayoutPart>> m_parts;
 
     // The RefPtr cycle between LocalFrame and FrameView is broken
     // when a LocalFrame is detached by LocalFrame::detach().
@@ skipping 102 matching lines @@
     OwnPtr<LayoutAnalyzer> m_analyzer;
 
     // Mark if something has changed in the mapping from Frame to GraphicsLayer
     // and the Frame Timing regions should be recalculated.
     bool m_frameTimingRequestsDirty;
 
     // Exists only on root frame.
     // TODO(bokan): crbug.com/484188. We should specialize FrameView for the
     // main frame.
     OwnPtrWillBeMember<ScrollableArea> m_viewportScrollableArea;
+
+    LifecycleThrottlingMode m_lifecycleThrottlingMode;
+    // This frame's bounds in the root frame's content coordinates, clipped recursively through every ancestor view.
+    IntRect m_clippedBounds;
+
+    enum class ViewportVisibility { Hidden, Visible, Unknown };
+    ViewportVisibility m_viewportVisibility;
+    ViewportVisibility m_viewportVisibilityForThrottling;

[ojan, 2015/09/01 19:56:48]

This member deserves a comment explaining why we need to the variables, i.e.
that we need to compute the visibility when the frame moves but not update it
until after the current frame of the pipeline is finished to avoid violating
assumptions of the layout/painting code.

[Sami, 2015/09/02 10:46:02]

Definitely agreed. Added a comment.

+    bool m_isCrossOriginForThrottling;
 };
 
 inline void FrameView::incrementVisuallyNonEmptyCharacterCount(unsigned count)
 {
     if (m_isVisuallyNonEmpty)
         return;
     m_visuallyNonEmptyCharacterCount += count;
     // Use a threshold value to prevent very small amounts of visible content from triggering didFirstVisuallyNonEmptyLayout.
     // The first few hundred characters rarely contain the interesting content of the page.
     static const unsigned visualCharacterThreshold = 200;
@@ skipping 10 matching lines @@
     static const unsigned visualPixelThreshold = 32 * 32;
     if (m_visuallyNonEmptyPixelCount > visualPixelThreshold)
         setIsVisuallyNonEmpty();
 }
 
 DEFINE_TYPE_CASTS(FrameView, Widget, widget, widget->isFrameView(), widget.isFrameView());
 
 } // namespace blink
 
 #endif // FrameView_h