cc: Move TryScroll from LayerImpl to LayerTreeHostImpl

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 67 matching lines @@
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/latency_info_swap_promise_monitor.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
+#include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 namespace {
 
 // Small helper class that saves the current viewport location as the user sees
 // it and resets to the same location.
@@ skipping 2312 matching lines @@
 
 float LayerTreeHostImpl::CurrentTopControlsShownRatio() const {
   return active_tree_->CurrentTopControlsShownRatio();
 }
 
 void LayerTreeHostImpl::BindToClient(InputHandlerClient* client) {
   DCHECK(input_handler_client_ == NULL);
   input_handler_client_ = client;
 }
 
+InputHandler::ScrollStatus LayerTreeHostImpl::TryScroll(
+    const gfx::PointF& screen_space_point,
+    InputHandler::ScrollInputType type,
+    const ScrollTree& scroll_tree,
+    ScrollNode* scroll_node) const {
+  InputHandler::ScrollStatus scroll_status;
+  scroll_status.main_thread_scrolling_reasons =
+      MainThreadScrollingReason::kNotScrollingOnMain;
+  if (!!scroll_node->data.main_thread_scrolling_reasons) {
+    TRACE_EVENT0("cc", "LayerImpl::TryScroll: Failed ShouldScrollOnMainThread");
+    scroll_status.thread = InputHandler::SCROLL_ON_MAIN_THREAD;
+    scroll_status.main_thread_scrolling_reasons =
+        scroll_node->data.main_thread_scrolling_reasons;
+    return scroll_status;
+  }
+
+  gfx::Transform screen_space_transform =
+      scroll_tree.ScreenSpaceTransform(scroll_node->id);
+  if (!screen_space_transform.IsInvertible()) {
+    TRACE_EVENT0("cc", "LayerImpl::TryScroll: Ignored NonInvertibleTransform");
+    scroll_status.thread = InputHandler::SCROLL_IGNORED;
+    scroll_status.main_thread_scrolling_reasons =
+        MainThreadScrollingReason::kNonInvertibleTransform;
+    return scroll_status;
+  }
+
+  if (scroll_node->data.contains_non_fast_scrollable_region) {
+    bool clipped = false;
+    gfx::Transform inverse_screen_space_transform(
+        gfx::Transform::kSkipInitialization);
+    if (!screen_space_transform.GetInverse(&inverse_screen_space_transform)) {
+      // TODO(shawnsingh): We shouldn't be applying a projection if screen space
+      // transform is uninvertible here. Perhaps we should be returning
+      // SCROLL_ON_MAIN_THREAD in this case?
+    }
+
+    gfx::PointF hit_test_point_in_layer_space = MathUtil::ProjectPoint(
+        inverse_screen_space_transform, screen_space_point, &clipped);
+    if (!clipped &&
+        active_tree()
+            ->LayerById(scroll_node->owner_id)
+            ->non_fast_scrollable_region()
+            .Contains(gfx::ToRoundedPoint(hit_test_point_in_layer_space))) {
+      TRACE_EVENT0("cc",
+                   "LayerImpl::tryScroll: Failed NonFastScrollableRegion");
+      scroll_status.thread = InputHandler::SCROLL_ON_MAIN_THREAD;
+      scroll_status.main_thread_scrolling_reasons =
+          MainThreadScrollingReason::kNonFastScrollableRegion;
+      return scroll_status;
+    }
+  }
+
+  if (type == InputHandler::WHEEL || type == InputHandler::ANIMATED_WHEEL) {
+    EventListenerProperties event_properties =
+        active_tree()->event_listener_properties(
+            EventListenerClass::kMouseWheel);
+    if (event_properties == EventListenerProperties::kBlocking ||
+        event_properties == EventListenerProperties::kBlockingAndPassive ||
+        (!active_tree()->settings().use_mouse_wheel_gestures &&
+         event_properties == EventListenerProperties::kPassive)) {
+      TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed WheelEventHandlers");
+      scroll_status.thread = InputHandler::SCROLL_ON_MAIN_THREAD;
+      scroll_status.main_thread_scrolling_reasons =
+          MainThreadScrollingReason::kEventHandlers;
+      return scroll_status;
+    }
+  }
+
+  if (!scroll_node->data.scrollable) {
+    TRACE_EVENT0("cc", "LayerImpl::tryScroll: Ignored not scrollable");
+    scroll_status.thread = InputHandler::SCROLL_IGNORED;
+    scroll_status.main_thread_scrolling_reasons =
+        MainThreadScrollingReason::kNotScrollable;
+    return scroll_status;
+  }
+
+  gfx::ScrollOffset max_scroll_offset =
+      scroll_tree.MaxScrollOffset(scroll_node->id);
+  if (max_scroll_offset.x() <= 0 && max_scroll_offset.y() <= 0) {
+    TRACE_EVENT0("cc",
+                 "LayerImpl::tryScroll: Ignored. Technically scrollable,"
+                 " but has no affordance in either direction.");
+    scroll_status.thread = InputHandler::SCROLL_IGNORED;
+    scroll_status.main_thread_scrolling_reasons =
+        MainThreadScrollingReason::kNotScrollable;
+    return scroll_status;
+  }
+
+  scroll_status.thread = InputHandler::SCROLL_ON_IMPL_THREAD;
+  return scroll_status;
+}
+
 LayerImpl* LayerTreeHostImpl::FindScrollLayerForDeviceViewportPoint(
     const gfx::PointF& device_viewport_point,
     InputHandler::ScrollInputType type,
     LayerImpl* layer_impl,
     bool* scroll_on_main_thread,
     uint32_t* main_thread_scrolling_reasons) const {
   DCHECK(scroll_on_main_thread);
   DCHECK(main_thread_scrolling_reasons);
   *main_thread_scrolling_reasons =
       MainThreadScrollingReason::kNotScrollingOnMain;
 
   // Walk up the hierarchy and look for a scrollable layer.
   LayerImpl* potentially_scrolling_layer_impl = NULL;
   if (layer_impl) {
     ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;
     ScrollNode* scroll_node = scroll_tree.Node(layer_impl->scroll_tree_index());
     for (; scroll_tree.parent(scroll_node);
          scroll_node = scroll_tree.parent(scroll_node)) {
-      layer_impl = active_tree_->LayerById(scroll_node->owner_id);
       // The content layer can also block attempts to scroll outside the main
       // thread.
-      ScrollStatus status = layer_impl->TryScroll(device_viewport_point, type);
+      ScrollStatus status =
+          TryScroll(device_viewport_point, type, scroll_tree, scroll_node);
       if (status.thread == SCROLL_ON_MAIN_THREAD) {
-        if (layer_impl->should_scroll_on_main_thread()) {
+        if (!!scroll_node->data.main_thread_scrolling_reasons) {
           DCHECK(MainThreadScrollingReason::MainThreadCanSetScrollReasons(
               status.main_thread_scrolling_reasons));
         } else {
           DCHECK(MainThreadScrollingReason::CompositorCanSetScrollReasons(
               status.main_thread_scrolling_reasons));
         }
 
         *scroll_on_main_thread = true;
         *main_thread_scrolling_reasons = status.main_thread_scrolling_reasons;
         return NULL;
       }
 
       if (status.thread == InputHandler::SCROLL_ON_IMPL_THREAD &&
           !potentially_scrolling_layer_impl) {
-        potentially_scrolling_layer_impl = layer_impl;
+        potentially_scrolling_layer_impl =
+            active_tree_->LayerById(scroll_node->owner_id);
       }
     }
   }
   // Falling back to the root scroll layer ensures generation of root overscroll
   // notifications while preventing scroll updates from being unintentionally
   // forwarded to the main thread. The inner viewport layer represents the
   // viewport during scrolling.
   if (!potentially_scrolling_layer_impl)
     potentially_scrolling_layer_impl = InnerViewportScrollLayer();
 
@@ skipping 1398 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