Purge the ScrollBlocksOn code.

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 573 matching lines @@
   return layer_impl != NULL;
 }
 
 static LayerImpl* NextLayerInScrollOrder(LayerImpl* layer) {
   if (layer->scroll_parent())
     return layer->scroll_parent();
 
   return layer->parent();
 }
 
-static ScrollBlocksOn EffectiveScrollBlocksOn(LayerImpl* layer) {
-  ScrollBlocksOn blocks = SCROLL_BLOCKS_ON_NONE;
-  for (; layer; layer = NextLayerInScrollOrder(layer)) {
-    blocks |= layer->scroll_blocks_on();
-  }
-  return blocks;
-}
-
 bool LayerTreeHostImpl::DoTouchEventsBlockScrollAt(
     const gfx::Point& viewport_point) {
   gfx::PointF device_viewport_point = gfx::ScalePoint(
       gfx::PointF(viewport_point), active_tree_->device_scale_factor());
 
-  // First check if scrolling at this point is required to block on any
-  // touch event handlers.  Note that we must start at the innermost layer
-  // (as opposed to only the layer found to contain a touch handler region
-  // below) to ensure all relevant scroll-blocks-on values are applied.
-  LayerImpl* layer_impl =
-      active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
-  ScrollBlocksOn blocking = EffectiveScrollBlocksOn(layer_impl);
-  if (!(blocking & SCROLL_BLOCKS_ON_START_TOUCH))
-    return false;
-
   // Now determine if there are actually any handlers at that point.
   // TODO(rbyers): Consider also honoring touch-action (crbug.com/347272).
-  layer_impl = active_tree_->FindLayerThatIsHitByPointInTouchHandlerRegion(
-      device_viewport_point);
+  LayerImpl* layer_impl =
+      active_tree_->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          device_viewport_point);
   return layer_impl != NULL;
 }
 
 scoped_ptr<SwapPromiseMonitor>
 LayerTreeHostImpl::CreateLatencyInfoSwapPromiseMonitor(
     ui::LatencyInfo* latency) {
   return make_scoped_ptr(
       new LatencyInfoSwapPromiseMonitor(latency, NULL, this));
 }
 
@@ skipping 1852 matching lines @@
     InputHandler::ScrollInputType type,
     LayerImpl* layer_impl,
     bool* scroll_on_main_thread,
     bool* optional_has_ancestor_scroll_handler,
     uint32_t* main_thread_scrolling_reasons) const {
   DCHECK(scroll_on_main_thread);
   DCHECK(main_thread_scrolling_reasons);
   *main_thread_scrolling_reasons =
       MainThreadScrollingReason::kNotScrollingOnMain;
 
-  ScrollBlocksOn block_mode = EffectiveScrollBlocksOn(layer_impl);
-
   // Walk up the hierarchy and look for a scrollable layer.
   LayerImpl* potentially_scrolling_layer_impl = NULL;
   for (; layer_impl; layer_impl = NextLayerInScrollOrder(layer_impl)) {
     // The content layer can also block attempts to scroll outside the main
     // thread.
-    ScrollStatus status =
-        layer_impl->TryScroll(device_viewport_point, type, block_mode);
+    ScrollStatus status = layer_impl->TryScroll(device_viewport_point, type);
     if (status.thread == SCROLL_ON_MAIN_THREAD) {
       if (layer_impl->should_scroll_on_main_thread()) {
         DCHECK_LE(status.main_thread_scrolling_reasons,
                   MainThreadScrollingReason::kMaxNonTransientScrollingReasons);
       } else {
         DCHECK_GT(status.main_thread_scrolling_reasons,
                   MainThreadScrollingReason::kMaxNonTransientScrollingReasons);
       }
 
       *scroll_on_main_thread = true;
       *main_thread_scrolling_reasons = status.main_thread_scrolling_reasons;
       return NULL;
     }
 
     LayerImpl* scroll_layer_impl = FindScrollLayerForContentLayer(layer_impl);
     if (!scroll_layer_impl)
       continue;
 
-    status =
-        scroll_layer_impl->TryScroll(device_viewport_point, type, block_mode);
+    status = scroll_layer_impl->TryScroll(device_viewport_point, type);
 
     // If any layer wants to divert the scroll event to the main thread, abort.
     if (status.thread == SCROLL_ON_MAIN_THREAD) {
       if (layer_impl->should_scroll_on_main_thread()) {
         DCHECK_LE(status.main_thread_scrolling_reasons,
                   MainThreadScrollingReason::kMaxNonTransientScrollingReasons);
       } else {
         DCHECK_GT(status.main_thread_scrolling_reasons,
                   MainThreadScrollingReason::kMaxNonTransientScrollingReasons);
       }
@@ skipping 1388 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc