Make neutral keyframes explicit in SVG attribute interpolation test API

third_party/WebKit/LayoutTests/animations/svg-attribute-interpolation/resources/interpolation-test.js

 /* Copyright 2015 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.
  *
  * Exported function:
- *  - assertAttributeInterpolation({property, [from], [to], [fromComposite], [toComposite], [underlying]}, [{at: fraction, is: value}])
+ *  - assertAttributeInterpolation({property, from, to, [fromComposite], [toComposite], [underlying]}, [{at: fraction, is: value}])
  *        Constructs a test case for each fraction that asserts the expected value
  *        equals the value produced by interpolation between from and to composited
  *        onto underlying by fromComposite and toComposite respectively using
  *        SMIL and Web Animations.
- *        If from or to are missing then a neutral keyframe will be used and the
- *        composite mode will be forced to be 'add'.
+ *        Set from/to to the exported neutralKeyframe object to specify neutral keyframes.
  *        SMIL will only be tested with equal fromComposite and toComposite values.
 */
 'use strict';
 (() => {
   var interpolationTests = [];
+  var neutralKeyframe = {};
 
   // Set to true to output rebaselined test expectations.
   var rebaselineTests = false;
 
+  function isNeutralKeyframe(keyframe) {
+    return keyframe === neutralKeyframe;
+  }
+
   function createElement(tagName, container) {
     var element = document.createElement(tagName);
     if (container) {
       container.appendChild(element);
     }
     return element;
   }
 
   // Constructs a timing function which produces 'y' at x = 0.5
   function createEasing(y) {
@@ skipping 281 matching lines @@
         } else {
           console.warn(`Unable to test SMIL from ${params.from} to ${params.to}`);
           target.container.remove();
           target.measure = function() {};
         }
         break;
       case 'Web Animations':
         // Replace 'transform' with 'svgTransform', etc. This avoids collisions with CSS properties or the Web Animations API (offset).
         var prefixedProperty = 'svg' + params.property[0].toUpperCase() + params.property.slice(1);
         var keyframes = [];
-        if ('from' in params) {
+        if (!isNeutralKeyframe(params.from)) {
           keyframes.push({
             offset: 0,
             [prefixedProperty]: params.from,
             composite: params.fromComposite,
           });
-        } else {
-          console.assert(params.fromComposite === 'add');
         }
-        if ('to' in params) {
+        if (!isNeutralKeyframe(params.to)) {
           keyframes.push({
             offset: 1,
             [prefixedProperty]: params.to,
             composite: params.toComposite,
           });
-        } else {
-          console.assert(params.toComposite === 'add');
         }
         target.animate(keyframes, {
           fill: 'forwards',
           duration: 1,
           easing: createEasing(expectation.at),
           delay: -0.5,
           iterations: 0.5,
         });
         break;
       default:
@@ skipping 15 matching lines @@
       }, `${method}: ${description} at (${expectation.at}) is [${expectation.is}]`);
     };
 
     return target;
   }
 
   function createTestTargets(interpolationTests, container, rebaselineContainer) {
     var targets = [];
     for (var interpolationTest of interpolationTests) {
       var params = interpolationTest.params;
-      params.fromComposite = 'from' in params ? (params.fromComposite || 'replace') : 'add';
-      params.toComposite = 'to' in params ? (params.toComposite || 'replace') : 'add';
+      assert_true('property' in params);
+      assert_true('from' in params);
+      assert_true('to' in params);
+      params.fromComposite = isNeutralKeyframe(params.from) ? 'add' : (params.fromComposite || 'replace');
+      params.toComposite = isNeutralKeyframe(params.to) ? 'add' : (params.toComposite || 'replace');
       var underlyingText = params.underlying ? `with underlying [${params.underlying}] ` : '';
-      var fromText = 'from' in params ? `${params.fromComposite} [${params.from}]` : 'neutral';
-      var toText = 'to' in params ? `${params.toComposite} [${params.to}]` : 'neutral';
+      var fromText = isNeutralKeyframe(params.from) ? 'neutral' : `${params.fromComposite} [${params.from}]`;
+      var toText = isNeutralKeyframe(params.to) ? 'neutral' : `${params.toComposite} [${params.to}]`;
       var description = `Interpolate attribute <${params.property}> ${underlyingText}from ${fromText} to ${toText}`;
 
     if (rebaselineTests) {
         var rebaseline = createElement('pre', rebaselineContainer);
 
-        var fromCode = 'from' in params ? `
-  from: '${params.from}',
-  fromComposite: '${params.fromComposite}',` : '';
+        var assertionCode =
+          `assertAttributeInterpolation({\n` +
+          `  property: '${params.property}',\n` +
+          `  underlying: '${params.underlying}',\n`;
 
-        var toCode = 'to' in params ? `
-  to: '${params.to}',
-  toComposite: '${params.toComposite}',` : '';
 
-        rebaseline.appendChild(document.createTextNode(`\
-assertAttributeInterpolation({
-  property: '${params.property}',
-  underlying: '${params.underlying}',${fromCode}${toCode}
-}, [\n`));
+        if (isNeutralKeyframe(params.from)) {
+          assertionCode += `  from: neutralKeyframe,\n`;
+        } else {
+          assertionCode +=
+            `  from: '${params.from}',\n` +
+            `  fromComposite: '${params.fromComposite}',\n`;
+        }
+
+        if (isNeutralKeyframe(params.to)) {
+          assertionCode += `  to: neutralKeyframe,\n`;
+        } else {
+          assertionCode +=
+            `  to: '${params.to}',\n` +
+            `  fromComposite: '${params.fromComposite}',\n`;
+        }
+
+        assertionCode += `\n}, [\n`;
+
+        rebaseline.appendChild(document.createTextNode(assertionCode));
         var rebaselineExpectation;
         rebaseline.appendChild(rebaselineExpectation = document.createTextNode(''));
         rebaseline.appendChild(document.createTextNode(']);\n\n'));
       }
 
       for (var method of ['SMIL', 'Web Animations']) {
         if (method === 'SMIL' && params.fromComposite !== params.toComposite) {
           continue;
         }
         createElement('pre', container).textContent = `${method}: ${description}`;
@@ skipping 46 matching lines @@
   loadScript('../../resources/testharness.js').then(() => {
     return loadScript('../../resources/testharnessreport.js');
   }).then(() => {
     var asyncHandle = async_test('This test uses interpolation-test.js.')
     requestAnimationFrame(() => {
       runTests().then(() => asyncHandle.done());
     });
   });
 
   window.assertAttributeInterpolation = assertAttributeInterpolation;
+  window.neutralKeyframe = neutralKeyframe;
 })();