[scroll-animations] Add operator== to ScrollTimelineOffset

In order to update a CSSAnimation when an associated @scroll-timeline
changes, we'll need to be able to detect whether or not scroll offsets
changed. This CL prepares for that.

Bug: 1074052
Change-Id: I6059062499e4d7893db413908083d41fae5ac2b8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2332598
Commit-Queue: Anders Hartvoll Ruud <andruud@chromium.org>
Reviewed-by: Kevin Ellis <kevers@chromium.org>
Cr-Commit-Position: refs/heads/master@{#795395}

third_party/blink/renderer/core/animation/BUILD.gn

@@ -300,6 +300,7 @@ blink_core_tests("unit_tests") {
     "keyframe_effect_test.cc",
     "list_interpolation_functions_test.cc",
     "property_handle_test.cc",
+    "scroll_timeline_offset_test.cc",
     "scroll_timeline_test.cc",
     "scroll_timeline_util_test.cc",
     "svg_number_interpolation_type_test.cc",

third_party/blink/renderer/core/animation/scroll_timeline_offset.cc

@@ -13,6 +13,7 @@
 #include "third_party/blink/renderer/core/dom/node_computed_style.h"
 #include "third_party/blink/renderer/core/layout/layout_box.h"
 #include "third_party/blink/renderer/core/layout/layout_view.h"
+#include "third_party/blink/renderer/core/style/data_equivalency.h"
 #include "third_party/blink/renderer/platform/geometry/layout_unit.h"
 #include "third_party/blink/renderer/platform/geometry/length_functions.h"
 
@@ -66,6 +67,16 @@ bool IsContainingBlockChainDescendant(const LayoutObject* descendant,
   return descendant;
 }
 
+bool ElementBasedOffsetsEqual(ScrollTimelineElementBasedOffset* o1,
+                              ScrollTimelineElementBasedOffset* o2) {
+  if (o1 == o2)
+    return true;
+  if (!o1 || !o2)
+    return false;
+  return (o1->edge() == o2->edge()) && (o1->target() == o2->target()) &&
+         (o1->threshold() == o2->threshold());
+}
+
 }  // namespace
 
 // static
@@ -215,6 +226,12 @@ ScrollTimelineOffset::ToStringOrScrollTimelineElementBasedOffset() const {
   return result;
 }
 
+bool ScrollTimelineOffset::operator==(const ScrollTimelineOffset& o) const {
+  return DataEquivalent(length_based_offset_, o.length_based_offset_) &&
+         ElementBasedOffsetsEqual(element_based_offset_,
+                                  o.element_based_offset_);
+}
+
 ScrollTimelineOffset::ScrollTimelineOffset(const CSSPrimitiveValue* offset)
     : length_based_offset_(offset), element_based_offset_(nullptr) {}
 

third_party/blink/renderer/core/animation/scroll_timeline_offset.h

@@ -55,6 +55,9 @@ class CORE_EXPORT ScrollTimelineOffset final
     return !length_based_offset_ && !element_based_offset_;
   }
 
+  bool operator==(const ScrollTimelineOffset&) const;
+  bool operator!=(const ScrollTimelineOffset& o) const { return !(*this == o); }
+
  private:
   // We either have an scroll or element based offset so at any time one of
   // these is null. If both are null, it represents the default value of

third_party/blink/renderer/core/animation/scroll_timeline_offset_test.cc

+// Copyright 2020 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 "third_party/blink/renderer/core/animation/scroll_timeline_offset.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/blink/renderer/bindings/core/v8/string_or_scroll_timeline_element_based_offset.h"
+#include "third_party/blink/renderer/core/css/parser/css_parser_context.h"
+#include "third_party/blink/renderer/core/dom/document.h"
+#include "third_party/blink/renderer/core/html/html_element.h"
+#include "third_party/blink/renderer/core/testing/page_test_base.h"
+
+namespace blink {
+
+class ScrollTimelineOffsetTest : public PageTestBase {
+ public:
+  ScrollTimelineOffset* ScrollBasedOffsetFrom(String string) {
+    StringOrScrollTimelineElementBasedOffset param;
+    param.SetString(string);
+    return ScrollTimelineOffset::Create(param, *CreateCSSParserContext());
+  }
+
+  ScrollTimelineOffset* ElementBasedOffsetFrom(Element* target,
+                                               String edge,
+                                               double threshold) {
+    auto* inner = CreateElementBasedOffset(target, edge, threshold);
+    if (!inner)
+      return nullptr;
+    StringOrScrollTimelineElementBasedOffset param;
+    param.SetScrollTimelineElementBasedOffset(inner);
+    return ScrollTimelineOffset::Create(param, *CreateCSSParserContext());
+  }
+
+ private:
+  const CSSParserContext* CreateCSSParserContext() {
+    return MakeGarbageCollected<CSSParserContext>(GetDocument());
+  }
+
+  ScrollTimelineElementBasedOffset* CreateElementBasedOffset(Element* target,
+                                                             String edge,
+                                                             double threshold) {
+    auto* value = ScrollTimelineElementBasedOffset::Create();
+    value->setTarget(target);
+    value->setEdge(edge);
+    value->setThreshold(threshold);
+    return value;
+  }
+};
+
+TEST_F(ScrollTimelineOffsetTest, Equality) {
+  GetDocument().body()->setInnerHTML("<i id=e1></i><i id=e2></i>");
+  UpdateAllLifecyclePhasesForTest();
+  Element* e1 = GetDocument().getElementById("e1");
+  Element* e2 = GetDocument().getElementById("e2");
+
+  ASSERT_TRUE(e1);
+  ASSERT_TRUE(e2);
+
+  EXPECT_EQ(*ScrollBasedOffsetFrom("10px"), *ScrollBasedOffsetFrom("10px"));
+  EXPECT_EQ(*ScrollBasedOffsetFrom("10%"), *ScrollBasedOffsetFrom("10%"));
+  EXPECT_EQ(*ElementBasedOffsetFrom(e1, "start", 0),
+            *ElementBasedOffsetFrom(e1, "start", 0));
+
+  // Different types of offset:
+  EXPECT_NE(*ScrollBasedOffsetFrom("10px"),
+            *ElementBasedOffsetFrom(e1, "start", 0));
+  EXPECT_NE(*ElementBasedOffsetFrom(e1, "start", 0),
+            *ScrollBasedOffsetFrom("10px"));
+
+  // Different unit:
+  EXPECT_NE(*ScrollBasedOffsetFrom("10px"), *ScrollBasedOffsetFrom("10%"));
+  EXPECT_NE(*ScrollBasedOffsetFrom("10em"), *ScrollBasedOffsetFrom("10px"));
+
+  // Different value:
+  EXPECT_NE(*ScrollBasedOffsetFrom("10em"), *ScrollBasedOffsetFrom("50em"));
+  EXPECT_NE(*ScrollBasedOffsetFrom("10px"), *ScrollBasedOffsetFrom("10.5px"));
+
+  // Different target:
+  EXPECT_NE(*ElementBasedOffsetFrom(e1, "start", 0),
+            *ElementBasedOffsetFrom(e2, "start", 0));
+
+  // Different edge:
+  EXPECT_NE(*ElementBasedOffsetFrom(e1, "start", 0),
+            *ElementBasedOffsetFrom(e1, "end", 0));
+
+  // Different threshold:
+  EXPECT_NE(*ElementBasedOffsetFrom(e1, "start", 0),
+            *ElementBasedOffsetFrom(e1, "start", 1));
+}
+
+}  // namespace blink