Share SnapPoints data between cc and blink

This patch does the following:
1. Moves the data structure of SnapPoints from blink to cc and shares it back with blink.
2. Use the coordinate of ScrollPosition and the type of FloatPoint to do calculations in
   SnapCoordinator instead of ScrollOffset, as gfx::ScrollOffset uses ScrollPosition.
3. Update the logic in SnapCoordinator to work with vertical-rl writing-mode.
4. Use LocalToAncestorQuad() for the snap_area to ensure transforms are properly dealt with.


Bug: 795404
Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.android:android_optional_gpu_tests_rel
Change-Id: I538327e169ebee4d3e03ec2ddd0d5b282e36f5de
Reviewed-on: https://chromium-review.googlesource.com/825994
Reviewed-by: Ali Juma <ajuma@chromium.org>
Reviewed-by: Jeremy Roman <jbroman@chromium.org>
Reviewed-by: David Bokan <bokan@chromium.org>
Reviewed-by: Majid Valipour <majidvp@chromium.org>
Commit-Queue: Sandra Sun <sunyunjia@chromium.org>
Cr-Commit-Position: refs/heads/master@{#525271}

cc/BUILD.gn

@@ -39,6 +39,8 @@ cc_component("cc") {
     "input/page_scale_animation.h",
     "input/scroll_elasticity_helper.cc",
     "input/scroll_elasticity_helper.h",
+    "input/scroll_snap_data.cc",
+    "input/scroll_snap_data.h",
     "input/scroll_state.cc",
     "input/scroll_state.h",
     "input/scroll_state_data.cc",

cc/input/scroll_snap_data.cc

@@ -0,0 +1,41 @@
+// Copyright 2017 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/input/scroll_snap_data.h"
+
+namespace cc {
+
+SnapContainerData::SnapContainerData() : SnapContainerData(ScrollSnapType()) {}
+
+SnapContainerData::SnapContainerData(ScrollSnapType type)
+    : scroll_snap_type(type) {}
+
+SnapContainerData::SnapContainerData(ScrollSnapType type, gfx::ScrollOffset max)
+    : scroll_snap_type(type), max_position(max) {}
+
+SnapContainerData::SnapContainerData(const SnapContainerData& other)
+    : scroll_snap_type(other.scroll_snap_type),
+      max_position(other.max_position),
+      snap_area_list(other.snap_area_list) {}
+
+SnapContainerData::~SnapContainerData() {}
+
+void SnapContainerData::AddSnapAreaData(SnapAreaData snap_area_data) {
+  snap_area_list.push_back(snap_area_data);
+}
+
+std::ostream& operator<<(std::ostream& ostream, const SnapAreaData& area_data) {
+  return ostream << area_data.snap_position.x() << ", "
+                 << area_data.snap_position.y();
+}
+
+std::ostream& operator<<(std::ostream& ostream,
+                         const SnapContainerData& container_data) {
+  for (SnapAreaData area_data : container_data.snap_area_list) {
+    ostream << area_data << "\n";
+  }
+  return ostream;
+}
+
+}  // namespace cc

cc/input/scroll_snap_data.h

@@ -0,0 +1,148 @@
+// Copyright 2017 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.
+
+#ifndef CC_INPUT_SCROLL_SNAP_DATA_H_
+#define CC_INPUT_SCROLL_SNAP_DATA_H_
+
+#include <vector>
+
+#include "cc/cc_export.h"
+#include "ui/gfx/geometry/scroll_offset.h"
+
+namespace cc {
+
+// See https://www.w3.org/TR/css-scroll-snap-1/#snap-axis
+enum class SnapAxis : unsigned {
+  kBoth,
+  kX,
+  kY,
+  kBlock,
+  kInline,
+};
+
+// See https://www.w3.org/TR/css-scroll-snap-1/#snap-strictness
+// TODO(sunyunjia): Add kNone for SnapStrictness to match the spec.
+// crbug.com/791663
+enum class SnapStrictness : unsigned { kProximity, kMandatory };
+
+// See https://www.w3.org/TR/css-scroll-snap-1/#scroll-snap-align
+enum class SnapAlignment : unsigned { kNone, kStart, kEnd, kCenter };
+
+struct ScrollSnapType {
+  ScrollSnapType()
+      : is_none(true),
+        axis(SnapAxis::kBoth),
+        strictness(SnapStrictness::kProximity) {}
+
+  ScrollSnapType(bool snap_type_none, SnapAxis axis, SnapStrictness strictness)
+      : is_none(snap_type_none), axis(axis), strictness(strictness) {}
+
+  bool operator==(const ScrollSnapType& other) const {
+    return is_none == other.is_none && axis == other.axis &&
+           strictness == other.strictness;
+  }
+
+  bool operator!=(const ScrollSnapType& other) const {
+    return !(*this == other);
+  }
+
+  // Whether the scroll-snap-type is none or the snap-strictness field has the
+  // value None.
+  // TODO(sunyunjia): Consider combining is_none with SnapStrictness.
+  bool is_none;
+
+  SnapAxis axis;
+  SnapStrictness strictness;
+};
+
+struct ScrollSnapAlign {
+  ScrollSnapAlign()
+      : alignmentX(SnapAlignment::kNone), alignmentY(SnapAlignment::kNone) {}
+
+  explicit ScrollSnapAlign(SnapAlignment alignment)
+      : alignmentX(alignment), alignmentY(alignment) {}
+
+  ScrollSnapAlign(SnapAlignment x, SnapAlignment y)
+      : alignmentX(x), alignmentY(y) {}
+
+  bool operator==(const ScrollSnapAlign& other) const {
+    return alignmentX == other.alignmentX && alignmentY == other.alignmentY;
+  }
+
+  bool operator!=(const ScrollSnapAlign& other) const {
+    return !(*this == other);
+  }
+
+  SnapAlignment alignmentX;
+  SnapAlignment alignmentY;
+};
+
+// Snap area is a bounding box that could be snapped to when a scroll happens in
+// its scroll container.
+// This data structure describes the data needed for SnapCoordinator if we want
+// to snap to this snap area.
+struct SnapAreaData {
+  // kInvalidScrollOffset is used to mark that the snap_position on a specific
+  // axis is not applicable, thus should not be considered when snapping on that
+  // axis. This is because the snap area has SnapAlignmentNone on that axis.
+  static const int kInvalidScrollPosition = -1;
+
+  SnapAreaData() {}
+
+  SnapAreaData(SnapAxis axis, gfx::ScrollOffset position, bool msnap)
+      : snap_axis(axis), snap_position(position), must_snap(msnap) {}
+
+  // The axes along which the area has specified snap positions.
+  SnapAxis snap_axis;
+
+  // The scroll_position to snap the area at the specified alignment in that
+  // axis.
+  // This is in the same coordinate with blink's scroll position, which is the
+  // location of the top/left of the scroll viewport in the top/left of the
+  // overflow rect.
+  gfx::ScrollOffset snap_position;
+
+  // Whether this area has scroll-snap-stop: always.
+  // See https://www.w3.org/TR/css-scroll-snap-1/#scroll-snap-stop
+  bool must_snap;
+
+  // TODO(sunyunjia): Add fields for visibility requirement and large area
+  // snapping.
+};
+
+// Snap container is a scroll container that has non-'none' value for
+// scroll-snap-type. It can be snapped to one of its snap areas when a scroll
+// happens.
+// This data structure describes the data needed for SnapCoordinator to perform
+// snapping in the snap container.
+struct CC_EXPORT SnapContainerData {
+  SnapContainerData();
+  explicit SnapContainerData(ScrollSnapType type);
+  SnapContainerData(ScrollSnapType type, gfx::ScrollOffset max);
+  SnapContainerData(const SnapContainerData& other);
+  ~SnapContainerData();
+
+  void AddSnapAreaData(SnapAreaData snap_area_data);
+
+  // Specifies whether a scroll container is a scroll snap container, how
+  // strictly it snaps, and which axes are considered.
+  // See https://www.w3.org/TR/css-scroll-snap-1/#scroll-snap-type for details.
+  ScrollSnapType scroll_snap_type;
+
+  // The maximal scroll position of the SnapContainer, in the same coordinate
+  // with blink's scroll position.
+  gfx::ScrollOffset max_position;
+
+  // The SnapAreaData for the snap areas in this snap container. When a scroll
+  // happens, we iterate through the snap_area_list to find the best snap
+  // position.
+  std::vector<SnapAreaData> snap_area_list;
+};
+
+CC_EXPORT std::ostream& operator<<(std::ostream&, const SnapAreaData&);
+CC_EXPORT std::ostream& operator<<(std::ostream&, const SnapContainerData&);
+
+}  // namespace cc
+
+#endif  // CC_INPUT_SCROLL_SNAP_DATA_H_