Fix the bug that sticky element may not be correctly invalidated due to non-promotion

third_party/WebKit/Source/core/layout/compositing/CompositingRequirementsUpdater.cpp

 /*
  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 129 matching lines @@
   Vector<OverlapMapContainers> overlap_stack_;
 };
 
 class CompositingRequirementsUpdater::RecursionData {
  public:
   explicit RecursionData(PaintLayer* compositing_ancestor)
       : compositing_ancestor_(compositing_ancestor),
         subtree_is_compositing_(false),
         has_unisolated_composited_blending_descendant_(false),
         testing_overlap_(true),
+        has_composited_non_root_ancestor_(false),
         has_composited_scrolling_ancestor_(false) {}
 
   PaintLayer* compositing_ancestor_;
   bool subtree_is_compositing_;
   bool has_unisolated_composited_blending_descendant_;
   bool testing_overlap_;
+  // Ancestors may be composited but not have composited scrolling layer.
+  bool has_composited_non_root_ancestor_;
   bool has_composited_scrolling_ancestor_;
 };
 
 static bool RequiresCompositingOrSquashing(CompositingReasons reasons) {
 #if DCHECK_IS_ON()
   bool fast_answer = reasons != kCompositingReasonNone;
   bool slow_answer = RequiresCompositing(reasons) || RequiresSquashing(reasons);
   DCHECK_EQ(slow_answer, fast_answer);
 #endif
   return reasons != kCompositingReasonNone;
@@ skipping 200 matching lines @@
   }
 
   reasons_to_composite |= overlap_compositing_reason;
 
   // The children of this layer don't need to composite, unless there is
   // a compositing layer among them, so start by inheriting the compositing
   // ancestor with m_subtreeIsCompositing set to false.
   RecursionData child_recursion_data = current_recursion_data;
   child_recursion_data.subtree_is_compositing_ = false;
 
+  if (layer->SticksToScroller() &&
+      layer->AncestorOverflowLayer()->ScrollsOverflow() &&
+      current_recursion_data.has_composited_non_root_ancestor_) {
+    reasons_to_composite |= kCompositingReasonScrollDependentPosition;

[chrishtr, 2017/05/10 17:48:44]

You don't need current_recursion_data.has_composited_non_root_ancestor_. 

Instead:

if (layer->SticksToScroller() && 
    layer->AncestorScrollingLayer() &&
    current_recursion_data.compositing_ancestor_ &&
// It's actually only needed if the ancestor scrolling layer of
compositing_ancestor_ is below
// the scroller |layer| sticks to, but that is more complicated to compute.
    current_recursion_data.compositing_ancestor_->AncestorScrollingLayer() &&
   
!current_recursion_data.compositing_ancestor_->AncestorScrollingLayer()->IsRoot())
{
  reasons_to_composite |= kCompositingReasonScrollDependentPosition;
}

[yigu, 2017/05/10 18:04:13]

Done.

+  }
+
   bool will_be_composited_or_squashed =
       can_be_composited && RequiresCompositingOrSquashing(reasons_to_composite);
   if (will_be_composited_or_squashed) {
     // This layer now acts as the ancestor for kids.
     child_recursion_data.compositing_ancestor_ = layer;
 
     // Here we know that all children and the layer's own contents can blindly
     // paint into this layer's backing, until a descendant is composited. So, we
     // don't need to check for overlap with anything behind this layer.
     overlap_map.BeginNewOverlapTestingContext();
     // This layer is going to be composited, so children can safely ignore the
     // fact that there's an animation running behind this layer, meaning they
     // can rely on the overlap map testing again.
     child_recursion_data.testing_overlap_ = true;
+
+    // Tell the descendants they have composited non-root ancestor.
+    if (!layer->IsRootLayer())
+      child_recursion_data.has_composited_non_root_ancestor_ = true;
   }
 
 #if DCHECK_IS_ON()
   LayerListMutationDetector mutation_checker(layer->StackingNode());
 #endif
 
   bool any_descendant_has3d_transform = false;
   bool will_have_foreground_layer = false;
 
   if (layer->StackingNode()->IsStackingContext()) {
@@ skipping 157 matching lines @@
     descendant_has3d_transform |=
         any_descendant_has3d_transform || layer->Has3DTransform();
   }
 
   // At this point we have finished collecting all reasons to composite this
   // layer.
   layer->SetCompositingReasons(reasons_to_composite);
 }
 
 }  // namespace blink