New UMA stats for stacking container opt-in measurements.

Source/core/rendering/RenderLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 115 matching lines @@
 RenderLayer::RenderLayer(RenderLayerModelObject* renderer)
     : m_inResizeMode(false)
     , m_scrollDimensionsDirty(true)
     , m_normalFlowListDirty(true)
     , m_hasSelfPaintingLayerDescendant(false)
     , m_hasSelfPaintingLayerDescendantDirty(false)
     , m_hasOutOfFlowPositionedDescendant(false)
     , m_hasOutOfFlowPositionedDescendantDirty(true)
     , m_hasUnclippedDescendant(false)
     , m_isUnclippedDescendant(false)
-    , m_needsCompositedScrolling(false)
+    , m_isScrollableAreaHasBeenRecorded(false)
     , m_canBePromotedToStackingContainer(false)
     , m_canBePromotedToStackingContainerDirty(true)
     , m_isRootLayer(renderer->isRenderView())
     , m_usedTransparency(false)
     , m_paintingInsideReflection(false)
     , m_inOverflowRelayout(false)
     , m_repaintStatus(NeedsNormalRepaint)
     , m_visibleContentStatusDirty(true)
     , m_hasVisibleContent(false)
     , m_visibleDescendantStatusDirty(false)
     , m_hasVisibleDescendant(false)
     , m_isPaginated(false)
     , m_3DTransformedDescendantStatusDirty(true)
     , m_has3DTransformedDescendant(false)
     , m_containsDirtyOverlayScrollbars(false)
 #if !ASSERT_DISABLED
     , m_layerListMutationAllowed(true)
 #endif
     , m_canSkipRepaintRectsUpdateOnScroll(renderer->isTableCell())
     , m_hasFilterInfo(false)
+    , m_needsCompositedScrolling(MixedTriState)
     , m_blendMode(BlendModeNormal)
     , m_renderer(renderer)
     , m_parent(0)
     , m_previous(0)
     , m_next(0)
     , m_first(0)
     , m_last(0)
     , m_staticInlinePosition(0)
     , m_staticBlockPosition(0)
     , m_reflection(0)
@@ skipping 1877 matching lines @@
         return needsToBeStackingContainer();
     if (FrameView* frameView = renderer()->view()->frameView())
         return frameView->containsScrollableArea(scrollableArea());
     return false;
 }
 
 bool RenderLayer::needsToBeStackingContainer() const
 {
     switch (m_forceNeedsCompositedScrolling) {
     case DoNotForceCompositedScrolling:
-        return m_needsCompositedScrolling;
+        return m_needsCompositedScrolling == TrueTriState;
     case CompositedScrollingAlwaysOn:
         return true;
     case CompositedScrollingAlwaysOff:
         return false;
     }
 
     ASSERT_NOT_REACHED();
-    return m_needsCompositedScrolling;
+    return m_needsCompositedScrolling == TrueTriState;
 }
 
 void RenderLayer::updateNeedsCompositedScrolling()
 {
     TRACE_EVENT0("comp-scroll", "RenderLayer::updateNeedsCompositedScrolling");
 
     updateCanBeStackingContainer();
     updateDescendantDependentFlags();
 
     ASSERT(renderer()->view()->frameView() && renderer()->view()->frameView()->containsScrollableArea(scrollableArea()));
     bool needsCompositedScrolling = acceleratedCompositingForOverflowScrollEnabled()
         && canBeStackingContainer()
         && !hasUnclippedDescendant();
 
     // We gather a boolean value for use with Google UMA histograms to
     // quantify the actual effects of a set of patches attempting to
     // relax composited scrolling requirements, thereby increasing the
     // number of composited overflow divs.
     if (acceleratedCompositingForOverflowScrollEnabled())
         HistogramSupport::histogramEnumeration("Renderer.NeedsCompositedScrolling", needsCompositedScrolling, 2);
 
     setNeedsCompositedScrolling(needsCompositedScrolling);
 }
 
 void RenderLayer::setNeedsCompositedScrolling(bool needsCompositedScrolling)
 {
-    if (m_needsCompositedScrolling == needsCompositedScrolling)
+    const bool neededCompositedScrolling = m_needsCompositedScrolling == TrueTriState;
+    if (neededCompositedScrolling == needsCompositedScrolling)
         return;
 
-    m_needsCompositedScrolling = needsCompositedScrolling;
+    // Count the total number of RenderLayers which need composited scrolling at
+    // some point. This should be recorded at most once per RenderLayer, so we
+    // check if m_needsCompositedScrolling has been set yet. If it hasn't been
+    // set, its value will be MixedTriState, but if it has been set, it will be
+    // TrueTriState or FalseTriState.
+    if (acceleratedCompositingForOverflowScrollEnabled() && m_needsCompositedScrolling == MixedTriState)
+        HistogramSupport::histogramEnumeration("Renderer.NeedsToBeStackingContainer", 1, 2);
+
+    m_needsCompositedScrolling = needsCompositedScrolling ? TrueTriState : FalseTriState;
 
     // Note, the z-order lists may need to be rebuilt, but our code guarantees
     // that we have not affected stacking, so we will not dirty
     // m_canBePromotedToStackingContainer for either us or our stacking context
     // or container.
     didUpdateNeedsCompositedScrolling();
 }
 
 void RenderLayer::setForceNeedsCompositedScrolling(RenderLayer::ForceNeedsCompositedScrollingMode mode)
 {
@@ skipping 4077 matching lines @@
     if (!frameView)
         return;
 
     bool isVisibleToHitTest = renderer()->visibleToHitTesting();
     if (HTMLFrameOwnerElement* owner = frame->ownerElement())
         isVisibleToHitTest &= owner->renderer() && owner->renderer()->visibleToHitTesting();
 
     if (hasOverflow && isVisibleToHitTest) {
         if (frameView->addScrollableArea(scrollableArea()))
             compositor()->setNeedsUpdateCompositingRequirementsState();
+
+        // Count the total number of RenderLayers that are scrollable areas for
+        // any period. We only want to record this at most once per RenderLayer.
+        if (!m_isScrollableAreaHasBeenRecorded) {
+            HistogramSupport::histogramEnumeration("Renderer.IsScrollableArea", 1, 2);
+            m_isScrollableAreaHasBeenRecorded = true;
+        }

[Ian Vollick, 2013/09/03 18:28:07]

This should happen inside the previous 'if', I think. if (frameView->add...) {
compositor()->...; <new code>; }

[hartmanng, 2013/09/03 21:26:56]

Done.

     } else {
         if (frameView->removeScrollableArea(scrollableArea()))
             setNeedsCompositedScrolling(false);
     }
 }
 
 void RenderLayer::updateScrollCornerStyle()
 {
     RenderObject* actualRenderer = rendererForScrollbar(renderer());
     RefPtr<RenderStyle> corner = renderer()->hasOverflowClip() ? actualRenderer->getUncachedPseudoStyle(PseudoStyleRequest(SCROLLBAR_CORNER), actualRenderer->style()) : PassRefPtr<RenderStyle>(0);
@@ skipping 273 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif