Disentangle blend mode from updateDescendantDependentFlags

Source/core/rendering/RenderLayer.h

 /*
  * Copyright (C) 2003, 2009, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. 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>
@@ skipping 30 matching lines @@
  * If you do not delete the provisions above, a recipient may use your
  * version of this file under any of the LGPL, the MPL or the GPL.
  */
 
 #ifndef RenderLayer_h
 #define RenderLayer_h
 
 #include "core/rendering/LayerFragment.h"
 #include "core/rendering/LayerPaintingInfo.h"
 #include "core/rendering/RenderBox.h"
-#include "core/rendering/RenderLayerBlendInfo.h"
 #include "core/rendering/RenderLayerClipper.h"
 #include "core/rendering/RenderLayerFilterInfo.h"
 #include "core/rendering/RenderLayerReflectionInfo.h"
 #include "core/rendering/RenderLayerRepainter.h"
 #include "core/rendering/RenderLayerScrollableArea.h"
 #include "core/rendering/RenderLayerStackingNode.h"
 #include "core/rendering/RenderLayerStackingNodeIterator.h"
 #include "platform/graphics/CompositingReasons.h"
+#include "public/platform/WebBlendMode.h"
 #include "wtf/OwnPtr.h"
 
 namespace blink {
 
 class FilterEffectRenderer;
 class FilterOperations;
 class HitTestRequest;
 class HitTestResult;
 class HitTestingTransformState;
 class CompositedLayerMapping;
@@ skipping 321 matching lines @@
         // FIXME: This is not in sync with containingBlock.
         // RenderObject::canContainFixedPositionedObject() should probably be used
         // instead.
         RenderLayerModelObject* layerRenderer = renderer();
         return isRootLayer() || layerRenderer->isPositioned() || hasTransform();
     }
 
     // paintLayer() assumes that the caller will clip to the bounds of the painting dirty if necessary.
     void paintLayer(GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags);
 
-    RenderLayerBlendInfo& blendInfo() { return m_blendInfo; }
-
     bool scrollsOverflow() const;
 
     CompositingReasons potentialCompositingReasonsFromStyle() const { return m_potentialCompositingReasonsFromStyle; }
     void setPotentialCompositingReasonsFromStyle(CompositingReasons reasons) { ASSERT(reasons == (reasons & CompositingReasonComboAllStyleDeterminedReasons)); m_potentialCompositingReasonsFromStyle = reasons; }
 
     bool hasStyleDeterminedDirectCompositingReasons() const { return m_potentialCompositingReasonsFromStyle & CompositingReasonComboAllDirectStyleDeterminedReasons; }
 
     class AncestorDependentCompositingInputs {
     public:
         AncestorDependentCompositingInputs()
@@ skipping 40 matching lines @@
         // bounds of scrolling content for overlap the same way we're doing for
         // animation and only promote what's necessary. Once we're doing that,
         // we won't need to use the "unclipped" concept for promotion any
         // longer.
         unsigned isUnclippedDescendant : 1;
         unsigned hasAncestorWithClipPath : 1;
     };
 
     class DescendantDependentCompositingInputs {
     public:
-        DescendantDependentCompositingInputs() : hasDescendantWithClipPath(false) { }
+        DescendantDependentCompositingInputs()
+            : hasDescendantWithClipPath(false)
+            , hasDescendantWithBlendMode(false)
+        { }
+
         unsigned hasDescendantWithClipPath : 1;
+        unsigned hasDescendantWithBlendMode : 1;
     };
 
     void setNeedsCompositingInputsUpdate();
     bool childNeedsCompositingInputsUpdate() const { return m_childNeedsCompositingInputsUpdate; }
     bool needsCompositingInputsUpdate() const
     {
         // While we're updating the compositing inputs, these values may differ.
         // We should never be asking for this value when that is the case.
         ASSERT(m_needsDescendantDependentCompositingInputsUpdate == m_needsAncestorDependentCompositingInputsUpdate);
         return m_needsDescendantDependentCompositingInputsUpdate;
@@ skipping 10 matching lines @@
     const RenderLayer* opacityAncestor() const { return ancestorDependentCompositingInputs().opacityAncestor; }
     const RenderLayer* transformAncestor() const { return ancestorDependentCompositingInputs().transformAncestor; }
     const RenderLayer* filterAncestor() const { return ancestorDependentCompositingInputs().filterAncestor; }
     const RenderObject* clippingContainer() const { return ancestorDependentCompositingInputs().clippingContainer; }
     const RenderLayer* ancestorScrollingLayer() const { return ancestorDependentCompositingInputs().ancestorScrollingLayer; }
     RenderLayer* scrollParent() const { return const_cast<RenderLayer*>(ancestorDependentCompositingInputs().scrollParent); }
     RenderLayer* clipParent() const { return const_cast<RenderLayer*>(ancestorDependentCompositingInputs().clipParent); }
     bool isUnclippedDescendant() const { return ancestorDependentCompositingInputs().isUnclippedDescendant; }
     bool hasAncestorWithClipPath() const { return ancestorDependentCompositingInputs().hasAncestorWithClipPath; }
     bool hasDescendantWithClipPath() const { return descendantDependentCompositingInputs().hasDescendantWithClipPath; }
+    bool hasDescendantWithBlendMode() const { return descendantDependentCompositingInputs().hasDescendantWithBlendMode; }
 
     bool lostGroupedMapping() const { ASSERT(isAllowedToQueryCompositingState()); return m_lostGroupedMapping; }
     void setLostGroupedMapping(bool b) { m_lostGroupedMapping = b; }
 
     CompositingReasons compositingReasons() const { ASSERT(isAllowedToQueryCompositingState()); return m_compositingReasons; }
     void setCompositingReasons(CompositingReasons, CompositingReasons mask = CompositingReasonAll);
 
     bool hasCompositingDescendant() const { ASSERT(isAllowedToQueryCompositingState()); return m_hasCompositingDescendant; }
     void setHasCompositingDescendant(bool);
 
@@ skipping 222 matching lines @@
 
     OwnPtr<CompositedLayerMapping> m_compositedLayerMapping;
     OwnPtr<RenderLayerScrollableArea> m_scrollableArea;
 
     CompositedLayerMapping* m_groupedMapping;
 
     RenderLayerRepainter m_repainter;
     RenderLayerClipper m_clipper; // FIXME: Lazily allocate?
     OwnPtr<RenderLayerStackingNode> m_stackingNode;
     OwnPtrWillBePersistent<RenderLayerReflectionInfo> m_reflectionInfo;
-    RenderLayerBlendInfo m_blendInfo;
 
     LayoutSize m_subpixelAccumulation; // The accumulated subpixel offset of a composited layer's composited bounds compared to absolute coordinates.
 };
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showLayerTree(const blink::RenderLayer*);
 void showLayerTree(const blink::RenderObject*);
 #endif
 
 #endif // RenderLayer_h