Delete invalidateTreeIfNeeded.

sky/engine/core/rendering/RenderObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 81 matching lines @@
 struct SameSizeAsRenderObject {
     virtual ~SameSizeAsRenderObject() { } // Allocate vtable pointer.
     void* pointers[5];
 #if ENABLE(ASSERT)
     unsigned m_debugBitfields : 2;
 #if ENABLE(OILPAN)
     unsigned m_oilpanBitfields : 1;
 #endif
 #endif
     unsigned m_bitfields;
-    unsigned m_bitfields2;
     LayoutRect rect; // Stores the previous paint invalidation rect.
     LayoutPoint position; // Stores the previous position from the paint invalidation container.
 };
 
 COMPILE_ASSERT(sizeof(RenderObject) == sizeof(SameSizeAsRenderObject), RenderObject_should_stay_small);
 
 bool RenderObject::s_affectsParentBlock = false;
 
 #if !ENABLE(OILPAN)
 void* RenderObject::operator new(size_t sz)
@@ skipping 1098 matching lines @@
 }
 
 const RenderLayerModelObject* RenderObject::adjustCompositedContainerForSpecialAncestors(const RenderLayerModelObject* paintInvalidationContainer) const
 {
     // FIXME(sky): We shouldn't have any special ancestors and we don't have composited containers
     if (paintInvalidationContainer)
         return paintInvalidationContainer;
     return view();
 }
 
-void RenderObject::invalidateTreeIfNeeded(const PaintInvalidationState& paintInvalidationState)
-{
-    // If we didn't need paint invalidation then our children don't need as well.
-    // Skip walking down the tree as everything should be fine below us.
-    if (!shouldCheckForPaintInvalidation(paintInvalidationState))
-        return;
-
-    clearPaintInvalidationState(paintInvalidationState);
-
-    for (RenderObject* child = slowFirstChild(); child; child = child->nextSibling()) {
-        if (!child->isOutOfFlowPositioned())
-            child->invalidateTreeIfNeeded(paintInvalidationState);
-    }
-}
-
 void RenderObject::mapRectToPaintInvalidationBacking(const RenderLayerModelObject* paintInvalidationContainer, LayoutRect& rect, const PaintInvalidationState* paintInvalidationState) const
 {
     if (paintInvalidationContainer == this)
         return;
 
     if (RenderObject* o = parent()) {
         if (o->hasOverflowClip()) {
             RenderBox* boxParent = toRenderBox(o);
             boxParent->applyCachedClipAndScrollOffsetForPaintInvalidation(rect);
             if (rect.isEmpty())
@@ skipping 219 matching lines @@
         if (updatedDiff.needsFullLayout())
             setNeedsLayoutAndPrefWidthsRecalc();
         else if (updatedDiff.needsPositionedMovementLayout())
             setNeedsPositionedMovementLayout();
     }
 
     if (diff.transformChanged() && !needsLayout()) {
         if (RenderBlock* container = containingBlock())
             container->setNeedsOverflowRecalcAfterStyleChange();
     }
-
-    if (updatedDiff.needsPaintInvalidationLayer())
-        toRenderLayerModelObject(this)->layer()->setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
-    else if (diff.needsPaintInvalidationObject() || updatedDiff.needsPaintInvalidationObject())
-        setShouldDoFullPaintInvalidation(true);
 }
 
 void RenderObject::styleWillChange(StyleDifference diff, const RenderStyle& newStyle)
 {
     if (m_style) {
         if (isOutOfFlowPositioned() && (m_style->position() != newStyle.position()))
             // For changes in positioning styles, we need to conceivably remove ourselves
             // from the positioned objects list.
             toRenderBox(this)->removeFloatingOrPositionedChildFromBlockLists();
 
@@ skipping 517 matching lines @@
                 if (FrameView* frameView = renderView->frameView())
                     frameView->scheduleRelayoutOfSubtree(this);
             }
         }
     }
 }
 
 void RenderObject::forceLayout()
 {
     setSelfNeedsLayout(true);
-    setShouldDoFullPaintInvalidation(true);
     layout();
 }
 
 // FIXME: Does this do anything different than forceLayout given that we don't walk
 // the containing block chain. If not, we should change all callers to use forceLayout.
 void RenderObject::forceChildLayout()
 {
     setNormalChildNeedsLayout(true);
     layout();
 }
@@ skipping 207 matching lines @@
 {
     ASSERT_NOT_REACHED();
     return false;
 }
 
 bool RenderObject::isRelayoutBoundaryForInspector() const
 {
     return objectIsRelayoutBoundary(this);
 }
 
-void RenderObject::setShouldDoFullPaintInvalidation(bool b, MarkingBehavior markBehavior)
-{
-    if (markBehavior == MarkContainingBlockChain && b) {
-        ASSERT(document().lifecycle().state() != DocumentLifecycle::InPaintInvalidation);
-        // FIXME(sky): Do we still need this here?
-        frame()->page()->animator().scheduleVisualUpdate(); // In case that this is called not during FrameView::updateLayoutAndStyleForPainting().

[ojan, 2015/01/12 21:14:21]

This is the only potential change in behavior. I removed all the
setShouldDoFullPaintInvalidation calls, so now we might not be scheduling a
frame in all the cases where we used to.

Elliott and I talked about this. I'll replace all these calls with
scheduleVisualUpdate calls instead for now and we can clean those up as needed
since it's hard to tell right now which ones are needed for the frame versus for
doing paint invalidation.

-    }
-}
-
-void RenderObject::clearPaintInvalidationState(const PaintInvalidationState& paintInvalidationState)
-{
-    // paintInvalidationStateIsDirty should be kept in sync with the
-    // booleans that are cleared below.
-    ASSERT(paintInvalidationState.forceCheckForPaintInvalidation() || paintInvalidationStateIsDirty());
-    setShouldDoFullPaintInvalidation(false);
-    setOnlyNeededPositionedMovementLayout(false);
-    setNeededLayoutBecauseOfChildren(false);
-    setShouldInvalidateOverflowForPaint(false);
-    setLayoutDidGetCalled(false);
-}
-
 bool RenderObject::isAllowedToModifyRenderTreeStructure(Document& document)
 {
     return document.lifecycle().stateAllowsRenderTreeMutations();
 }
 
 } // namespace blink
 
 #ifndef NDEBUG
 
 void showTree(const blink::RenderObject* object)
@@ skipping 17 matching lines @@
 {
     if (object1) {
         const blink::RenderObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showRenderTreeAndMark(object1, "*", object2, "-", 0);
     }
 }
 
 #endif