Only scroll on main if the targeted frames need to scroll on main

third_party/WebKit/Source/core/frame/FrameView.cpp

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
@@ skipping 176 matching lines @@
       m_hiddenForThrottling(false),
       m_subtreeThrottled(false),
       m_lifecycleUpdatesThrottled(false),
       m_needsPaintPropertyUpdate(true),
       m_currentUpdateLifecyclePhasesTargetState(
           DocumentLifecycle::Uninitialized),
       m_scrollAnchor(this),
       m_scrollbarManager(*this),
       m_needsScrollbarsUpdate(false),
       m_suppressAdjustViewSize(false),
-      m_allowsLayoutInvalidationAfterLayoutClean(true) {
+      m_allowsLayoutInvalidationAfterLayoutClean(true),
+      m_lastMainThreadScrollingReasons(0) {
   init();
 }
 
 FrameView* FrameView::create(LocalFrame& frame) {
   FrameView* view = new FrameView(frame);
   view->show();
   return view;
 }
 
 FrameView* FrameView::create(LocalFrame& frame, const IntSize& initialSize) {
@@ skipping 42 matching lines @@
   m_firstLayout = true;
   m_safeToPropagateScrollToParent = true;
   m_lastViewportSize = IntSize();
   m_lastZoomFactor = 1.0f;
   m_trackedObjectPaintInvalidations = WTF::wrapUnique(
       s_initialTrackAllPaintInvalidations ? new Vector<ObjectPaintInvalidation>
                                           : nullptr);
   m_visuallyNonEmptyCharacterCount = 0;
   m_visuallyNonEmptyPixelCount = 0;
   m_isVisuallyNonEmpty = false;
+  m_lastMainThreadScrollingReasons = 0;
   m_layoutObjectCounter.reset();
   clearFragmentAnchor();
   m_viewportConstrainedObjects.reset();
   m_layoutSubtreeRootList.clear();
   m_orthogonalWritingModeRootList.clear();
 }
 
 // Call function for each non-throttled frame view in pre tree order.
 // Note it needs a null check of the frame's layoutView to access it in case of
 // detached frames.
@@ skipping 547 matching lines @@
   LayoutViewItem layoutView = this->layoutViewItem();
   if (layoutView.isNull())
     return false;
   if (m_frame->settings() &&
       m_frame->settings()->preferCompositingToLCDTextEnabled())
     return layoutView.compositor()->inCompositingMode();
   return false;
 }
 
 bool FrameView::shouldScrollOnMainThread() const {
-  if (ScrollingCoordinator* sc = scrollingCoordinator()) {
-    if (sc->shouldUpdateScrollLayerPositionOnMainThread())
-      return true;
-  }
+  if (mainThreadScrollingReasons())
+    return true;
   return ScrollableArea::shouldScrollOnMainThread();
 }
 
 GraphicsLayer* FrameView::layerForScrolling() const {
   LayoutViewItem layoutView = this->layoutViewItem();
   if (layoutView.isNull())
     return nullptr;
   return layoutView.compositor()->frameScrollLayer();
 }
 
@@ skipping 3831 matching lines @@
 int FrameView::initialViewportWidth() const {
   DCHECK(m_frame->isMainFrame());
   return m_initialViewportSize.width();
 }
 
 int FrameView::initialViewportHeight() const {
   DCHECK(m_frame->isMainFrame());
   return m_initialViewportSize.height();
 }
 
+bool FrameView::hasVisibleSlowRepaintViewportConstrainedObjects(

[pdr., 2016/12/17 05:50:16]

Nit: I don't think you need to pass in frameView here, just make this a member
function on FrameView.

E.g.:
bool FrameView::hasVisibleSlowRepaintViewportConstrainedObjects() const {
  if (!viewportConstrainedObjects())
    return false;
  for (const auto* layoutObject : *viewportConstrainedObjects()) {
...etc...

[yigu, 2016/12/18 17:57:11]

Done.

+    const FrameView& frameView) const {
+  const ViewportConstrainedObjectSet* viewportConstrainedObjects =
+      frameView.viewportConstrainedObjects();
+  if (!viewportConstrainedObjects)
+    return false;
+
+  for (const LayoutObject* layoutObject : *viewportConstrainedObjects) {
+    DCHECK(layoutObject->isBoxModelObject() && layoutObject->hasLayer());
+    DCHECK(layoutObject->style()->position() == FixedPosition ||
+           layoutObject->style()->position() == StickyPosition);
+    PaintLayer* layer = toLayoutBoxModelObject(layoutObject)->layer();
+
+    // Whether the Layer sticks to the viewport is a tree-depenent
+    // property and our viewportConstrainedObjects collection is maintained
+    // with only LayoutObject-level information.
+    if (!layer->sticksToViewport())
+      continue;
+
+    // If the whole subtree is invisible, there's no reason to scroll on
+    // the main thread because we don't need to generate invalidations
+    // for invisible content.
+    if (layer->subtreeIsInvisible())
+      continue;
+
+    // We're only smart enough to scroll viewport-constrainted objects
+    // in the compositor if they have their own backing or they paint
+    // into a grouped back (which necessarily all have the same viewport
+    // constraints).
+    CompositingState compositingState = layer->compositingState();
+    if (compositingState != PaintsIntoOwnBacking &&
+        compositingState != PaintsIntoGroupedBacking)
+      return true;
+  }
+  return false;
+}
+
+void FrameView::updateSubFrameScrollOnMainReason(
+    const Frame& frame,
+    MainThreadScrollingReasons parentReason) {
+  MainThreadScrollingReasons reasons = parentReason;
+
+  if (!page()->settings().threadedScrollingEnabled())
+    reasons |= MainThreadScrollingReason::kThreadedScrollingDisabled;
+
+  if (!frame.isLocalFrame())
+    return;
+
+  if (!toLocalFrame(frame).view()->layerForScrolling())
+    return;
+
+  reasons |= mainThreadScrollingReasonsPerFrame(*toLocalFrame(&frame));
+  if (WebLayer* scrollLayer =
+          toLocalFrame(frame).view()->layerForScrolling()->platformLayer()) {
+    if (reasons) {
+      scrollLayer->addMainThreadScrollingReasons(reasons);
+    } else {
+      scrollLayer->clearMainThreadScrollingReasons(
+          ~0 & ~MainThreadScrollingReason::kHandlingScrollFromMainThread);

[pdr., 2016/12/17 05:50:16]

What is ~0 for?

[yigu, 2016/12/18 17:57:11]

That was silly..

+    }
+  }
+
+  Frame* child = frame.tree().firstChild();
+  while (child) {
+    updateSubFrameScrollOnMainReason(*child, reasons);
+    child = child->tree().nextSibling();
+  }
+
+  if (frame.isMainFrame())
+    m_lastMainThreadScrollingReasons = reasons;
+}
+
+MainThreadScrollingReasons FrameView::mainThreadScrollingReasonsPerFrame(

[pdr., 2016/12/17 05:50:16]

Is "const LocalFrame& frame" needed? Similar to
hasVisibleSlowRepaintViewportConstrainedObjects, I think this can be refactored
as a member function:
MainThreadScrollingReasons FrameView::localMainThreadScrollingReasons() const {
  MainThreadScrollingReasons reasons =
      static_cast<MainThreadScrollingReasons>(0);
  if (shouldThrottleRendering())
    return reasons;
  ...etc...

In FrameView.h, can you add a very short comment above
mainThreadScrollingReasons and localMainThreadScrollingReasons describing the
difference?
Maybe something like:
// Main thread scrolling reasons including reasons from ancestors.
MainThreadScrollingReasons mainThreadScrollingReasons();

private:
// Main thread scrolling reasons for this object only. For all reasons,
// see: mainThreadScrollingReasons().
MainThreadScrollingReasons localMainThreadScrollingReasons() const;

[yigu, 2016/12/18 17:57:11]

Done.

+    const LocalFrame& frame) const {
+  MainThreadScrollingReasons reasons =
+      static_cast<MainThreadScrollingReasons>(0);
+
+  FrameView* frameView = frame.view();
+  if (!frameView || frameView->shouldThrottleRendering())
+    return reasons;
+
+  if (frameView->hasBackgroundAttachmentFixedObjects())
+    reasons |= MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects;
+  ScrollingReasons scrollingReasons = frameView->getScrollingReasons();
+  const bool mayBeScrolledByInput = (scrollingReasons == Scrollable);
+  const bool mayBeScrolledByScript =
+      mayBeScrolledByInput ||
+      (scrollingReasons == NotScrollableExplicitlyDisabled);
+
+  // TODO(awoloszyn) Currently crbug.com/304810 will let certain
+  // overflow:hidden elements scroll on the compositor thread, so we should
+  // not let this move there path as an optimization, when we have
+  // slow-repaint elements.
+  if (mayBeScrolledByScript &&
+      hasVisibleSlowRepaintViewportConstrainedObjects(*frameView)) {
+    reasons |=
+        MainThreadScrollingReason::kHasNonLayerViewportConstrainedObjects;
+  }
+  return reasons;
+}
+
+MainThreadScrollingReasons FrameView::mainThreadScrollingReasons() const {
+  MainThreadScrollingReasons reasons =
+      static_cast<MainThreadScrollingReasons>(0);
+
+  if (!page()->settings().threadedScrollingEnabled())
+    reasons |= MainThreadScrollingReason::kThreadedScrollingDisabled;
+
+  if (!page()->mainFrame()->isLocalFrame())
+    return reasons;
+
+  // TODO(alexmos,kenrb): For OOPIF, local roots that are different from
+  // the main frame can't be used in the calculation, since they use
+  // different compositors with unrelated state, which breaks some of the
+  // calculations below.
+  if (m_frame->localFrameRoot() != page()->mainFrame())
+    return reasons;
+
+  // Walk through the subtree from the target frame to root. Use the gathered

[pdr., 2016/12/17 05:50:16]

Nit: Update this to reflect that the function is now on FrameView.

e.g., Walk the tree to the root. Use the gathered reasons...etc

[yigu, 2016/12/18 17:57:11]

Done.

+  // reasons to determine whether the target frame should be scrolled on main
+  // thread regardless other subframes on the same page.
+  for (Frame* frame = m_frame; frame; frame = frame->tree().parent()) {
+    if (!frame->isLocalFrame())
+      continue;
+    reasons |= mainThreadScrollingReasonsPerFrame(*toLocalFrame(frame));
+  }
+
+  return reasons;
+}
+
+String FrameView::mainThreadScrollingReasonsAsText() const {
+  DCHECK(lifecycle().state() >= DocumentLifecycle::CompositingClean);
+  if (layerForScrolling() && layerForScrolling()->platformLayer()) {
+    String result(
+        MainThreadScrollingReason::mainThreadScrollingReasonsAsText(
+            layerForScrolling()->platformLayer()->mainThreadScrollingReasons())
+            .c_str());
+    return result;
+  }
+
+  String result(MainThreadScrollingReason::mainThreadScrollingReasonsAsText(
+                    m_lastMainThreadScrollingReasons)
+                    .c_str());
+  return result;
+}
+
 }  // namespace blink