Only update composited scrolling state when necessary

Source/WebCore/rendering/RenderView.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@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
  * 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,
@@ skipping 45 matching lines @@
     , m_frameView(document->view())
     , m_selectionStart(0)
     , m_selectionEnd(0)
     , m_selectionStartPos(-1)
     , m_selectionEndPos(-1)
     , m_maximalOutlineSize(0)
     , m_pageLogicalHeight(0)
     , m_pageLogicalHeightChanged(false)
     , m_layoutState(0)
     , m_layoutStateDisableCount(0)
+    , m_scopedCompositedScrollingUpdatersCount(0)
     , m_renderQuoteHead(0)
     , m_renderCounterCount(0)
 {
     // init RenderObject attributes
     setInline(false);
     
     m_minPreferredLogicalWidth = 0;
     m_maxPreferredLogicalWidth = 0;
 
     setPreferredLogicalWidthsDirty(true, MarkOnlyThis);
@@ skipping 64 matching lines @@
 static RenderBox* enclosingSeamlessRenderer(Document* doc)
 {
     if (!doc)
         return 0;
     Element* ownerElement = doc->seamlessParentIFrame();
     if (!ownerElement)
         return 0;
     return ownerElement->renderBox();
 }
 
+void RenderView::cancelScheduledCompositedScrollingUpdatesForLayer(RenderLayer* layer)
+{
+    m_pendingContiguityUpdates.remove(layer);
+    m_pendingCompositedScrollingUpdates.remove(layer);
+}
+
 void RenderView::addChild(RenderObject* newChild, RenderObject* beforeChild)
 {
     // Seamless iframes are considered part of an enclosing render flow thread from the parent document. This is necessary for them to look
     // up regions in the parent document during layout.
     if (newChild && !newChild->isRenderFlowThread()) {
         RenderBox* seamlessBox = enclosingSeamlessRenderer(document());
         if (seamlessBox && seamlessBox->flowThreadContainingBlock())
             newChild->setFlowThreadState(seamlessBox->flowThreadState());
     }
     RenderBlock::addChild(newChild, beforeChild);
@@ skipping 1005 matching lines @@
     ASSERT(m_layoutState == layoutState);
 #endif
 
     if (layoutState)
         layoutState->m_isPaginated = m_fragmenting;
         
     if (m_flowThreadState != RenderObject::NotInsideFlowThread)
         m_root->setFlowThreadStateIncludingDescendants(m_flowThreadState);
 }
 
+ScopedCompositedScrollingUpdater::ScopedCompositedScrollingUpdater(RenderView* renderView)
+    : m_renderView(renderView)
+{
+    if (m_renderView)

[Julien - ping for review, 2013/04/09 21:06:43]

Cannot be NULL per your explanation.

+        m_renderView->m_scopedCompositedScrollingUpdatersCount++;
+}
+
+ScopedCompositedScrollingUpdater::ScopedCompositedScrollingUpdater(RenderLayer* layer, CompositedScrollingUpdateMode mode)
+    : m_renderView(0)
+{
+    if (!layer || !layer->acceleratedCompositingForOverflowScrollEnabled())
+        return;
+
+    m_renderView = layer->renderer()->view();
+    m_renderView->m_scopedCompositedScrollingUpdatersCount++;
+
+    if (mode == UpdateNeedsCompositedScrolling)
+        m_renderView->m_pendingCompositedScrollingUpdates.add(layer);
+    else if (mode == UpdateDescendantsAreContiguousInStackingOrder)
+        m_renderView->m_pendingContiguityUpdates.add(layer);
+}
+
+ScopedCompositedScrollingUpdater::~ScopedCompositedScrollingUpdater()
+{
+    if (!m_renderView)

[Julien - ping for review, 2013/04/09 21:06:43]

Cannot be NULL per your explanation.

+        return;
+
+    m_renderView->m_scopedCompositedScrollingUpdatersCount--;
+    ASSERT(m_renderView->m_scopedCompositedScrollingUpdatersCount >= 0);
+    if (!m_renderView->m_scopedCompositedScrollingUpdatersCount) {

[Julien - ping for review, 2013/04/09 21:06:43]

Early return.

+        HashSet<RenderLayer*> pendingCompositedScrollingUpdates = m_renderView->m_pendingCompositedScrollingUpdates;
+        m_renderView->m_pendingCompositedScrollingUpdates.clear();
+
+        HashSet<RenderLayer*> pendingContiguityUpdates = m_renderView->m_pendingContiguityUpdates;
+        m_renderView->m_pendingContiguityUpdates.clear();
+
+        if (!pendingContiguityUpdates.isEmpty()) {

[Julien - ping for review, 2013/04/09 21:06:43]

I don't think we need an isEmpty check as the iterator would just bail out
below.

+            HashSet<RenderLayer*> stackingContexts;
+            for (HashSet<RenderLayer*>::iterator iter = pendingContiguityUpdates.begin(); iter != pendingContiguityUpdates.end(); ++iter) {
+                if (RenderLayer* stackingContext = (*iter)->enclosingStackingContext())
+                    stackingContexts.add(stackingContext);
+            }
+            for (HashSet<RenderLayer*>::iterator iter = stackingContexts.begin(); iter != stackingContexts.end(); ++iter) {
+                (*iter)->updateLayerListsIfNeeded();
+                (*iter)->updateDescendantsAreContiguousInStackingOrder();
+            }
+        }
+
+        if (!pendingCompositedScrollingUpdates.isEmpty()) {

[Julien - ping for review, 2013/04/09 21:06:43]

Same comment.

+            for (HashSet<RenderLayer*>::iterator iter = pendingCompositedScrollingUpdates.begin(); iter != pendingCompositedScrollingUpdates.end(); ++iter)
+                (*iter)->updateNeedsCompositedScrolling();
+        }
+    }

[Julien - ping for review, 2013/04/09 21:06:43]

You do store the HashSet into local variables and clear them. It's good
defense-in-depth coding but we would probably ASSERT here that no one updated
our lists or else we would miss their update indefinitely.

+}
+
 } // namespace WebCore