Rename WebKit namespace to blink

Source/core/platform/animation/AnimationTranslationUtil.cpp

 /*
  * Copyright (C) 2012 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:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 38 matching lines @@
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebFilterAnimationCurve.h"
 #include "public/platform/WebFloatAnimationCurve.h"
 #include "public/platform/WebTransformAnimationCurve.h"
 #include "public/platform/WebTransformOperations.h"
 
 #include "wtf/OwnPtr.h"
 #include "wtf/text/CString.h"
 
 using namespace std;
-using namespace WebKit;
+using namespace blink;
 
 namespace WebCore {
 
 PassOwnPtr<WebTransformOperations> toWebTransformOperations(const TransformOperations& transformOperations, const FloatSize& boxSize)
 {
     // We need to do a deep copy the transformOperations may contain ref pointers to TransformOperation objects.
     OwnPtr<WebTransformOperations> webTransformOperations = adoptPtr(Platform::current()->compositorSupport()->createTransformOperations());
     if (!webTransformOperations)
         return nullptr;
     for (size_t j = 0; j < transformOperations.size(); ++j) {
@@ skipping 61 matching lines @@
         case TransformOperation::None:
             // Do nothing.
             break;
         } // switch
     } // for each operation
 
     return webTransformOperations.release();
 }
 
 template <class Value, class Keyframe, class Curve>
-bool appendKeyframeWithStandardTimingFunction(Curve* curve, double keyTime, const Value* value, const Value* lastValue, WebKit::WebAnimationCurve::TimingFunctionType timingFunctionType, const FloatSize&)
+bool appendKeyframeWithStandardTimingFunction(Curve* curve, double keyTime, const Value* value, const Value* lastValue, blink::WebAnimationCurve::TimingFunctionType timingFunctionType, const FloatSize&)
 {
     curve->add(Keyframe(keyTime, value->value()), timingFunctionType);
     return true;
 }
 
 template <class Value, class Keyframe, class Curve>
 bool appendKeyframeWithCustomBezierTimingFunction(Curve* curve, double keyTime, const Value* value, const Value* lastValue, double x1, double y1, double x2, double y2, const FloatSize&)
 {
     curve->add(Keyframe(keyTime, value->value()), x1, y1, x2, y2);
     return true;
 }
 
 template <>
-bool appendKeyframeWithStandardTimingFunction<TransformAnimationValue, WebTransformKeyframe, WebTransformAnimationCurve>(WebTransformAnimationCurve* curve, double keyTime, const TransformAnimationValue* value, const TransformAnimationValue* lastValue, WebKit::WebAnimationCurve::TimingFunctionType timingFunctionType, const FloatSize& boxSize)
+bool appendKeyframeWithStandardTimingFunction<TransformAnimationValue, WebTransformKeyframe, WebTransformAnimationCurve>(WebTransformAnimationCurve* curve, double keyTime, const TransformAnimationValue* value, const TransformAnimationValue* lastValue, blink::WebAnimationCurve::TimingFunctionType timingFunctionType, const FloatSize& boxSize)
 {
     bool canBlend = !lastValue;
     OwnPtr<WebTransformOperations> operations(toWebTransformOperations(*value->value(), boxSize));
     if (!operations)
         return false;
     if (!canBlend) {
         OwnPtr<WebTransformOperations> lastOperations(toWebTransformOperations(*lastValue->value(), boxSize));
         if (!lastOperations)
             return false;
         canBlend = lastOperations->canBlendWith(*operations);
@@ skipping 19 matching lines @@
         canBlend = lastOperations->canBlendWith(*operations);
     }
     if (canBlend) {
         curve->add(WebTransformKeyframe(keyTime, operations.release()), x1, y1, x2, y2);
         return true;
     }
     return false;
 }
 
 template <>
-bool appendKeyframeWithStandardTimingFunction<FilterAnimationValue, WebFilterKeyframe, WebFilterAnimationCurve>(WebFilterAnimationCurve* curve, double keyTime, const FilterAnimationValue* value, const FilterAnimationValue* lastValue, WebKit::WebAnimationCurve::TimingFunctionType timingFunctionType, const FloatSize& boxSize)
+bool appendKeyframeWithStandardTimingFunction<FilterAnimationValue, WebFilterKeyframe, WebFilterAnimationCurve>(WebFilterAnimationCurve* curve, double keyTime, const FilterAnimationValue* value, const FilterAnimationValue* lastValue, blink::WebAnimationCurve::TimingFunctionType timingFunctionType, const FloatSize& boxSize)
 {
     // FIXME(ajuma): In order to animate pixel-moving filters on the compositor thread, we need
     // to update overlap testing to take into account the bounds within which the animation
     // will be contained, and we need the compositor to update layer bounds as the animation
     // progresses.
     if (value->value()->hasFilterThatMovesPixels())
         return false;
     SkiaImageFilterBuilder builder;
     OwnPtr<WebFilterOperations> operations = adoptPtr(Platform::current()->compositorSupport()->createFilterOperations());
     FilterOutsets outsets = value->value()->outsets();
@@ skipping 17 matching lines @@
     OwnPtr<WebFilterOperations> operations = adoptPtr(Platform::current()->compositorSupport()->createFilterOperations());
     FilterOutsets outsets = value->value()->outsets();
     builder.setCropOffset(FloatSize(outsets.left(), outsets.top()));
     if (!builder.buildFilterOperations(*value->value(), operations.get()))
         return false;
     curve->add(WebFilterKeyframe(keyTime, operations.release()), x1, y1, x2, y2);
     return true;
 }
 
 template <class Value, class Keyframe, class Curve>
-PassOwnPtr<WebKit::WebAnimation> createWebAnimation(const KeyframeValueList& valueList, const CSSAnimationData* animation, int animationId, double timeOffset, Curve* curve, WebKit::WebAnimation::TargetProperty targetProperty, const FloatSize& boxSize)
+PassOwnPtr<blink::WebAnimation> createWebAnimation(const KeyframeValueList& valueList, const CSSAnimationData* animation, int animationId, double timeOffset, Curve* curve, blink::WebAnimation::TargetProperty targetProperty, const FloatSize& boxSize)
 {
     bool alternate = false;
     bool reverse = false;
     if (animation && animation->isDirectionSet()) {
         CSSAnimationData::AnimationDirection direction = animation->direction();
         if (direction == CSSAnimationData::AnimationDirectionAlternate || direction == CSSAnimationData::AnimationDirectionAlternateReverse)
             alternate = true;
         if (direction == CSSAnimationData::AnimationDirectionReverse || direction == CSSAnimationData::AnimationDirectionAlternateReverse)
             reverse = true;
     }
 
     for (size_t i = 0; i < valueList.size(); i++) {
         size_t index = reverse ? valueList.size() - i - 1 : i;
         const Value* originalValue = static_cast<const Value*>(valueList.at(index));
         const Value* lastOriginalValue = 0;
         if (valueList.size() > 1 && ((reverse && index + 1 < valueList.size()) || (!reverse && index > 0)))
             lastOriginalValue = static_cast<const Value*>(valueList.at(reverse ? index + 1 : index - 1));
 
         const TimingFunction* originalTimingFunction = originalValue->timingFunction();
 
         // If there hasn't been a timing function associated with this keyframe, use the
         // animation's timing function, if we have one.
         if (!originalTimingFunction && animation->isTimingFunctionSet())
             originalTimingFunction = animation->timingFunction();
 
         // Ease is the default timing function.
-        WebKit::WebAnimationCurve::TimingFunctionType timingFunctionType = WebKit::WebAnimationCurve::TimingFunctionTypeEase;
+        blink::WebAnimationCurve::TimingFunctionType timingFunctionType = blink::WebAnimationCurve::TimingFunctionTypeEase;
 
         bool isUsingCustomBezierTimingFunction = false;
         double x1 = 0;
         double y1 = 0;
         double x2 = 1;
         double y2 = 1;
 
         if (originalTimingFunction) {
             switch (originalTimingFunction->type()) {
             case TimingFunction::StepsFunction:
                 // FIXME: add support for steps timing function.
                 return nullptr;
             case TimingFunction::LinearFunction:
-                timingFunctionType = WebKit::WebAnimationCurve::TimingFunctionTypeLinear;
+                timingFunctionType = blink::WebAnimationCurve::TimingFunctionTypeLinear;
                 break;
             case TimingFunction::CubicBezierFunction:
                 {
                     const CubicBezierTimingFunction* originalBezierTimingFunction = static_cast<const CubicBezierTimingFunction*>(originalTimingFunction);
                     isUsingCustomBezierTimingFunction = true;
                     x1 = originalBezierTimingFunction->x1();
                     y1 = originalBezierTimingFunction->y1();
                     x2 = originalBezierTimingFunction->x2();
                     y2 = originalBezierTimingFunction->y2();
                     break;
@@ skipping 11 matching lines @@
 
         bool addedKeyframe = false;
         if (isUsingCustomBezierTimingFunction)
             addedKeyframe = appendKeyframeWithCustomBezierTimingFunction<Value, Keyframe, Curve>(curve, keyTime, originalValue, lastOriginalValue, x1, y1, x2, y2, boxSize);
         else
             addedKeyframe = appendKeyframeWithStandardTimingFunction<Value, Keyframe, Curve>(curve, keyTime, originalValue, lastOriginalValue, timingFunctionType, boxSize);
         if (!addedKeyframe)
             return nullptr;
     }
 
-    OwnPtr<WebKit::WebAnimation> webAnimation = adoptPtr(Platform::current()->compositorSupport()->createAnimation(*curve, targetProperty, animationId));
+    OwnPtr<blink::WebAnimation> webAnimation = adoptPtr(Platform::current()->compositorSupport()->createAnimation(*curve, targetProperty, animationId));
 
     int iterations = (animation && animation->isIterationCountSet()) ? animation->iterationCount() : 1;
     webAnimation->setIterations(iterations);
     webAnimation->setAlternatesDirection(alternate);
 
     // If timeOffset > 0, then the animation has started in the past.
     webAnimation->setTimeOffset(timeOffset);
 
     return webAnimation.release();
 }
 
-PassOwnPtr<WebKit::WebAnimation> createWebAnimation(const KeyframeValueList& values, const CSSAnimationData* animation, int animationId, double timeOffset, const FloatSize& boxSize)
+PassOwnPtr<blink::WebAnimation> createWebAnimation(const KeyframeValueList& values, const CSSAnimationData* animation, int animationId, double timeOffset, const FloatSize& boxSize)
 {
     switch (values.property()) {
     case AnimatedPropertyWebkitTransform: {
         OwnPtr<WebTransformAnimationCurve> curve = adoptPtr(Platform::current()->compositorSupport()->createTransformAnimationCurve());
-        return createWebAnimation<TransformAnimationValue, WebTransformKeyframe, WebTransformAnimationCurve>(values, animation, animationId, timeOffset, curve.get(), WebKit::WebAnimation::TargetPropertyTransform, FloatSize(boxSize));
+        return createWebAnimation<TransformAnimationValue, WebTransformKeyframe, WebTransformAnimationCurve>(values, animation, animationId, timeOffset, curve.get(), blink::WebAnimation::TargetPropertyTransform, FloatSize(boxSize));
     }
 
     case AnimatedPropertyOpacity: {
         OwnPtr<WebFloatAnimationCurve> curve = adoptPtr(Platform::current()->compositorSupport()->createFloatAnimationCurve());
-        return createWebAnimation<FloatAnimationValue, WebFloatKeyframe, WebFloatAnimationCurve>(values, animation, animationId, timeOffset, curve.get(), WebKit::WebAnimation::TargetPropertyOpacity, FloatSize());
+        return createWebAnimation<FloatAnimationValue, WebFloatKeyframe, WebFloatAnimationCurve>(values, animation, animationId, timeOffset, curve.get(), blink::WebAnimation::TargetPropertyOpacity, FloatSize());
     }
 
     case AnimatedPropertyWebkitFilter: {
         OwnPtr<WebFilterAnimationCurve> curve = adoptPtr(Platform::current()->compositorSupport()->createFilterAnimationCurve());
-        return createWebAnimation<FilterAnimationValue, WebFilterKeyframe, WebFilterAnimationCurve>(values, animation, animationId, timeOffset, curve.get(), WebKit::WebAnimation::TargetPropertyFilter, FloatSize(boxSize));
+        return createWebAnimation<FilterAnimationValue, WebFilterKeyframe, WebFilterAnimationCurve>(values, animation, animationId, timeOffset, curve.get(), blink::WebAnimation::TargetPropertyFilter, FloatSize(boxSize));
     }
 
     case AnimatedPropertyBackgroundColor:
     case AnimatedPropertyInvalid:
         return nullptr;
     }
 
     return nullptr;
 }
 
 } // namespace WebCore