Changeset 201715 in webkit


Ignore:
Timestamp:
Jun 6, 2016 10:56:33 AM (8 years ago)
Author:
Ryan Haddad
Message:

Unreviewed, rolling out r201706.
https://bugs.webkit.org/show_bug.cgi?id=158427

This change broke the Yosemite build and its LayoutTest is
failing on Mac and iOS testers (Requested by ryanhaddad on
#webkit).

Reverted changeset:

"Add experimental support for spring based CSS animations"
https://bugs.webkit.org/show_bug.cgi?id=158403
http://trac.webkit.org/changeset/201706

Patch by Commit Queue <commit-queue@webkit.org> on 2016-06-06

Location:
trunk
Files:
9 deleted
28 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r201714 r201715  
     12016-06-06  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r201706.
     4        https://bugs.webkit.org/show_bug.cgi?id=158427
     5
     6        This change broke the Yosemite build and its LayoutTest is
     7        failing on Mac and iOS testers (Requested by ryanhaddad on
     8        #webkit).
     9
     10        Reverted changeset:
     11
     12        "Add experimental support for spring based CSS animations"
     13        https://bugs.webkit.org/show_bug.cgi?id=158403
     14        http://trac.webkit.org/changeset/201706
     15
    1162016-06-03  Oliver Hunt  <oliver@apple.com>
    217
  • trunk/Source/WebCore/ChangeLog

    r201709 r201715  
     12016-06-06  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r201706.
     4        https://bugs.webkit.org/show_bug.cgi?id=158427
     5
     6        This change broke the Yosemite build and its LayoutTest is
     7        failing on Mac and iOS testers (Requested by ryanhaddad on
     8        #webkit).
     9
     10        Reverted changeset:
     11
     12        "Add experimental support for spring based CSS animations"
     13        https://bugs.webkit.org/show_bug.cgi?id=158403
     14        http://trac.webkit.org/changeset/201706
     15
    1162016-06-06  Javier Fernandez  <jfernandez@igalia.com>
    217
  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r201706 r201715  
    27652765                7C7941E41C56C29300A4C58E /* DataDetectorsCoreSoftLink.mm in Sources */ = {isa = PBXBuildFile; fileRef = 7C7941E21C56C29300A4C58E /* DataDetectorsCoreSoftLink.mm */; };
    27662766                7C7941E51C56C29300A4C58E /* DataDetectorsCoreSoftLink.h in Headers */ = {isa = PBXBuildFile; fileRef = 7C7941E31C56C29300A4C58E /* DataDetectorsCoreSoftLink.h */; };
    2767                 7C83DE861D04CC5D00FEBCF3 /* SpringSolver.h in Headers */ = {isa = PBXBuildFile; fileRef = 7C83DE851D04CBD400FEBCF3 /* SpringSolver.h */; };
    27682767                7C91A38F1B498ABE003F9EFA /* JSNodeOrString.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7C91A38D1B498ABE003F9EFA /* JSNodeOrString.cpp */; };
    27692768                7C91A3901B498ABE003F9EFA /* JSNodeOrString.h in Headers */ = {isa = PBXBuildFile; fileRef = 7C91A38E1B498ABE003F9EFA /* JSNodeOrString.h */; };
     
    1043210431                7C7941E21C56C29300A4C58E /* DataDetectorsCoreSoftLink.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = DataDetectorsCoreSoftLink.mm; sourceTree = "<group>"; };
    1043310432                7C7941E31C56C29300A4C58E /* DataDetectorsCoreSoftLink.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DataDetectorsCoreSoftLink.h; sourceTree = "<group>"; };
    10434                 7C83DE851D04CBD400FEBCF3 /* SpringSolver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SpringSolver.h; sourceTree = "<group>"; };
    1043510433                7C91A38D1B498ABE003F9EFA /* JSNodeOrString.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSNodeOrString.cpp; sourceTree = "<group>"; };
    1043610434                7C91A38E1B498ABE003F9EFA /* JSNodeOrString.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSNodeOrString.h; sourceTree = "<group>"; };
     
    2206722065                                CD641EB21818F5ED00EE4C41 /* SourceBufferPrivate.h */,
    2206822066                                CDC8B5AC1804AE5D0016E685 /* SourceBufferPrivateClient.h */,
    22069                                 7C83DE851D04CBD400FEBCF3 /* SpringSolver.h */,
    2207022067                                B23540F00D00782E002382FA /* StringTruncator.cpp */,
    2207122068                                B23540F10D00782E002382FA /* StringTruncator.h */,
     
    2784427841                                BC14028B0E83680800319717 /* ScrollbarThemeComposite.h in Headers */,
    2784527842                                44C991860F3D1EBE00586670 /* ScrollbarThemeIOS.h in Headers */,
    27846                                 7C83DE861D04CC5D00FEBCF3 /* SpringSolver.h in Headers */,
    2784727843                                BC8B853E0E7C7F1100AB6984 /* ScrollbarThemeMac.h in Headers */,
    2784827844                                0FE71406142170B800DB33BA /* ScrollbarThemeMock.h in Headers */,
  • trunk/Source/WebCore/css/CSSComputedStyleDeclaration.cpp

    r201706 r201715  
    14991499    switch (timingFunction->type()) {
    15001500    case TimingFunction::CubicBezierFunction: {
    1501         auto& function = *static_cast<const CubicBezierTimingFunction*>(timingFunction);
    1502         if (function.timingFunctionPreset() != CubicBezierTimingFunction::Custom) {
     1501        const CubicBezierTimingFunction* bezierTimingFunction = static_cast<const CubicBezierTimingFunction*>(timingFunction);
     1502        if (bezierTimingFunction->timingFunctionPreset() != CubicBezierTimingFunction::Custom) {
    15031503            CSSValueID valueId = CSSValueInvalid;
    1504             switch (function.timingFunctionPreset()) {
     1504            switch (bezierTimingFunction->timingFunctionPreset()) {
    15051505            case CubicBezierTimingFunction::Ease:
    15061506                valueId = CSSValueEase;
     
    15131513                break;
    15141514            default:
    1515                 ASSERT(function.timingFunctionPreset() == CubicBezierTimingFunction::EaseInOut);
     1515                ASSERT(bezierTimingFunction->timingFunctionPreset() == CubicBezierTimingFunction::EaseInOut);
    15161516                valueId = CSSValueEaseInOut;
    15171517                break;
     
    15191519            return CSSValuePool::singleton().createIdentifierValue(valueId);
    15201520        }
    1521         return CSSCubicBezierTimingFunctionValue::create(function.x1(), function.y1(), function.x2(), function.y2());
     1521        return CSSCubicBezierTimingFunctionValue::create(bezierTimingFunction->x1(), bezierTimingFunction->y1(), bezierTimingFunction->x2(), bezierTimingFunction->y2());
    15221522    }
    15231523    case TimingFunction::StepsFunction: {
    1524         auto& function = *static_cast<const StepsTimingFunction*>(timingFunction);
    1525         return CSSStepsTimingFunctionValue::create(function.numberOfSteps(), function.stepAtStart());
    1526     }
    1527     case TimingFunction::SpringFunction: {
    1528         auto& function = *static_cast<const SpringTimingFunction*>(timingFunction);
    1529         return CSSSpringTimingFunctionValue::create(function.mass(), function.stiffness(), function.damping(), function.initialVelocity());
     1524        const StepsTimingFunction* stepsTimingFunction = static_cast<const StepsTimingFunction*>(timingFunction);
     1525        return CSSStepsTimingFunctionValue::create(stepsTimingFunction->numberOfSteps(), stepsTimingFunction->stepAtStart());
    15301526    }
    15311527    default:
  • trunk/Source/WebCore/css/CSSParser.cpp

    r201706 r201715  
    271271        textAutosizingEnabled = settings->textAutosizingEnabled();
    272272#endif
    273         springTimingFunctionEnabled = settings->springTimingFunctionEnabled();
    274273    }
    275274
     
    293292        && a.needsSiteSpecificQuirks == b.needsSiteSpecificQuirks
    294293        && a.enforcesCSSMIMETypeInNoQuirksMode == b.enforcesCSSMIMETypeInNoQuirksMode
    295         && a.useLegacyBackgroundSizeShorthandBehavior == b.useLegacyBackgroundSizeShorthandBehavior
    296         && a.springTimingFunctionEnabled == b.springTimingFunctionEnabled;
     294        && a.useLegacyBackgroundSizeShorthandBehavior == b.useLegacyBackgroundSizeShorthandBehavior;
    297295}
    298296
     
    51605158}
    51615159
    5162 bool CSSParser::isSpringTimingFunctionEnabled() const
    5163 {
    5164     return m_context.springTimingFunctionEnabled;
    5165 }
    5166 
    5167 Optional<double> CSSParser::parseCubicBezierTimingFunctionValue(CSSParserValueList& args)
     5160bool CSSParser::parseCubicBezierTimingFunctionValue(CSSParserValueList& args, double& result)
    51685161{
    51695162    ValueWithCalculation argumentWithCalculation(*args.current());
    51705163    if (!validateUnit(argumentWithCalculation, FNumber))
    5171         return Nullopt;
    5172     Optional<double> result = parsedDouble(argumentWithCalculation);
     5164        return false;
     5165    result = parsedDouble(argumentWithCalculation);
    51735166    CSSParserValue* nextValue = args.next();
    51745167    if (!nextValue) {
    51755168        // The last number in the function has no comma after it, so we're done.
    5176         return result;
     5169        return true;
    51775170    }
    51785171    if (!isComma(nextValue))
    5179         return Nullopt;
     5172        return false;
    51805173    args.next();
    5181     return result;
    5182 }
    5183 
    5184 Optional<double> CSSParser::parseSpringTimingFunctionValue(CSSParserValueList& args)
    5185 {
    5186     ValueWithCalculation argumentWithCalculation(*args.current());
    5187     if (!validateUnit(argumentWithCalculation, FNumber))
    5188         return Nullopt;
    5189     Optional<double> result = parsedDouble(argumentWithCalculation);
    5190     args.next();
    5191     return result;
     5174    return true;
    51925175}
    51935176
     
    52375220
    52385221    if (equalLettersIgnoringASCIICase(value.function->name, "cubic-bezier(")) {
    5239         // For cubic bezier, 4 values must be specified (comma-separated).
     5222        // For cubic bezier, 4 values must be specified.
    52405223        if (!args || args->size() != 7)
    52415224            return nullptr;
    52425225
    52435226        // There are two points specified. The x values must be between 0 and 1 but the y values can exceed this range.
    5244 
    5245         auto x1 = parseCubicBezierTimingFunctionValue(*args);
    5246         if (!x1)
     5227        double x1, y1, x2, y2;
     5228
     5229        if (!parseCubicBezierTimingFunctionValue(*args, x1))
    52475230            return nullptr;
    5248         if (x1.value() < 0 || x1.value() > 1)
     5231        if (x1 < 0 || x1 > 1)
    52495232            return nullptr;
    5250 
    5251         auto y1 = parseCubicBezierTimingFunctionValue(*args);
    5252         if (!y1)
     5233        if (!parseCubicBezierTimingFunctionValue(*args, y1))
    52535234            return nullptr;
    5254 
    5255         auto x2 = parseCubicBezierTimingFunctionValue(*args);
    5256         if (!x2)
     5235        if (!parseCubicBezierTimingFunctionValue(*args, x2))
    52575236            return nullptr;
    5258         if (x2.value() < 0 || x2.value() > 1)
     5237        if (x2 < 0 || x2 > 1)
    52595238            return nullptr;
    5260 
    5261         auto y2 = parseCubicBezierTimingFunctionValue(*args);
    5262         if (!y2)
     5239        if (!parseCubicBezierTimingFunctionValue(*args, y2))
    52635240            return nullptr;
    52645241
    5265         return CSSCubicBezierTimingFunctionValue::create(x1.value(), y1.value(), x2.value(), y2.value());
    5266     }
    5267 
    5268     if (isSpringTimingFunctionEnabled() && equalLettersIgnoringASCIICase(value.function->name, "spring(")) {
    5269         // For a spring, 4 values must be specified (space-separated).
    5270         if (!args || args->size() != 4)
    5271             return nullptr;
    5272        
    5273         // Mass must be greater than 0.
    5274         auto mass = parseSpringTimingFunctionValue(*args);
    5275         if (!mass)
    5276             return nullptr;
    5277         if (mass.value() <= 0)
    5278             return nullptr;
    5279 
    5280         // Stiffness must be greater than 0.
    5281         auto stiffness = parseSpringTimingFunctionValue(*args);
    5282         if (!stiffness)
    5283             return nullptr;
    5284         if (stiffness.value() <= 0)
    5285             return nullptr;
    5286 
    5287         // Damping coefficient must be greater than or equal to 0.
    5288         auto damping = parseSpringTimingFunctionValue(*args);
    5289         if (!damping)
    5290             return nullptr;
    5291         if (damping.value() < 0)
    5292             return nullptr;
    5293 
    5294         // Initial velocity may have any value.
    5295         auto initialVelocity = parseSpringTimingFunctionValue(*args);
    5296         if (!initialVelocity)
    5297             return nullptr;
    5298 
    5299         return CSSSpringTimingFunctionValue::create(mass.value(), stiffness.value(), damping.value(), initialVelocity.value());
     5242        return CSSCubicBezierTimingFunctionValue::create(x1, y1, x2, y2);
    53005243    }
    53015244
  • trunk/Source/WebCore/css/CSSParser.h

    r201706 r201715  
    215215
    216216    bool parseTransformOriginShorthand(RefPtr<CSSPrimitiveValue>&, RefPtr<CSSPrimitiveValue>&, RefPtr<CSSValue>&);
    217     Optional<double> parseCubicBezierTimingFunctionValue(CSSParserValueList&);
    218     Optional<double> parseSpringTimingFunctionValue(CSSParserValueList&);
     217    bool parseCubicBezierTimingFunctionValue(CSSParserValueList& args, double& result);
    219218    bool parseAnimationProperty(CSSPropertyID, RefPtr<CSSValue>&, AnimationParseContext&);
    220219    bool parseTransitionShorthand(CSSPropertyID, bool important);
    221220    bool parseAnimationShorthand(CSSPropertyID, bool important);
    222 
    223     bool isSpringTimingFunctionEnabled() const;
    224221
    225222    RefPtr<CSSPrimitiveValue> parseColumnWidth();
  • trunk/Source/WebCore/css/CSSParserMode.h

    r201706 r201715  
    7474    bool enforcesCSSMIMETypeInNoQuirksMode { true };
    7575    bool useLegacyBackgroundSizeShorthandBehavior { false };
    76     bool springTimingFunctionEnabled { false };
    7776};
    7877
  • trunk/Source/WebCore/css/CSSTimingFunctionValue.cpp

    r201706 r201715  
    11/*
    2  * Copyright (C) 2007, 2013, 2016 Apple Inc. All rights reserved.
     2 * Copyright (C) 2007, 2013 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    2727#include "CSSTimingFunctionValue.h"
    2828
    29 #include <wtf/text/StringBuilder.h>
     29#include <wtf/text/WTFString.h>
    3030
    3131namespace WebCore {
     
    3333String CSSCubicBezierTimingFunctionValue::customCSSText() const
    3434{
    35     StringBuilder builder;
    36     builder.appendLiteral("cubic-bezier(");
    37     builder.appendNumber(m_x1);
    38     builder.appendLiteral(", ");
    39     builder.appendNumber(m_y1);
    40     builder.appendLiteral(", ");
    41     builder.appendNumber(m_x2);
    42     builder.appendLiteral(", ");
    43     builder.appendNumber(m_y2);
    44     builder.append(')');   
    45     return builder.toString();
     35    return "cubic-bezier("
     36        + String::number(m_x1) + ", "
     37        + String::number(m_y1) + ", "
     38        + String::number(m_x2) + ", "
     39        + String::number(m_y2) + ')';
    4640}
    4741
     
    5145}
    5246
     47
    5348String CSSStepsTimingFunctionValue::customCSSText() const
    5449{
    55     StringBuilder builder;
    56     builder.appendLiteral("steps(");
    57     builder.appendNumber(m_steps);
    58     if (m_stepAtStart)
    59         builder.appendLiteral(", start)");
    60     else
    61         builder.appendLiteral(", end)");
    62     return builder.toString();
     50    return "steps(" + String::number(m_steps) + ", " + (m_stepAtStart ? "start" : "end") + ')';
    6351}
    6452
     
    6856}
    6957
    70 String CSSSpringTimingFunctionValue::customCSSText() const
    71 {
    72     StringBuilder builder;
    73     builder.appendLiteral("spring(");
    74     builder.appendNumber(m_mass);
    75     builder.append(' ');
    76     builder.appendNumber(m_stiffness);
    77     builder.append(' ');
    78     builder.appendNumber(m_damping);
    79     builder.append(' ');
    80     builder.appendNumber(m_initialVelocity);
    81     builder.append(')');
    82     return builder.toString();
    83 }
    84 
    85 bool CSSSpringTimingFunctionValue::equals(const CSSSpringTimingFunctionValue& other) const
    86 {
    87     return m_mass == other.m_mass && m_stiffness == other.m_stiffness && m_damping == other.m_damping && m_initialVelocity == other.m_initialVelocity;
    88 }
    89 
    90 
    9158} // namespace WebCore
  • trunk/Source/WebCore/css/CSSTimingFunctionValue.h

    r201706 r201715  
    11/*
    2  * Copyright (C) 2007, 2008, 2012, 2016 Apple Inc. All rights reserved.
     2 * Copyright (C) 2007, 2008, 2012 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    9090};
    9191
    92 class CSSSpringTimingFunctionValue : public CSSValue {
    93 public:
    94     static Ref<CSSSpringTimingFunctionValue> create(double mass, double stiffness, double damping, double initialVelocity)
    95     {
    96         return adoptRef(*new CSSSpringTimingFunctionValue(mass, stiffness, damping, initialVelocity));
    97     }
    98 
    99     double mass() const { return m_mass; }
    100     double stiffness() const { return m_stiffness; }
    101     double damping() const { return m_damping; }
    102     double initialVelocity() const { return m_initialVelocity; }
    103 
    104     String customCSSText() const;
    105 
    106     bool equals(const CSSSpringTimingFunctionValue&) const;
    107 
    108 private:
    109     CSSSpringTimingFunctionValue(double mass, double stiffness, double damping, double initialVelocity)
    110         : CSSValue(SpringTimingFunctionClass)
    111         , m_mass(mass)
    112         , m_stiffness(stiffness)
    113         , m_damping(damping)
    114         , m_initialVelocity(initialVelocity)
    115     {
    116     }
    117 
    118     double m_mass;
    119     double m_stiffness;
    120     double m_damping;
    121     double m_initialVelocity;
    122 };
    123 
    12492} // namespace WebCore
    12593
    12694SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSCubicBezierTimingFunctionValue, isCubicBezierTimingFunctionValue())
    12795SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSStepsTimingFunctionValue, isStepsTimingFunctionValue())
    128 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSSpringTimingFunctionValue, isSpringTimingFunctionValue())
    12996
    13097#endif // CSSTimingFunctionValue_h
  • trunk/Source/WebCore/css/CSSToStyleMap.cpp

    r201706 r201715  
    511511        auto& stepsTimingFunction = downcast<CSSStepsTimingFunctionValue>(value);
    512512        animation.setTimingFunction(StepsTimingFunction::create(stepsTimingFunction.numberOfSteps(), stepsTimingFunction.stepAtStart()));
    513     } else if (is<CSSSpringTimingFunctionValue>(value)) {
    514         auto& springTimingFunction = downcast<CSSSpringTimingFunctionValue>(value);
    515         animation.setTimingFunction(SpringTimingFunction::create(springTimingFunction.mass(), springTimingFunction.stiffness(), springTimingFunction.damping(), springTimingFunction.initialVelocity()));
    516513    }
    517514}
  • trunk/Source/WebCore/css/CSSValue.cpp

    r201706 r201715  
    227227        case StepsTimingFunctionClass:
    228228            return compareCSSValues<CSSStepsTimingFunctionValue>(*this, other);
    229         case SpringTimingFunctionClass:
    230             return compareCSSValues<CSSSpringTimingFunctionValue>(*this, other);
    231229        case UnicodeRangeClass:
    232230            return compareCSSValues<CSSUnicodeRangeValue>(*this, other);
     
    335333    case StepsTimingFunctionClass:
    336334        return downcast<CSSStepsTimingFunctionValue>(*this).customCSSText();
    337     case SpringTimingFunctionClass:
    338         return downcast<CSSSpringTimingFunctionValue>(*this).customCSSText();
    339335    case UnicodeRangeClass:
    340336        return downcast<CSSUnicodeRangeValue>(*this).customCSSText();
     
    461457    case StepsTimingFunctionClass:
    462458        delete downcast<CSSStepsTimingFunctionValue>(this);
    463         return;
    464     case SpringTimingFunctionClass:
    465         delete downcast<CSSSpringTimingFunctionValue>(this);
    466459        return;
    467460    case UnicodeRangeClass:
  • trunk/Source/WebCore/css/CSSValue.h

    r201706 r201715  
    105105    bool isCubicBezierTimingFunctionValue() const { return m_classType == CubicBezierTimingFunctionClass; }
    106106    bool isStepsTimingFunctionValue() const { return m_classType == StepsTimingFunctionClass; }
    107     bool isSpringTimingFunctionValue() const { return m_classType == SpringTimingFunctionClass; }
    108107    bool isWebKitCSSTransformValue() const { return m_classType == WebKitCSSTransformClass; }
    109108    bool isLineBoxContainValue() const { return m_classType == LineBoxContainClass; }
     
    163162        CubicBezierTimingFunctionClass,
    164163        StepsTimingFunctionClass,
    165         SpringTimingFunctionClass,
    166164
    167165        // Other class types.
  • trunk/Source/WebCore/page/Settings.in

    r201706 r201715  
    268268
    269269shouldConvertInvalidURLsToBlank initial=true
    270 
    271 springTimingFunctionEnabled initial=false
  • trunk/Source/WebCore/page/animation/AnimationBase.cpp

    r201706 r201715  
    4242#include "RenderStyle.h"
    4343#include "RenderView.h"
    44 #include "SpringSolver.h"
    4544#include "UnitBezier.h"
    4645#include <algorithm>
     
    7069        return std::min(1.0, (floor(numSteps * t) + 1) / numSteps);
    7170    return floor(numSteps * t) / numSteps;
    72 }
    73 
    74 static inline double solveSpringFunction(double mass, double stiffness, double damping, double initialVelocity, double t, double duration)
    75 {
    76     SpringSolver solver(mass, stiffness, damping, initialVelocity);
    77     return solver.solve(t * duration);
    7871}
    7972
     
    656649    switch (timingFunction->type()) {
    657650    case TimingFunction::CubicBezierFunction: {
    658         auto& function = *static_cast<const CubicBezierTimingFunction*>(timingFunction);
    659         return solveCubicBezierFunction(function.x1(), function.y1(), function.x2(), function.y2(), fractionalTime, m_animation->duration());
     651        const CubicBezierTimingFunction* function = static_cast<const CubicBezierTimingFunction*>(timingFunction);
     652        return solveCubicBezierFunction(function->x1(), function->y1(), function->x2(), function->y2(), fractionalTime, m_animation->duration());
    660653    }
    661654    case TimingFunction::StepsFunction: {
    662         auto& function = *static_cast<const StepsTimingFunction*>(timingFunction);
    663         return solveStepsFunction(function.numberOfSteps(), function.stepAtStart(), fractionalTime);
    664     }
    665     case TimingFunction::SpringFunction: {
    666         auto& function = *static_cast<const SpringTimingFunction*>(timingFunction);
    667         return solveSpringFunction(function.mass(), function.stiffness(), function.damping(), function.initialVelocity(), fractionalTime, m_animation->duration());
     655        const StepsTimingFunction* stepsTimingFunction = static_cast<const StepsTimingFunction*>(timingFunction);
     656        return solveStepsFunction(stepsTimingFunction->numberOfSteps(), stepsTimingFunction->stepAtStart(), fractionalTime);
    668657    }
    669658    case TimingFunction::LinearFunction:
  • trunk/Source/WebCore/platform/animation/TimingFunction.cpp

    r201706 r201715  
    3838        break;
    3939    case TimingFunction::CubicBezierFunction: {
    40         auto& function = static_cast<const CubicBezierTimingFunction&>(timingFunction);
    41         ts << "cubic-bezier(" << function.x1() << ", " << function.y1() << ", " <<  function.x2() << ", " << function.y2() << ")";
     40        const CubicBezierTimingFunction& cubicBezierFunction = static_cast<const CubicBezierTimingFunction&>(timingFunction);
     41        ts << "cubic-bezier(" << cubicBezierFunction.x1() << ", " << cubicBezierFunction.y1() << ", " <<  cubicBezierFunction.x2() << ", " << cubicBezierFunction.y2() << ")";
    4242        break;
    4343    }
    4444    case TimingFunction::StepsFunction: {
    45         auto& function = static_cast<const StepsTimingFunction&>(timingFunction);
    46         ts << "steps(" << function.numberOfSteps() << ", " << (function.stepAtStart() ? "start" : "end") << ")";
    47         break;
    48     }
    49     case TimingFunction::SpringFunction: {
    50         auto& function = static_cast<const SpringTimingFunction&>(timingFunction);
    51         ts << "spring(" << function.mass() << " " << function.stiffness() << " " <<  function.damping() << " " << function.initialVelocity() << ")";
     45        const StepsTimingFunction& stepsFunction = static_cast<const StepsTimingFunction&>(timingFunction);
     46        ts << "steps(" << stepsFunction.numberOfSteps() << ", " << (stepsFunction.stepAtStart() ? "start" : "end") << ")";
    5247        break;
    5348    }
  • trunk/Source/WebCore/platform/animation/TimingFunction.h

    r201706 r201715  
    3737
    3838    enum TimingFunctionType {
    39         LinearFunction, CubicBezierFunction, StepsFunction, SpringFunction
     39        LinearFunction, CubicBezierFunction, StepsFunction
    4040    };
    4141   
     
    4747    bool isCubicBezierTimingFunction() const { return m_type == CubicBezierFunction; }
    4848    bool isStepsTimingFunction() const { return m_type == StepsFunction; }
    49     bool isSpringTimingFunction() const { return m_type == SpringFunction; }
    5049   
    5150    virtual bool operator==(const TimingFunction& other) = 0;
     
    6059};
    6160
    62 class LinearTimingFunction final : public TimingFunction {
     61class LinearTimingFunction : public TimingFunction {
    6362public:
    6463    static PassRefPtr<LinearTimingFunction> create()
     
    8685};
    8786
    88 class CubicBezierTimingFunction final : public TimingFunction {
     87class CubicBezierTimingFunction : public TimingFunction {
    8988public:
    9089    enum TimingFunctionPreset {
     
    187186};
    188187
    189 class StepsTimingFunction final : public TimingFunction {
     188class StepsTimingFunction : public TimingFunction {
    190189public:
    191190   
     
    233232};
    234233
    235 class SpringTimingFunction final : public TimingFunction {
    236 public:
    237     static Ref<SpringTimingFunction> create(double mass, double stiffness, double damping, double initialVelocity)
    238     {
    239         return adoptRef(*new SpringTimingFunction(mass, stiffness, damping, initialVelocity));
    240     }
    241 
    242     static Ref<SpringTimingFunction> create()
    243     {
    244         // This create() function should only be used by the argument decoders, and it is expected that
    245         // real values will be filled in using setValues().
    246         return create(0, 0, 0, 0);
    247     }
    248    
    249     bool operator==(const TimingFunction& other) override
    250     {
    251         if (other.isSpringTimingFunction()) {
    252             const SpringTimingFunction& otherString = *static_cast<const SpringTimingFunction*>(&other);
    253 
    254             return m_mass == otherString.m_mass && m_stiffness == otherString.m_stiffness && m_damping == otherString.m_damping && m_initialVelocity == otherString.m_initialVelocity;
    255         }
    256         return false;
    257     }
    258 
    259     double mass() const { return m_mass; }
    260     double stiffness() const { return m_stiffness; }
    261     double damping() const { return m_damping; }
    262     double initialVelocity() const { return m_initialVelocity; }
    263    
    264     void setValues(double mass, double stiffness, double damping, double initialVelocity)
    265     {
    266         m_mass = mass;
    267         m_stiffness = stiffness;
    268         m_damping = damping;
    269         m_initialVelocity = initialVelocity;
    270     }
    271 
    272 private:
    273     explicit SpringTimingFunction(double mass, double stiffness, double damping, double initialVelocity)
    274         : TimingFunction(SpringFunction)
    275         , m_mass(mass)
    276         , m_stiffness(stiffness)
    277         , m_damping(damping)
    278         , m_initialVelocity(initialVelocity)
    279     {
    280     }
    281 
    282     PassRefPtr<TimingFunction> clone() const override
    283     {
    284         return adoptRef(new SpringTimingFunction(m_mass, m_stiffness, m_damping, m_initialVelocity));
    285     }
    286 
    287     double m_mass;
    288     double m_stiffness;
    289     double m_damping;
    290     double m_initialVelocity;
    291 };
    292 
    293234class TextStream;
    294235WEBCORE_EXPORT TextStream& operator<<(TextStream&, const TimingFunction&);
  • trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp

    r201706 r201715  
    27442744        valuesOK = setAnimationKeyframes(valueList, animation, caAnimation.get());
    27452745    } else {
    2746         if (animation->timingFunction()->isSpringTimingFunction())
    2747             caAnimation = createSpringAnimation(animation, propertyIdToString(valueList.property()), additive);
    2748         else
    2749             caAnimation = createBasicAnimation(animation, propertyIdToString(valueList.property()), additive);
     2746        caAnimation = createBasicAnimation(animation, propertyIdToString(valueList.property()), additive);
    27502747        valuesOK = setAnimationEndpoints(valueList, animation, caAnimation.get());
    27512748    }
     
    27712768        validMatrices = setTransformAnimationKeyframes(valueList, animation, caAnimation.get(), animationIndex, transformOp, isMatrixAnimation, boxSize);
    27722769    } else {
    2773         if (animation->timingFunction()->isSpringTimingFunction())
    2774             caAnimation = createSpringAnimation(animation, propertyIdToString(valueList.property()), additive);
    2775         else
    2776             caAnimation = createBasicAnimation(animation, propertyIdToString(valueList.property()), additive);
     2770        caAnimation = createBasicAnimation(animation, propertyIdToString(valueList.property()), additive);
    27772771        validMatrices = setTransformAnimationEndpoints(valueList, animation, caAnimation.get(), animationIndex, transformOp, isMatrixAnimation, boxSize);
    27782772    }
     
    29082902}
    29092903
    2910 PassRefPtr<PlatformCAAnimation> GraphicsLayerCA::createKeyframeAnimation(const Animation* anim, const String& keyPath, bool additive)
     2904PassRefPtr<PlatformCAAnimation>GraphicsLayerCA::createKeyframeAnimation(const Animation* anim, const String& keyPath, bool additive)
    29112905{
    29122906    RefPtr<PlatformCAAnimation> keyframeAnim = createPlatformCAAnimation(PlatformCAAnimation::Keyframe, keyPath);
    29132907    setupAnimation(keyframeAnim.get(), anim, additive);
    29142908    return keyframeAnim;
    2915 }
    2916 
    2917 RefPtr<PlatformCAAnimation> GraphicsLayerCA::createSpringAnimation(const Animation* anim, const String& keyPath, bool additive)
    2918 {
    2919     auto basicAnim = createPlatformCAAnimation(PlatformCAAnimation::Spring, keyPath);
    2920     setupAnimation(basicAnim.get(), anim, additive);
    2921     return basicAnim;
    29222909}
    29232910
  • trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h

    r201706 r201715  
    243243    PassRefPtr<PlatformCAAnimation> createBasicAnimation(const Animation*, const String& keyPath, bool additive);
    244244    PassRefPtr<PlatformCAAnimation> createKeyframeAnimation(const Animation*, const String&, bool additive);
    245     RefPtr<PlatformCAAnimation> createSpringAnimation(const Animation*, const String&, bool additive);
    246245    void setupAnimation(PlatformCAAnimation*, const Animation*, bool additive);
    247246   
  • trunk/Source/WebCore/platform/graphics/ca/PlatformCAAnimation.cpp

    r201706 r201715  
    3636    case PlatformCAAnimation::Basic: ts << "basic"; break;
    3737    case PlatformCAAnimation::Keyframe: ts << "keyframe"; break;
    38     case PlatformCAAnimation::Spring: ts << "spring"; break;
    3938    }
    4039    return ts;
     
    7170}
    7271
    73 bool PlatformCAAnimation::isBasicAnimation() const
    74 {
    75     return animationType() == Basic || animationType() == Spring;
    76 }
    77 
    7872} // namespace WebCore
  • trunk/Source/WebCore/platform/graphics/ca/PlatformCAAnimation.h

    r201706 r201715  
    4242class PlatformCAAnimation : public RefCounted<PlatformCAAnimation> {
    4343public:
    44     enum AnimationType { Basic, Keyframe, Spring };
     44    enum AnimationType { Basic, Keyframe };
    4545    enum FillModeType { NoFillMode, Forwards, Backwards, Both };
    4646    enum ValueFunctionType { NoValueFunction, RotateX, RotateY, RotateZ, ScaleX, ScaleY, ScaleZ, Scale, TranslateX, TranslateY, TranslateZ, Translate };
     
    124124            setBeginTime(t);
    125125    }
    126 
    127     bool isBasicAnimation() const;
    128126   
    129127protected:
  • trunk/Source/WebCore/platform/graphics/ca/cocoa/PlatformCAAnimationCocoa.mm

    r201706 r201715  
    162162    : PlatformCAAnimation(type)
    163163{
    164     switch (type) {
    165     case Basic:
     164    if (type == Basic)
    166165        m_animation = [CABasicAnimation animationWithKeyPath:keyPath];
    167         break;
    168     case Keyframe:
     166    else
    169167        m_animation = [CAKeyframeAnimation animationWithKeyPath:keyPath];
    170         break;
    171     case Spring:
    172         m_animation = [CASpringAnimation animationWithKeyPath:keyPath];
    173         break;
    174     }
    175168}
    176169
    177170PlatformCAAnimationCocoa::PlatformCAAnimationCocoa(PlatformAnimationRef animation)
    178171{
    179     if ([static_cast<CAAnimation*>(animation) isKindOfClass:[CABasicAnimation class]]) {
    180         if ([static_cast<CAAnimation*>(animation) isKindOfClass:[CASpringAnimation class]])
    181             setType(Spring);
    182         else
    183             setType(Basic);
    184     } else if ([static_cast<CAAnimation*>(animation) isKindOfClass:[CAKeyframeAnimation class]])
     172    if ([static_cast<CAAnimation*>(animation) isKindOfClass:[CABasicAnimation class]])
     173        setType(Basic);
     174    else if ([static_cast<CAAnimation*>(animation) isKindOfClass:[CAKeyframeAnimation class]])
    185175        setType(Keyframe);
    186176    else {
    187         ASSERT_NOT_REACHED();
     177        ASSERT(0);
    188178        return;
    189179    }
     
    316306void PlatformCAAnimationCocoa::setTimingFunction(const TimingFunction* value, bool reverse)
    317307{
    318     switch (animationType()) {
    319     case Basic:
    320     case Keyframe:
    321         [m_animation setTimingFunction:toCAMediaTimingFunction(value, reverse)];
    322         break;
    323     case Spring:
    324         if (value->isSpringTimingFunction()) {
    325             // FIXME: Handle reverse.
    326             auto& function = *static_cast<const SpringTimingFunction*>(value);
    327             CASpringAnimation *springAnimation = (CASpringAnimation *)m_animation.get();
    328             springAnimation.mass = function.mass();
    329             springAnimation.stiffness = function.stiffness();
    330             springAnimation.damping = function.damping();
    331             springAnimation.initialVelocity = function.initialVelocity();
    332         }
    333         break;
    334     }
     308    [m_animation setTimingFunction:toCAMediaTimingFunction(value, reverse)];
    335309}
    336310
     
    373347void PlatformCAAnimationCocoa::setFromValue(float value)
    374348{
    375     if (!isBasicAnimation())
     349    if (animationType() != Basic)
    376350        return;
    377351    [static_cast<CABasicAnimation*>(m_animation.get()) setFromValue:[NSNumber numberWithDouble:value]];
     
    380354void PlatformCAAnimationCocoa::setFromValue(const WebCore::TransformationMatrix& value)
    381355{
    382     if (!isBasicAnimation())
     356    if (animationType() != Basic)
    383357        return;
    384358
     
    388362void PlatformCAAnimationCocoa::setFromValue(const FloatPoint3D& value)
    389363{
    390     if (!isBasicAnimation())
     364    if (animationType() != Basic)
    391365        return;
    392366
     
    401375void PlatformCAAnimationCocoa::setFromValue(const WebCore::Color& value)
    402376{
    403     if (!isBasicAnimation())
     377    if (animationType() != Basic)
    404378        return;
    405379
     
    421395void PlatformCAAnimationCocoa::copyFromValueFrom(const PlatformCAAnimation& value)
    422396{
    423     if (!isBasicAnimation() || !value.isBasicAnimation())
     397    if (animationType() != Basic || value.animationType() != Basic)
    424398        return;
    425399
     
    430404void PlatformCAAnimationCocoa::setToValue(float value)
    431405{
    432     if (!isBasicAnimation())
     406    if (animationType() != Basic)
    433407        return;
    434408    [static_cast<CABasicAnimation*>(m_animation.get()) setToValue:[NSNumber numberWithDouble:value]];
     
    437411void PlatformCAAnimationCocoa::setToValue(const WebCore::TransformationMatrix& value)
    438412{
    439     if (!isBasicAnimation())
     413    if (animationType() != Basic)
    440414        return;
    441415
     
    445419void PlatformCAAnimationCocoa::setToValue(const FloatPoint3D& value)
    446420{
    447     if (!isBasicAnimation())
     421    if (animationType() != Basic)
    448422        return;
    449423
     
    458432void PlatformCAAnimationCocoa::setToValue(const WebCore::Color& value)
    459433{
    460     if (!isBasicAnimation())
     434    if (animationType() != Basic)
    461435        return;
    462436
     
    478452void PlatformCAAnimationCocoa::copyToValueFrom(const PlatformCAAnimation& value)
    479453{
    480     if (!isBasicAnimation() || !value.isBasicAnimation())
     454    if (animationType() != Basic || value.animationType() != Basic)
    481455        return;
    482456
  • trunk/Source/WebKit2/ChangeLog

    r201708 r201715  
     12016-06-06  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r201706.
     4        https://bugs.webkit.org/show_bug.cgi?id=158427
     5
     6        This change broke the Yosemite build and its LayoutTest is
     7        failing on Mac and iOS testers (Requested by ryanhaddad on
     8        #webkit).
     9
     10        Reverted changeset:
     11
     12        "Add experimental support for spring based CSS animations"
     13        https://bugs.webkit.org/show_bug.cgi?id=158403
     14        http://trac.webkit.org/changeset/201706
     15
    1162016-06-06  Alex Christensen  <achristensen@webkit.org>
    217
  • trunk/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedGraphicsArgumentCoders.cpp

    r201706 r201715  
    366366        break;
    367367    }
    368     case TimingFunction::SpringFunction: {
    369         const SpringTimingFunction* spring = static_cast<const SpringTimingFunction*>(timingFunction);
    370         encoder << spring->mass();
    371         encoder << spring->stiffness();
    372         encoder << spring->damping();
    373         encoder << spring->initialVelocity();
    374         break;
    375     }
    376368    }
    377369}
     
    420412
    421413        timingFunction = StepsTimingFunction::create(numberOfSteps, stepAtStart);
    422         return true;
    423     }
    424     case TimingFunction::SpringFunction: {
    425         double mass;
    426         if (!decoder.decode(mass))
    427             return false;
    428         double stiffness;
    429         if (!decoder.decode(stiffness))
    430             return false;
    431         double damping;
    432         if (!decoder.decode(damping))
    433             return false;
    434         double initialVelocity;
    435         if (!decoder.decode(initialVelocity))
    436             return false;
    437 
    438         timingFunction = SpringTimingFunction::create(mass, stiffness, damping, initialVelocity);
    439414        return true;
    440415    }
  • trunk/Source/WebKit2/Shared/WebCoreArgumentCoders.cpp

    r201706 r201715  
    266266}
    267267
    268 void ArgumentCoder<SpringTimingFunction>::encode(ArgumentEncoder& encoder, const SpringTimingFunction& timingFunction)
    269 {
    270     encoder.encodeEnum(timingFunction.type());
    271    
    272     encoder << timingFunction.mass();
    273     encoder << timingFunction.stiffness();
    274     encoder << timingFunction.damping();
    275     encoder << timingFunction.initialVelocity();
    276 }
    277 
    278 bool ArgumentCoder<SpringTimingFunction>::decode(ArgumentDecoder& decoder, SpringTimingFunction& timingFunction)
    279 {
    280     // Type is decoded by the caller.
    281     double mass;
    282     if (!decoder.decode(mass))
    283         return false;
    284 
    285     double stiffness;
    286     if (!decoder.decode(stiffness))
    287         return false;
    288 
    289     double damping;
    290     if (!decoder.decode(damping))
    291         return false;
    292 
    293     double initialVelocity;
    294     if (!decoder.decode(initialVelocity))
    295         return false;
    296 
    297     timingFunction.setValues(mass, stiffness, damping, initialVelocity);
    298 
    299     return true;
    300 }
    301 
    302268void ArgumentCoder<FloatPoint>::encode(ArgumentEncoder& encoder, const FloatPoint& floatPoint)
    303269{
  • trunk/Source/WebKit2/Shared/WebCoreArgumentCoders.h

    r201706 r201715  
    6161class ResourceResponse;
    6262class SessionID;
    63 class SpringTimingFunction;
    6463class StepsTimingFunction;
    6564class StickyPositionViewportConstraints;
     
    153152};
    154153
    155 template<> struct ArgumentCoder<WebCore::SpringTimingFunction> {
    156     static void encode(ArgumentEncoder&, const WebCore::SpringTimingFunction&);
    157     static bool decode(ArgumentDecoder&, WebCore::SpringTimingFunction&);
    158 };
    159 
    160154template<> struct ArgumentCoder<WebCore::CertificateInfo> {
    161155    static void encode(ArgumentEncoder&, const WebCore::CertificateInfo&);
  • trunk/Source/WebKit2/Shared/WebPreferencesDefinitions.h

    r201706 r201715  
    294294    macro(CustomElementsEnabled, customElementsEnabled, Bool, bool, true, "Custom Elements", "HTML Custom Elements prototype") \
    295295    macro(WebGL2Enabled, webGL2Enabled, Bool, bool, true, "WebGL 2.0", "WebGL 2 prototype") \
    296     macro(SpringTimingFunctionEnabled, springTimingFunctionEnabled, Bool, bool, true, "CSS Spring Animations", "CSS Spring Animation prototype") \
    297296    \
    298297
  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.cpp

    r201706 r201715  
    31513151#endif
    31523152
    3153     settings.setSpringTimingFunctionEnabled(store.getBoolValueForKey(WebPreferencesKey::springTimingFunctionEnabledKey()));
    3154 
    31553153    bool processSuppressionEnabled = store.getBoolValueForKey(WebPreferencesKey::pageVisibilityBasedProcessSuppressionEnabledKey());
    31563154    if (m_processSuppressionEnabled != processSuppressionEnabled) {
  • trunk/Source/WebKit2/WebProcess/WebPage/mac/PlatformCAAnimationRemote.mm

    r201706 r201715  
    197197            encoder << *static_cast<StepsTimingFunction*>(timingFunction.get());
    198198            break;
    199 
    200         case TimingFunction::SpringFunction:
    201             encoder << *static_cast<SpringTimingFunction*>(timingFunction.get());
    202             break;
    203199        }
    204200    }
     
    287283                    return false;
    288284                break;
    289 
    290             case TimingFunction::SpringFunction:
    291                 timingFunction = SpringTimingFunction::create();
    292                 if (!decoder.decode(*static_cast<SpringTimingFunction*>(timingFunction.get())))
    293                     return false;
    294                 break;
    295285            }
    296286           
     
    765755        break;
    766756    }
    767     case PlatformCAAnimation::Spring: {
    768         RetainPtr<CASpringAnimation> springAnimation;
    769         springAnimation = [CASpringAnimation animationWithKeyPath:properties.keyPath];
    770        
    771         if (properties.keyValues.size() > 1) {
    772             [springAnimation setFromValue:animationValueFromKeyframeValue(properties.keyValues[0])];
    773             [springAnimation setToValue:animationValueFromKeyframeValue(properties.keyValues[1])];
    774         }
    775        
    776         if (properties.timingFunctions.size()) {
    777             auto& timingFunction = properties.timingFunctions[0];
    778             if (timingFunction->isSpringTimingFunction()) {
    779                 auto& function = *static_cast<const SpringTimingFunction*>(timingFunction.get());
    780                 [springAnimation setMass:function.mass()];
    781                 [springAnimation setStiffness:function.stiffness()];
    782                 [springAnimation setDamping:function.damping()];
    783                 [springAnimation setInitialVelocity:function.initialVelocity()];
    784             }
    785         }
    786         caAnimation = springAnimation;
    787         break;
    788     }
    789757    }
    790758   
Note: See TracChangeset for help on using the changeset viewer.