Reflow comments in core/animation and subdirs

third_party/WebKit/Source/core/animation/PrimitiveInterpolation.h

 // 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.
 
 #ifndef PrimitiveInterpolation_h
 #define PrimitiveInterpolation_h
 
 #include "core/animation/TypedInterpolationValue.h"
 #include "platform/animation/AnimationUtilities.h"
 #include "platform/heap/Handle.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/Vector.h"
 #include <cmath>
 #include <memory>
 
 namespace blink {
 
 class StyleResolverState;
 
-// Represents an animation's effect between an adjacent pair of PropertySpecificKeyframes after converting
-// the keyframes to an internal format with respect to the animation environment and underlying values.
+// Represents an animation's effect between an adjacent pair of
+// PropertySpecificKeyframes after converting the keyframes to an internal
+// format with respect to the animation environment and underlying values.
 class PrimitiveInterpolation {
   USING_FAST_MALLOC(PrimitiveInterpolation);
   WTF_MAKE_NONCOPYABLE(PrimitiveInterpolation);
 
  public:
   virtual ~PrimitiveInterpolation() {}
 
   virtual void interpolateValue(
       double fraction,
       std::unique_ptr<TypedInterpolationValue>& result) const = 0;
   virtual double interpolateUnderlyingFraction(double start,
                                                double end,
                                                double fraction) const = 0;
   virtual bool isFlip() const { return false; }
 
  protected:
   PrimitiveInterpolation() {}
 };
 
-// Represents a pair of keyframes that are compatible for "smooth" interpolation eg. "0px" and "100px".
+// Represents a pair of keyframes that are compatible for "smooth" interpolation
+// eg. "0px" and "100px".
 class PairwisePrimitiveInterpolation : public PrimitiveInterpolation {
  public:
   ~PairwisePrimitiveInterpolation() override {}
 
   static std::unique_ptr<PairwisePrimitiveInterpolation> create(
       const InterpolationType& type,
       std::unique_ptr<InterpolableValue> start,
       std::unique_ptr<InterpolableValue> end,
       PassRefPtr<NonInterpolableValue> nonInterpolableValue) {
     return wrapUnique(new PairwisePrimitiveInterpolation(
@@ skipping 37 matching lines @@
                                        double fraction) const final {
     return blend(start, end, fraction);
   }
 
   const InterpolationType& m_type;
   std::unique_ptr<InterpolableValue> m_start;
   std::unique_ptr<InterpolableValue> m_end;
   RefPtr<NonInterpolableValue> m_nonInterpolableValue;
 };
 
-// Represents a pair of incompatible keyframes that fall back to 50% flip behaviour eg. "auto" and "0px".
+// Represents a pair of incompatible keyframes that fall back to 50% flip
+// behaviour eg. "auto" and "0px".
 class FlipPrimitiveInterpolation : public PrimitiveInterpolation {
  public:
   ~FlipPrimitiveInterpolation() override {}
 
   static std::unique_ptr<FlipPrimitiveInterpolation> create(
       std::unique_ptr<TypedInterpolationValue> start,
       std::unique_ptr<TypedInterpolationValue> end) {
     return wrapUnique(
         new FlipPrimitiveInterpolation(std::move(start), std::move(end)));
   }
@@ skipping 26 matching lines @@
   bool isFlip() const final { return true; }
 
   std::unique_ptr<TypedInterpolationValue> m_start;
   std::unique_ptr<TypedInterpolationValue> m_end;
   mutable double m_lastFraction;
 };
 
 }  // namespace blink
 
 #endif  // PrimitiveInterpolation_h