Don't animate visibility keyframes that don't include "visible"

third_party/WebKit/Source/core/animation/CSSVisibilityInterpolationType.cpp

 // 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.
 
 #include "core/animation/CSSVisibilityInterpolationType.h"
 
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
@@ skipping 12 matching lines @@
   EVisibility visibility() const {
     DCHECK(m_isSingle);
     return m_start;
   }
 
   EVisibility visibility(double fraction) const {
     if (m_isSingle || fraction <= 0)
       return m_start;
     if (fraction >= 1)
       return m_end;
     if (m_start == EVisibility::kVisible || m_end == EVisibility::kVisible)

[Eric Willigers, 2017/02/16 00:29:47]

Should this now be DCHECK(m_start == EVisibility::kVisible || m_end ==
EVisibility::kVisible)  ?

[alancutter (OOO until 2018), 2017/02/16 00:58:17]

Good idea. Done.

       return EVisibility::kVisible;
     return fraction < 0.5 ? m_start : m_end;
   }
 
   DECLARE_NON_INTERPOLABLE_VALUE_TYPE();
 
  private:
   CSSVisibilityNonInterpolableValue(EVisibility start, EVisibility end)
       : m_start(start), m_end(end), m_isSingle(m_start == m_end) {}
 
@@ skipping 110 matching lines @@
 
 InterpolationValue
 CSSVisibilityInterpolationType::maybeConvertStandardPropertyUnderlyingValue(
     const ComputedStyle& style) const {
   return createVisibilityValue(style.visibility());
 }
 
 PairwiseInterpolationValue CSSVisibilityInterpolationType::maybeMergeSingles(
     InterpolationValue&& start,
     InterpolationValue&& end) const {
-  return PairwiseInterpolationValue(
-      InterpolableNumber::create(0), InterpolableNumber::create(1),
-      CSSVisibilityNonInterpolableValue::create(
-          toCSSVisibilityNonInterpolableValue(*start.nonInterpolableValue)
-              .visibility(),
-          toCSSVisibilityNonInterpolableValue(*end.nonInterpolableValue)
-              .visibility()));
+  EVisibility startVisibility =
+      toCSSVisibilityNonInterpolableValue(*start.nonInterpolableValue)
+          .visibility();
+  EVisibility endVisibility =
+      toCSSVisibilityNonInterpolableValue(*end.nonInterpolableValue)
+          .visibility();
+  if (startVisibility != endVisibility &&
+      startVisibility != EVisibility::kVisible &&
+      endVisibility != EVisibility::kVisible) {
+    return nullptr;
+  }
+  return PairwiseInterpolationValue(InterpolableNumber::create(0),
+                                    InterpolableNumber::create(1),
+                                    CSSVisibilityNonInterpolableValue::create(
+                                        startVisibility, endVisibility));
 }
 
 void CSSVisibilityInterpolationType::composite(
     UnderlyingValueOwner& underlyingValueOwner,
     double underlyingFraction,
     const InterpolationValue& value,
     double interpolationFraction) const {
   underlyingValueOwner.set(*this, value);
 }
 
 void CSSVisibilityInterpolationType::applyStandardPropertyValue(
     const InterpolableValue& interpolableValue,
     const NonInterpolableValue* nonInterpolableValue,
     StyleResolverState& state) const {
   // Visibility interpolation has been deferred to application time here due to
   // its non-linear behaviour.
   double fraction = toInterpolableNumber(interpolableValue).value();
   EVisibility visibility =
       toCSSVisibilityNonInterpolableValue(nonInterpolableValue)
           ->visibility(fraction);
   state.style()->setVisibility(visibility);
 }
 
 }  // namespace blink