Use unnamed namespaces instead of static functions in CSSAnimations.cpp

third_party/WebKit/Source/core/animation/css/CSSAnimations.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 55 matching lines @@
 #include "platform/animation/TimingFunction.h"
 #include "platform/wtf/HashSet.h"
 #include "public/platform/Platform.h"
 
 namespace blink {
 
 using PropertySet = HashSet<CSSPropertyID>;
 
 namespace {
 
-static StringKeyframeEffectModel* CreateKeyframeEffectModel(
+StringKeyframeEffectModel* CreateKeyframeEffectModel(
     StyleResolver* resolver,
     const Element* animating_element,
     Element& element,
     const ComputedStyle* style,
     const ComputedStyle* parent_style,
     const AtomicString& name,
     TimingFunction* default_timing_function,
     size_t animation_index) {
   // When the animating element is null, use its parent for scoping purposes.
   const Element* element_for_scoping =
@@ skipping 116 matching lines @@
 
 bool CSSAnimations::IsTransitionAnimationForInspector(
     const Animation& animation) const {
   for (const auto& it : transitions_) {
     if (it.value.animation->SequenceNumber() == animation.SequenceNumber())
       return true;
   }
   return false;
 }
 
-static const KeyframeEffectModelBase* GetKeyframeEffectModelBase(
+namespace {
+
+const KeyframeEffectModelBase* GetKeyframeEffectModelBase(
     const AnimationEffectReadOnly* effect) {
   if (!effect)
     return nullptr;
   const EffectModel* model = nullptr;
   if (effect->IsKeyframeEffectReadOnly())
     model = ToKeyframeEffectReadOnly(effect)->Model();
   else if (effect->IsInertEffect())
     model = ToInertEffect(effect)->Model();
   if (!model || !model->IsKeyframeEffectModel())
     return nullptr;
   return ToKeyframeEffectModelBase(model);
 }
 
+}  // namespace
+
 void CSSAnimations::CalculateCompositorAnimationUpdate(
     CSSAnimationUpdate& update,
     const Element* animating_element,
     Element& element,
     const ComputedStyle& style,
     const ComputedStyle* parent_style,
     bool was_viewport_resized) {
   ElementAnimations* element_animations =
       animating_element ? animating_element->GetElementAnimations() : nullptr;
 
@@ skipping 705 matching lines @@
   for (const auto& entry : transitions_) {
     entry.value.animation->cancel();
     entry.value.animation->Update(kTimingUpdateOnDemand);
   }
 
   running_animations_.clear();
   transitions_.clear();
   ClearPendingUpdate();
 }
 
-static bool IsCustomPropertyHandle(const PropertyHandle& property) {
+namespace {
+
+bool IsCustomPropertyHandle(const PropertyHandle& property) {
   return property.IsCSSCustomProperty();
 }
 
 // TODO(alancutter): CSS properties and presentation attributes may have
 // identical effects. By grouping them in the same set we introduce a bug where
 // arbitrary hash iteration will determine the order the apply in and thus which
 // one "wins". We should be more deliberate about the order of application in
 // the case of effect collisions.
 // Example: Both 'color' and 'svg-color' set the color on ComputedStyle but are
 // considered distinct properties in the ActiveInterpolationsMap.
-static bool IsStandardPropertyHandle(const PropertyHandle& property) {
+bool IsStandardPropertyHandle(const PropertyHandle& property) {
   return (property.IsCSSProperty() && !property.IsCSSCustomProperty()) ||
          property.IsPresentationAttribute();
 }
 
-static void AdoptActiveAnimationInterpolations(
+void AdoptActiveAnimationInterpolations(
     EffectStack* effect_stack,
     CSSAnimationUpdate& update,
     const HeapVector<Member<const InertEffect>>* new_animations,
     const HeapHashSet<Member<const Animation>>* suppressed_animations) {
   ActiveInterpolationsMap custom_interpolations(
       EffectStack::ActiveInterpolations(
           effect_stack, new_animations, suppressed_animations,
           KeyframeEffectReadOnly::kDefaultPriority, IsCustomPropertyHandle));
   update.AdoptActiveInterpolationsForCustomAnimations(custom_interpolations);
 
   ActiveInterpolationsMap standard_interpolations(
       EffectStack::ActiveInterpolations(
           effect_stack, new_animations, suppressed_animations,
           KeyframeEffectReadOnly::kDefaultPriority, IsStandardPropertyHandle));
   update.AdoptActiveInterpolationsForStandardAnimations(
       standard_interpolations);
 }
 
+}  // namespace
+
 void CSSAnimations::CalculateAnimationActiveInterpolations(
     CSSAnimationUpdate& update,
     const Element* animating_element) {
   ElementAnimations* element_animations =
       animating_element ? animating_element->GetElementAnimations() : nullptr;
   EffectStack* effect_stack =
       element_animations ? &element_animations->GetEffectStack() : nullptr;
 
   if (update.NewAnimations().IsEmpty() &&
       update.SuppressedAnimations().IsEmpty()) {
     AdoptActiveAnimationInterpolations(effect_stack, update, nullptr, nullptr);
     return;
   }
 
   HeapVector<Member<const InertEffect>> new_effects;
   for (const auto& new_animation : update.NewAnimations())
     new_effects.push_back(new_animation.effect);
 
   // Animations with updates use a temporary InertEffect for the current frame.
   for (const auto& updated_animation : update.AnimationsWithUpdates())
     new_effects.push_back(updated_animation.effect);
 
   AdoptActiveAnimationInterpolations(effect_stack, update, &new_effects,
                                      &update.SuppressedAnimations());
 }
 
-static EffectStack::PropertyHandleFilter PropertyFilter(
+namespace {
+
+EffectStack::PropertyHandleFilter PropertyFilter(
     CSSAnimations::PropertyPass property_pass) {
   if (property_pass == CSSAnimations::PropertyPass::kCustom) {
     return IsCustomPropertyHandle;
   }
   DCHECK_EQ(property_pass, CSSAnimations::PropertyPass::kStandard);
   return IsStandardPropertyHandle;
 }
 
+}  // namespace
+
 void CSSAnimations::CalculateTransitionActiveInterpolations(
     CSSAnimationUpdate& update,
     PropertyPass property_pass,
     const Element* animating_element) {
   ElementAnimations* element_animations =
       animating_element ? animating_element->GetElementAnimations() : nullptr;
   EffectStack* effect_stack =
       element_animations ? &element_animations->GetEffectStack() : nullptr;
 
   ActiveInterpolationsMap active_interpolations_for_transitions;
@@ skipping 217 matching lines @@
              IsCustomPropertyHandle);
 }
 
 DEFINE_TRACE(CSSAnimations) {
   visitor->Trace(transitions_);
   visitor->Trace(pending_update_);
   visitor->Trace(running_animations_);
 }
 
 }  // namespace blink