Changed ComputedStyle's EVisibility to be an enum class and fixed naming

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 14 matching lines @@
         ASSERT(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 == VISIBLE || m_end == VISIBLE)
-            return VISIBLE;
+        if (m_start == EVisibility::Visible || m_end == EVisibility::Visible)
+            return EVisibility::Visible;
         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 33 matching lines @@
 
 class ParentVisibilityChecker : public InterpolationType::ConversionChecker {
 public:
     static std::unique_ptr<ParentVisibilityChecker> create(EVisibility visibility)
     {
         return wrapUnique(new ParentVisibilityChecker(visibility));
     }
 
 private:
     ParentVisibilityChecker(EVisibility visibility)
-        : m_visibility(visibility)
+        : m_visibility(static_cast<double>(visibility))
     { }
 
     bool isValid(const InterpolationEnvironment& environment, const InterpolationValue& underlying) const final
     {
-        return m_visibility == environment.state().parentStyle()->visibility();
+        return static_cast<EVisibility>(m_visibility) == environment.state().parentStyle()->visibility();
     }
 
+    // TODO(sashab): Why is this being stored as a double?

[Bugs Nash, 2016/07/28 01:25:12]

Should a question be put in as a TODO? Maybe do the research now.

[sashab, 2016/07/29 06:25:50]

Seems to be added by alancutter@ here:
https://codereview.chromium.org/1548873002
seems like an honest mistake since other ConversionCheckers store fractions.

Changed the TODO to be clearer I'll do it in a follow-up patch. :)

[alancutter (OOO until 2018), 2016/07/29 09:16:47]

This is indeed a mistake, feel free to make it store an enum instead.

     const double m_visibility;
 };
 
 InterpolationValue CSSVisibilityInterpolationType::createVisibilityValue(EVisibility visibility) const
 {
     return InterpolationValue(InterpolableNumber::create(0), CSSVisibilityNonInterpolableValue::create(visibility, visibility));
 }
 
 InterpolationValue CSSVisibilityInterpolationType::maybeConvertNeutral(const InterpolationValue& underlying, ConversionCheckers& conversionCheckers) const
 {
     double underlyingFraction = toInterpolableNumber(*underlying.interpolableValue).value();
     EVisibility underlyingVisibility = toCSSVisibilityNonInterpolableValue(*underlying.nonInterpolableValue).visibility(underlyingFraction);
     conversionCheckers.append(UnderlyingVisibilityChecker::create(underlyingVisibility));
     return createVisibilityValue(underlyingVisibility);
 }
 
 InterpolationValue CSSVisibilityInterpolationType::maybeConvertInitial(const StyleResolverState&, ConversionCheckers&) const
 {
-    return createVisibilityValue(VISIBLE);
+    return createVisibilityValue(EVisibility::Visible);
 }
 
 InterpolationValue CSSVisibilityInterpolationType::maybeConvertInherit(const StyleResolverState& state, ConversionCheckers& conversionCheckers) const
 {
     if (!state.parentStyle())
         return nullptr;
     EVisibility inheritedVisibility = state.parentStyle()->visibility();
     conversionCheckers.append(ParentVisibilityChecker::create(inheritedVisibility));
     return createVisibilityValue(inheritedVisibility);
 }
@@ skipping 38 matching lines @@
 
 void CSSVisibilityInterpolationType::apply(const InterpolableValue& interpolableValue, const NonInterpolableValue* nonInterpolableValue, InterpolationEnvironment& environment) 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);
     environment.state().style()->setVisibility(visibility);
 }
 
 } // namespace blink