Implement CSS: scroll-boundary-behavior

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 3037 matching lines @@
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
     const gfx::Point& viewport_point,
     const gfx::Vector2dF& scroll_delta,
     base::TimeDelta delayed_by) {
   InputHandler::ScrollStatus scroll_status;
   scroll_status.main_thread_scrolling_reasons =
       MainThreadScrollingReason::kNotScrollingOnMain;
   ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;
   ScrollNode* scroll_node = scroll_tree.CurrentlyScrollingNode();
+  bool x_dominated = (std::abs(scroll_delta.x()) > std::abs(scroll_delta.y()));

[bokan, 2017/06/30 15:44:11]

nit: no need for outer parentheses

[sunyunjia, 2017/06/30 18:26:57]

Done.

 
   if (scroll_node) {
     // Flash the overlay scrollbar even if the scroll dalta is 0.
     ScrollbarAnimationController* animation_controller =
         ScrollbarAnimationControllerForElementId(scroll_node->element_id);
 
     if (animation_controller)
       animation_controller->WillUpdateScroll();
 
     gfx::Vector2dF delta = scroll_delta;
@@ skipping 59 matching lines @@
       }
 
       gfx::Vector2dF scroll_delta =
           ComputeScrollDelta(scroll_node, pending_delta);
       if (ScrollAnimationCreate(scroll_node, scroll_delta, delayed_by)) {
         scroll_animating_latched_node_id_ = scroll_node->id;
         return scroll_status;
       }
 
       pending_delta -= scroll_delta;
+
+      if ((x_dominated &&
+           scroll_node->scroll_boundary_behavior.x !=
+               ScrollBoundaryBehavior::kScrollBoundaryBehaviorTypeAuto) ||
+          (!x_dominated &&
+           scroll_node->scroll_boundary_behavior.y !=
+               ScrollBoundaryBehavior::kScrollBoundaryBehaviorTypeAuto))
+        break;
     }
   }
   scroll_state.set_is_ending(true);
   ScrollEnd(&scroll_state);
   if (settings_.is_layer_tree_for_subframe &&
       scroll_status.thread == SCROLL_ON_IMPL_THREAD) {
     // If we get to here, we shouldn't return SCROLL_ON_IMPL_THREAD as otherwise
     // we'll mark the scroll as handled and the scroll won't bubble.
     scroll_status.thread = SCROLL_IGNORED;
     scroll_status.main_thread_scrolling_reasons =
@@ skipping 215 matching lines @@
   // is not the case here. We eventually want to have the same behaviour on both
   // sides but it may become a non issue if we get rid of scroll chaining (see
   // crbug.com/526462)
   std::list<ScrollNode*> current_scroll_chain;
   ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;
   ScrollNode* scroll_node = scroll_tree.CurrentlyScrollingNode();
   ScrollNode* viewport_scroll_node =
       viewport()->MainScrollLayer()
           ? scroll_tree.Node(viewport()->MainScrollLayer()->scroll_tree_index())
           : nullptr;
+  bool x_dominated =
+      (std::abs(scroll_state->delta_x()) > std::abs(scroll_state->delta_y()));

[bokan, 2017/06/30 15:44:11]

ditto

[sunyunjia, 2017/06/30 18:26:58]

Done.

+  if (scroll_state->is_beginning()) {
+    x_dominated = (std::abs(scroll_state->delta_x_hint()) >
+                   std::abs(scroll_state->delta_y_hint()));
+  }
   if (scroll_node) {
     // TODO(bokan): The loop checks for a null parent but don't we still want to
     // distribute to the root scroll node?
     for (; scroll_tree.parent(scroll_node);
          scroll_node = scroll_tree.parent(scroll_node)) {
       if (scroll_node == viewport_scroll_node) {
         // Don't chain scrolls past the outer viewport scroll layer. Once we
         // reach that, we should scroll the viewport which is represented by the
         // main viewport scroll layer.
         DCHECK(viewport_scroll_node);
         current_scroll_chain.push_front(viewport_scroll_node);
         break;
       }
 
-      if (!scroll_node->scrollable)
-        continue;
+      if (scroll_node->scrollable &&
+          CanConsumeDelta(scroll_node, *scroll_state))
+        current_scroll_chain.push_front(scroll_node);
 
-      if (CanConsumeDelta(scroll_node, *scroll_state))
-        current_scroll_chain.push_front(scroll_node);
+      if ((x_dominated &&
+           scroll_node->scroll_boundary_behavior.x !=
+               ScrollBoundaryBehavior::kScrollBoundaryBehaviorTypeAuto) ||
+          (!x_dominated &&
+           scroll_node->scroll_boundary_behavior.y !=
+               ScrollBoundaryBehavior::kScrollBoundaryBehaviorTypeAuto))
+        break;
     }
   }
   active_tree_->SetCurrentlyScrollingNode(
       current_scroll_chain.empty() ? nullptr : current_scroll_chain.back());
   scroll_state->set_scroll_chain_and_layer_tree(current_scroll_chain,
                                                 active_tree());
   scroll_state->DistributeToScrollChainDescendant();
 }
 
 bool LayerTreeHostImpl::CanConsumeDelta(ScrollNode* scroll_node,
@@ skipping 1003 matching lines @@
 
 void LayerTreeHostImpl::ShowScrollbarsForImplScroll(ElementId element_id) {
   if (!element_id)
     return;
   if (ScrollbarAnimationController* animation_controller =
           ScrollbarAnimationControllerForElementId(element_id))
     animation_controller->DidScrollUpdate();
 }
 
 }  // namespace cc