First Implementation of Snapped Points

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 716 matching lines @@
 DrawMode LayerTreeHostImpl::GetDrawMode() const {
   if (resourceless_software_draw_) {
     return DRAW_MODE_RESOURCELESS_SOFTWARE;
   } else if (compositor_frame_sink_->context_provider()) {
     return DRAW_MODE_HARDWARE;
   } else {
     return DRAW_MODE_SOFTWARE;
   }
 }
 
+static double FindClosestInSortedArray(double start,
+                                       double target,
+                                       const std::vector<SnapPoint>& array) {
+  int size = array.size();
+  if (size <= 0)
+    return target;
+
+  int large_area_cnt = 0;
+
+  if (target >= start) {
+    // First, find the index of the snap point that's closest
+    // to start point.
+    double snap_point = array[0].offset;
+    double delta = target - snap_point;
+    int i = 0;
+    for (; i < size; ++i) {
+      if (array[i].offset >= start)
+        break;
+      if (array[i].is_start)
+        ++large_area_cnt;
+      if (array[i].is_end)
+        --large_area_cnt;
+      snap_point = array[i].offset;
+      delta = target - snap_point;
+    }
+    if (i >= size)
+      return target;
+
+    for (int j = i; j < size; ++j) {
+      if (array[j].offset >= target) {
+        if (large_area_cnt > 0)
+          return target;
+        if (array[j].offset - target < delta)
+          return array[j].offset;
+        return snap_point;
+      }
+      if (array[j].must_snap && start != target)
+        return array[j].offset;
+      if (array[j].is_start)
+        ++large_area_cnt;
+      if (array[j].is_end)
+        --large_area_cnt;
+      snap_point = array[j].offset;
+      delta = target - snap_point;
+    }
+  }
+
+  if (target < start) {
+    double snap_point = array[size - 1].offset;
+    double delta = snap_point - target;
+    int i = size - 1;
+    for (; i >= 0; --i) {
+      if (array[i].offset <= start)
+        break;
+      if (array[i].is_end)
+        ++large_area_cnt;
+      if (array[i].is_start)
+        --large_area_cnt;
+      snap_point = array[i].offset;
+      delta = snap_point - target;
+    }
+    if (i < 0)
+      return target;
+
+    for (int j = i; j >= 0; --j) {
+      if (array[j].offset <= target) {
+        if (large_area_cnt > 0)
+          return target;
+        if (target - array[j].offset < delta)
+          return array[j].offset;
+        return snap_point;
+      }
+      if (array[j].must_snap)
+        return array[j].offset;
+      if (array[j].is_end)
+        ++large_area_cnt;
+      if (array[j].is_start)
+        --large_area_cnt;
+      snap_point = array[j].offset;
+      delta = snap_point - target;
+    }
+  }
+
+  return target;
+}
+
 static void AppendQuadsToFillScreen(
     const gfx::Rect& root_scroll_layer_rect,
     RenderPass* target_render_pass,
     const RenderSurfaceImpl* root_render_surface,
     SkColor screen_background_color,
     const Region& fill_region) {
   if (!root_render_surface || !SkColorGetA(screen_background_color))
     return;
   if (fill_region.IsEmpty())
     return;
@@ skipping 2466 matching lines @@
         scroll_node, gfx::PointF(viewport_point), delta, scroll_tree);
   }
   float scale_factor = active_tree()->current_page_scale_factor();
   return ScrollNodeWithLocalDelta(scroll_node, delta, scale_factor,
                                   active_tree());
 }
 
 void LayerTreeHostImpl::ApplyScroll(ScrollNode* scroll_node,
                                     ScrollState* scroll_state) {
   DCHECK(scroll_node && scroll_state);
+
   gfx::Point viewport_point(scroll_state->position_x(),
                             scroll_state->position_y());
   const gfx::Vector2dF delta(scroll_state->delta_x(), scroll_state->delta_y());
   gfx::Vector2dF applied_delta;
   gfx::Vector2dF delta_applied_to_content;
   // TODO(tdresser): Use a more rational epsilon. See crbug.com/510550 for
   // details.
   const float kEpsilon = 0.1f;
 
   bool scrolls_main_viewport_scroll_layer =
@@ skipping 50 matching lines @@
   }
 
   scroll_state->set_caused_scroll(
       std::abs(delta_applied_to_content.x()) > kEpsilon,
       std::abs(delta_applied_to_content.y()) > kEpsilon);
   scroll_state->ConsumeDelta(applied_delta.x(), applied_delta.y());
 
   scroll_state->set_current_native_scrolling_node(scroll_node);
 }
 
+void LayerTreeHostImpl::FindSnappedOffset(
+    gfx::Vector2dF* snapped_offset,
+    const gfx::Vector2dF& original_offset) {
+  ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;
+  ScrollNode* scroll_node = scroll_tree.CurrentlyScrollingNode();
+
+  LayerImpl* layer =
+      active_tree()->FindActiveTreeLayerById(scroll_node->owning_layer_id);
+  float scale_factor = active_tree()->current_page_scale_factor();
+  gfx::Vector2dF scaled = original_offset;
+  scaled.Scale(1.f / scale_factor);
+
+  gfx::ScrollOffset current_offset =
+      scroll_tree.current_scroll_offset(scroll_node->owning_layer_id);
+  gfx::ScrollOffset expected_offset =
+      current_offset - gfx::ScrollOffset(scaled);
+  std::vector<SnapPoint> horizontal = layer->snap_offsets_horizontal();
+  std::vector<SnapPoint> vertical = layer->snap_offsets_vertical();
+  double snapped_x = FindClosestInSortedArray(current_offset.x(),
+                                              expected_offset.x(), horizontal);
+  double snapped_y = FindClosestInSortedArray(current_offset.y(),
+                                              expected_offset.y(), vertical);
+  expected_offset.set_x(snapped_x);
+  expected_offset.set_y(snapped_y);
+  expected_offset = current_offset - expected_offset;
+  snapped_offset->set_x(expected_offset.x());
+  snapped_offset->set_y(expected_offset.y());
+  snapped_offset->Scale(scale_factor);
+}
+
 void LayerTreeHostImpl::DistributeScrollDelta(ScrollState* scroll_state) {
   // TODO(majidvp): in Blink we compute scroll chain only at scroll begin which
   // 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 = OuterViewportScrollNode();
   if (scroll_node) {
@@ skipping 104 matching lines @@
     // input handler.
     UpdateRootLayerStateForSynchronousInputHandler();
   }
 
   // Update compositor worker mutations which may respond to scrolling.
   Mutate(CurrentBeginFrameArgs().frame_time);
 
   return scroll_result;
 }
 
+void LayerTreeHostImpl::SnapAfterGestureScroll(const gfx::Point& scroll_point) {
+  gfx::Vector2dF snap_offset, original_offset;
+  FindSnappedOffset(&snap_offset, original_offset);
+  ScrollTree& scroll_tree = active_tree_->property_trees()->scroll_tree;
+  ScrollNode* scroll_node = scroll_tree.CurrentlyScrollingNode();
+  ScrollAnimationCreate(scroll_node, -snap_offset, base::TimeDelta());
+}
+
 void LayerTreeHostImpl::RequestUpdateForSynchronousInputHandler() {
   UpdateRootLayerStateForSynchronousInputHandler();
 }
 
 void LayerTreeHostImpl::SetSynchronousInputHandlerRootScrollOffset(
     const gfx::ScrollOffset& root_offset) {
   bool changed = active_tree_->DistributeRootScrollOffset(root_offset);
   if (!changed)
     return;
 
@@ skipping 872 matching lines @@
 
 void LayerTreeHostImpl::ShowScrollbarsForImplScroll(ElementId element_id) {
   if (!element_id)
     return;
   if (ScrollbarAnimationController* animation_controller =
           ScrollbarAnimationControllerForElementId(element_id))
     animation_controller->DidScrollUpdate();
 }
 
 }  // namespace cc