Revert of Move logic of recording main thread scrolling reasons from cc to blink::ScrollManager

third_party/WebKit/Source/core/paint/PaintLayerScrollableArea.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@gmail.com>
@@ skipping 96 matching lines @@
       rebuild_horizontal_scrollbar_layer_(false),
       rebuild_vertical_scrollbar_layer_(false),
       needs_scroll_offset_clamp_(false),
       needs_relayout_(false),
       had_horizontal_scrollbar_before_relayout_(false),
       had_vertical_scrollbar_before_relayout_(false),
       scrollbar_manager_(*this),
       scroll_corner_(nullptr),
       resizer_(nullptr),
       scroll_anchor_(this),
-      non_composited_main_thread_scrolling_reasons_(0)
+      reasons_(0)
 #if DCHECK_IS_ON()
       ,
       has_been_disposed_(false)
 #endif
 {
   Node* node = Box().GetNode();
   if (node && node->IsElementNode()) {
     // We save and restore only the scrollOffset as the other scroll values are
     // recalculated.
     Element* element = ToElement(node);
@@ skipping 17 matching lines @@
       frame->GetEventHandler().ResizeScrollableAreaDestroyed();
   }
 
   if (LocalFrame* frame = Box().GetFrame()) {
     if (FrameView* frame_view = frame->View()) {
       frame_view->RemoveScrollableArea(this);
       frame_view->RemoveAnimatingScrollableArea(this);
     }
   }
 
-  non_composited_main_thread_scrolling_reasons_ = 0;
+  RemoveStyleRelatedMainThreadScrollingReasons();
 
   if (ScrollingCoordinator* scrolling_coordinator = GetScrollingCoordinator())
     scrolling_coordinator->WillDestroyScrollableArea(this);
 
   if (!Box().DocumentBeingDestroyed()) {
     Node* node = Box().GetNode();
     // FIXME: Make setSavedLayerScrollOffset take DoubleSize. crbug.com/414283.
     if (node && node->IsElementNode())
       ToElement(node)->SetSavedLayerScrollOffset(scroll_offset_);
   }
@@ skipping 1623 matching lines @@
   if (LocalFrame* frame = Box().GetFrame()) {
     if (frame->View()->GetMainThreadScrollingReasons())
       return true;
   }
   return ScrollableArea::ShouldScrollOnMainThread();
 }
 
 bool PaintLayerScrollableArea::ComputeNeedsCompositedScrolling(
     const LCDTextMode mode,
     const PaintLayer* layer) {
-  non_composited_main_thread_scrolling_reasons_ = 0;
   if (!layer->ScrollsOverflow())
     return false;
 
   Node* node = layer->EnclosingNode();
   if (node && node->IsElementNode() &&
       (ToElement(node)->CompositorMutableProperties() &
        (CompositorMutableProperty::kScrollTop |
         CompositorMutableProperty::kScrollLeft)))
     return true;
 
   if (layer->size().IsEmpty())
     return false;
 
   bool needs_composited_scrolling = true;
+  uint32_t main_thread_scrolling_reasons = 0;
 
   // TODO(flackr): Allow integer transforms as long as all of the ancestor
   // transforms are also integer.
   bool background_supports_lcd_text =
       RuntimeEnabledFeatures::compositeOpaqueScrollersEnabled() &&
       layer->GetLayoutObject().Style()->IsStackingContext() &&
-      layer->GetBackgroundPaintLocation(
-          &non_composited_main_thread_scrolling_reasons_) &
+      layer->GetBackgroundPaintLocation(&main_thread_scrolling_reasons) &
           kBackgroundPaintInScrollingContents &&
       layer->BackgroundIsKnownToBeOpaqueInRect(
           ToLayoutBox(layer->GetLayoutObject()).PaddingBoxRect()) &&
       !layer->CompositesWithTransform() && !layer->CompositesWithOpacity();
 
   if (mode == PaintLayerScrollableArea::kConsiderLCDText &&
       !layer->Compositor()->PreferCompositingToLCDTextEnabled() &&
       !background_supports_lcd_text) {
     if (layer->CompositesWithOpacity()) {
-      non_composited_main_thread_scrolling_reasons_ |=
+      main_thread_scrolling_reasons |=
           MainThreadScrollingReason::kHasOpacityAndLCDText;
     }
     if (layer->CompositesWithTransform()) {
-      non_composited_main_thread_scrolling_reasons_ |=
+      main_thread_scrolling_reasons |=
           MainThreadScrollingReason::kHasTransformAndLCDText;
     }
     if (!layer->BackgroundIsKnownToBeOpaqueInRect(
             ToLayoutBox(layer->GetLayoutObject()).PaddingBoxRect())) {
-      non_composited_main_thread_scrolling_reasons_ |=
+      main_thread_scrolling_reasons |=
           MainThreadScrollingReason::kBackgroundNotOpaqueInRectAndLCDText;
     }
 
     needs_composited_scrolling = false;
   }
 
   // TODO(schenney) Tests fail if we do not also exclude
   // layer->layoutObject().style()->hasBorderDecoration() (missing background
   // behind dashed borders). Resolve this case, or not, and update this check
   // with the results.
   if (layer->GetLayoutObject().Style()->HasBorderRadius()) {
-    non_composited_main_thread_scrolling_reasons_ |=
+    main_thread_scrolling_reasons |=
         MainThreadScrollingReason::kHasBorderRadius;
     needs_composited_scrolling = false;
   }
   if (layer->GetLayoutObject().HasClip() ||
       layer->HasDescendantWithClipPath() || layer->HasAncestorWithClipPath()) {
-    non_composited_main_thread_scrolling_reasons_ |=
+    main_thread_scrolling_reasons |=
         MainThreadScrollingReason::kHasClipRelatedProperty;
     needs_composited_scrolling = false;
   }
 
-  DCHECK(!(non_composited_main_thread_scrolling_reasons_ &
-           ~MainThreadScrollingReason::kNonCompositedReasons));
+  if (main_thread_scrolling_reasons) {
+    AddStyleRelatedMainThreadScrollingReasons(main_thread_scrolling_reasons);
+  }
+
   return needs_composited_scrolling;
 }
 
+void PaintLayerScrollableArea::AddStyleRelatedMainThreadScrollingReasons(
+    const uint32_t reasons) {
+  LocalFrame* frame = Box().GetFrame();
+  if (!frame)
+    return;
+  FrameView* frame_view = frame->View();
+  if (!frame_view)
+    return;
+
+  for (uint32_t reason = 1;
+       reason < 1 << MainThreadScrollingReason::kMainThreadScrollingReasonCount;
+       reason <<= 1) {
+    if (reasons & reason) {
+      frame_view->AdjustStyleRelatedMainThreadScrollingReasons(reason, true);
+      reasons_ |= reason;
+    }
+  }
+}
+
+void PaintLayerScrollableArea::RemoveStyleRelatedMainThreadScrollingReasons() {
+  LocalFrame* frame = Box().GetFrame();
+  if (!frame)
+    return;
+  FrameView* frame_view = frame->View();
+  if (!frame_view)
+    return;
+
+  // Decrease the number of layers that have any main thread
+  // scrolling reasons stored in FrameView
+  for (uint32_t i = 0;
+       i < MainThreadScrollingReason::kMainThreadScrollingReasonCount; ++i) {
+    uint32_t reason = 1 << i;
+    if (HasMainThreadScrollingReason(reason)) {
+      reasons_ &= ~reason;
+      frame_view->AdjustStyleRelatedMainThreadScrollingReasons(reason, false);
+    }
+  }
+}
+
 void PaintLayerScrollableArea::UpdateNeedsCompositedScrolling(
     LCDTextMode mode) {
+  // Clear all style related main thread scrolling reasons, if any,
+  // before calling computeNeedsCompositedScrolling
+  RemoveStyleRelatedMainThreadScrollingReasons();
   const bool needs_composited_scrolling =
       ComputeNeedsCompositedScrolling(mode, Layer());
 
   if (static_cast<bool>(needs_composited_scrolling_) !=
       needs_composited_scrolling) {
     needs_composited_scrolling_ = needs_composited_scrolling;
     Layer()->DidUpdateNeedsCompositedScrolling();
   }
 }
 
@@ skipping 253 matching lines @@
 
 void PaintLayerScrollableArea::DelayScrollOffsetClampScope::
     ClampScrollableAreas() {
   for (auto& scrollable_area : *needs_clamp_)
     scrollable_area->ClampScrollOffsetAfterOverflowChange();
   delete needs_clamp_;
   needs_clamp_ = nullptr;
 }
 
 }  // namespace blink