Merge WebKit at r80534: Intial merge by Git

Change-Id: Ia7a83357124c9e1cdb1debf55d9661ec0bd09a61

17 files changed, 175 insertions, 82 deletions

diff --git a/Source/WebCore/platform/graphics/filters/FEBlend.cpp b/Source/WebCore/platform/graphics/filters/FEBlend.cpp
index ac68266..e5db03e 100644
--- a/Source/WebCore/platform/graphics/filters/FEBlend.cpp
+++ b/Source/WebCore/platform/graphics/filters/FEBlend.cpp
@@ -53,9 +53,12 @@ BlendModeType FEBlend::blendMode() const
     return m_mode;
 }
 
-void FEBlend::setBlendMode(BlendModeType mode)
+bool FEBlend::setBlendMode(BlendModeType mode)
 {
+    if (m_mode == mode)
+        return false;
     m_mode = mode;
+    return true;
 }
 
 static unsigned char unknown(unsigned char, unsigned char, unsigned char, unsigned char)
diff --git a/Source/WebCore/platform/graphics/filters/FEBlend.h b/Source/WebCore/platform/graphics/filters/FEBlend.h
index 4c59578..def33be 100644
--- a/Source/WebCore/platform/graphics/filters/FEBlend.h
+++ b/Source/WebCore/platform/graphics/filters/FEBlend.h
@@ -43,7 +43,7 @@ public:
     static PassRefPtr<FEBlend> create(Filter*, BlendModeType);
 
     BlendModeType blendMode() const;
-    void setBlendMode(BlendModeType);
+    bool setBlendMode(BlendModeType);
 
     virtual void apply();
     virtual void dump();
diff --git a/Source/WebCore/platform/graphics/filters/FEColorMatrix.cpp b/Source/WebCore/platform/graphics/filters/FEColorMatrix.cpp
index 33c4467..f324830 100644
--- a/Source/WebCore/platform/graphics/filters/FEColorMatrix.cpp
+++ b/Source/WebCore/platform/graphics/filters/FEColorMatrix.cpp
@@ -52,9 +52,12 @@ ColorMatrixType FEColorMatrix::type() const
     return m_type;
 }
 
-void FEColorMatrix::setType(ColorMatrixType type)
+bool FEColorMatrix::setType(ColorMatrixType type)
 {
+    if (m_type == type)
+        return false;
     m_type = type;
+    return true;
 }
 
 const Vector<float>& FEColorMatrix::values() const
@@ -62,9 +65,12 @@ const Vector<float>& FEColorMatrix::values() const
     return m_values;
 }
 
-void FEColorMatrix::setValues(const Vector<float> &values)
+bool FEColorMatrix::setValues(const Vector<float> &values)
 {
+    if (m_values == values)
+        return false;
     m_values = values;
+    return true;
 }
 
 inline void matrix(double& red, double& green, double& blue, double& alpha, const Vector<float>& values)
diff --git a/Source/WebCore/platform/graphics/filters/FEColorMatrix.h b/Source/WebCore/platform/graphics/filters/FEColorMatrix.h
index a3ced7e..5bdfa74 100644
--- a/Source/WebCore/platform/graphics/filters/FEColorMatrix.h
+++ b/Source/WebCore/platform/graphics/filters/FEColorMatrix.h
@@ -43,10 +43,10 @@ public:
     static PassRefPtr<FEColorMatrix> create(Filter*, ColorMatrixType, const Vector<float>&);
 
     ColorMatrixType type() const;
-    void setType(ColorMatrixType);
+    bool setType(ColorMatrixType);
 
     const Vector<float>& values() const;
-    void setValues(const Vector<float>&);
+    bool setValues(const Vector<float>&);
 
     virtual void apply();
     virtual void dump();
diff --git a/Source/WebCore/platform/graphics/filters/FEComposite.cpp b/Source/WebCore/platform/graphics/filters/FEComposite.cpp
index bc7fa80..eead000 100644
--- a/Source/WebCore/platform/graphics/filters/FEComposite.cpp
+++ b/Source/WebCore/platform/graphics/filters/FEComposite.cpp
@@ -55,9 +55,12 @@ CompositeOperationType FEComposite::operation() const
     return m_type;
 }
 
-void FEComposite::setOperation(CompositeOperationType type)
+bool FEComposite::setOperation(CompositeOperationType type)
 {
+    if (m_type == type)
+        return false;
     m_type = type;
+    return true;
 }
 
 float FEComposite::k1() const
@@ -65,9 +68,12 @@ float FEComposite::k1() const
     return m_k1;
 }
 
-void FEComposite::setK1(float k1)
+bool FEComposite::setK1(float k1)
 {
+    if (m_k1 == k1)
+        return false;
     m_k1 = k1;
+    return true;
 }
 
 float FEComposite::k2() const
@@ -75,9 +81,12 @@ float FEComposite::k2() const
     return m_k2;
 }
 
-void FEComposite::setK2(float k2)
+bool FEComposite::setK2(float k2)
 {
+    if (m_k2 == k2)
+        return false;
     m_k2 = k2;
+    return true;
 }
 
 float FEComposite::k3() const
@@ -85,9 +94,12 @@ float FEComposite::k3() const
     return m_k3;
 }
 
-void FEComposite::setK3(float k3)
+bool FEComposite::setK3(float k3)
 {
+    if (m_k3 == k3)
+        return false;
     m_k3 = k3;
+    return true;
 }
 
 float FEComposite::k4() const
@@ -95,9 +107,12 @@ float FEComposite::k4() const
     return m_k4;
 }
 
-void FEComposite::setK4(float k4)
+bool FEComposite::setK4(float k4)
 {
+    if (m_k4 == k4)
+        return false;
     m_k4 = k4;
+    return true;
 }
 
 template <int b1, int b2, int b3, int b4>
diff --git a/Source/WebCore/platform/graphics/filters/FEComposite.h b/Source/WebCore/platform/graphics/filters/FEComposite.h
index b846902..481c6a7 100644
--- a/Source/WebCore/platform/graphics/filters/FEComposite.h
+++ b/Source/WebCore/platform/graphics/filters/FEComposite.h
@@ -45,19 +45,19 @@ public:
     static PassRefPtr<FEComposite> create(Filter*, const CompositeOperationType&, float, float, float, float);
 
     CompositeOperationType operation() const;
-    void setOperation(CompositeOperationType);
+    bool setOperation(CompositeOperationType);
 
     float k1() const;
-    void setK1(float);
+    bool setK1(float);
 
     float k2() const;
-    void setK2(float);
+    bool setK2(float);
 
     float k3() const;
-    void setK3(float);
+    bool setK3(float);
 
     float k4() const;
-    void setK4(float);
+    bool setK4(float);
 
     virtual void apply();
     virtual void dump();
diff --git a/Source/WebCore/platform/graphics/filters/FEConvolveMatrix.cpp b/Source/WebCore/platform/graphics/filters/FEConvolveMatrix.cpp
index 0483626..a1f8dfd 100644
--- a/Source/WebCore/platform/graphics/filters/FEConvolveMatrix.cpp
+++ b/Source/WebCore/platform/graphics/filters/FEConvolveMatrix.cpp
@@ -63,7 +63,7 @@ IntSize FEConvolveMatrix::kernelSize() const
     return m_kernelSize;
 }
 
-void FEConvolveMatrix::setKernelSize(IntSize kernelSize)
+void FEConvolveMatrix::setKernelSize(const IntSize& kernelSize)
 {
     m_kernelSize = kernelSize; 
 }
@@ -83,9 +83,12 @@ float FEConvolveMatrix::divisor() const
     return m_divisor; 
 }
 
-void FEConvolveMatrix::setDivisor(float divisor)
+bool FEConvolveMatrix::setDivisor(float divisor)
 {
-    m_divisor = divisor; 
+    if (m_divisor == divisor)
+        return false;
+    m_divisor = divisor;
+    return true;
 }
 
 float FEConvolveMatrix::bias() const
@@ -93,9 +96,12 @@ float FEConvolveMatrix::bias() const
     return m_bias; 
 }
 
-void FEConvolveMatrix::setBias(float bias)
+bool FEConvolveMatrix::setBias(float bias)
 {
-    m_bias = bias; 
+    if (m_bias == bias)
+        return false;
+    m_bias = bias;
+    return true;
 }
 
 IntPoint FEConvolveMatrix::targetOffset() const
@@ -103,19 +109,25 @@ IntPoint FEConvolveMatrix::targetOffset() const
     return m_targetOffset; 
 }
 
-void FEConvolveMatrix::setTargetOffset(IntPoint targetOffset)
+bool FEConvolveMatrix::setTargetOffset(const IntPoint& targetOffset)
 {
-    m_targetOffset = targetOffset; 
+    if (m_targetOffset == targetOffset)
+        return false;
+    m_targetOffset = targetOffset;
+    return true;
 }
 
 EdgeModeType FEConvolveMatrix::edgeMode() const
 {
-    return m_edgeMode; 
+    return m_edgeMode;
 }
 
-void FEConvolveMatrix::setEdgeMode(EdgeModeType edgeMode)
+bool FEConvolveMatrix::setEdgeMode(EdgeModeType edgeMode)
 {
-    m_edgeMode = edgeMode; 
+    if (m_edgeMode == edgeMode)
+        return false;
+    m_edgeMode = edgeMode;
+    return true;
 }
 
 FloatPoint FEConvolveMatrix::kernelUnitLength() const
@@ -123,9 +135,12 @@ FloatPoint FEConvolveMatrix::kernelUnitLength() const
     return m_kernelUnitLength; 
 }
 
-void FEConvolveMatrix::setKernelUnitLength(FloatPoint kernelUnitLength)
+bool FEConvolveMatrix::setKernelUnitLength(const FloatPoint& kernelUnitLength)
 {
-    m_kernelUnitLength = kernelUnitLength; 
+    if (m_kernelUnitLength == kernelUnitLength)
+        return false;
+    m_kernelUnitLength = kernelUnitLength;
+    return true;
 }
 
 bool FEConvolveMatrix::preserveAlpha() const
@@ -133,9 +148,12 @@ bool FEConvolveMatrix::preserveAlpha() const
     return m_preserveAlpha; 
 }
 
-void FEConvolveMatrix::setPreserveAlpha(bool preserveAlpha)
+bool FEConvolveMatrix::setPreserveAlpha(bool preserveAlpha)
 {
-    m_preserveAlpha = preserveAlpha; 
+    if (m_preserveAlpha == preserveAlpha)
+        return false;
+    m_preserveAlpha = preserveAlpha;
+    return true;
 }
 
 /*
diff --git a/Source/WebCore/platform/graphics/filters/FEConvolveMatrix.h b/Source/WebCore/platform/graphics/filters/FEConvolveMatrix.h
index 05d1199..5dc8873 100644
--- a/Source/WebCore/platform/graphics/filters/FEConvolveMatrix.h
+++ b/Source/WebCore/platform/graphics/filters/FEConvolveMatrix.h
@@ -49,28 +49,28 @@ public:
             bool, const Vector<float>&);
 
     IntSize kernelSize() const;
-    void setKernelSize(IntSize);
+    void setKernelSize(const IntSize&);
 
     const Vector<float>& kernel() const;
     void setKernel(const Vector<float>&);
 
     float divisor() const;
-    void setDivisor(float);
+    bool setDivisor(float);
 
     float bias() const;
-    void setBias(float);
+    bool setBias(float);
 
     IntPoint targetOffset() const;
-    void setTargetOffset(IntPoint);
+    bool setTargetOffset(const IntPoint&);
 
     EdgeModeType edgeMode() const;
-    void setEdgeMode(EdgeModeType);
+    bool setEdgeMode(EdgeModeType);
 
     FloatPoint kernelUnitLength() const;
-    void setKernelUnitLength(FloatPoint);
+    bool setKernelUnitLength(const FloatPoint&);
 
     bool preserveAlpha() const;
-    void setPreserveAlpha(bool);
+    bool setPreserveAlpha(bool);
 
     virtual void apply();
     virtual void dump();
diff --git a/Source/WebCore/platform/graphics/filters/FEDisplacementMap.cpp b/Source/WebCore/platform/graphics/filters/FEDisplacementMap.cpp
index 88c87b7..b632233 100644
--- a/Source/WebCore/platform/graphics/filters/FEDisplacementMap.cpp
+++ b/Source/WebCore/platform/graphics/filters/FEDisplacementMap.cpp
@@ -54,9 +54,12 @@ ChannelSelectorType FEDisplacementMap::xChannelSelector() const
     return m_xChannelSelector;
 }
 
-void FEDisplacementMap::setXChannelSelector(const ChannelSelectorType xChannelSelector)
+bool FEDisplacementMap::setXChannelSelector(const ChannelSelectorType xChannelSelector)
 {
+    if (m_xChannelSelector == xChannelSelector)
+        return false;
     m_xChannelSelector = xChannelSelector;
+    return true;
 }
 
 ChannelSelectorType FEDisplacementMap::yChannelSelector() const
@@ -64,9 +67,12 @@ ChannelSelectorType FEDisplacementMap::yChannelSelector() const
     return m_yChannelSelector;
 }
 
-void FEDisplacementMap::setYChannelSelector(const ChannelSelectorType yChannelSelector)
+bool FEDisplacementMap::setYChannelSelector(const ChannelSelectorType yChannelSelector)
 {
+    if (m_yChannelSelector == yChannelSelector)
+        return false;
     m_yChannelSelector = yChannelSelector;
+    return true;
 }
 
 float FEDisplacementMap::scale() const
@@ -74,9 +80,12 @@ float FEDisplacementMap::scale() const
     return m_scale;
 }
 
-void FEDisplacementMap::setScale(float scale)
+bool FEDisplacementMap::setScale(float scale)
 {
+    if (m_scale == scale)
+        return false;
     m_scale = scale;
+    return true;
 }
 
 void FEDisplacementMap::apply()
diff --git a/Source/WebCore/platform/graphics/filters/FEDisplacementMap.h b/Source/WebCore/platform/graphics/filters/FEDisplacementMap.h
index ffb8f0e..9b7dda8 100644
--- a/Source/WebCore/platform/graphics/filters/FEDisplacementMap.h
+++ b/Source/WebCore/platform/graphics/filters/FEDisplacementMap.h
@@ -42,13 +42,13 @@ public:
     static PassRefPtr<FEDisplacementMap> create(Filter*, ChannelSelectorType xChannelSelector, ChannelSelectorType yChannelSelector, float);
 
     ChannelSelectorType xChannelSelector() const;
-    void setXChannelSelector(const ChannelSelectorType);
+    bool setXChannelSelector(const ChannelSelectorType);
 
     ChannelSelectorType yChannelSelector() const;
-    void setYChannelSelector(const ChannelSelectorType);
+    bool setYChannelSelector(const ChannelSelectorType);
 
     float scale() const;
-    void setScale(float scale);
+    bool setScale(float);
 
     virtual void apply();
     virtual void dump();
diff --git a/Source/WebCore/platform/graphics/filters/FEFlood.cpp b/Source/WebCore/platform/graphics/filters/FEFlood.cpp
index 0e0e94c..3c48cf9 100644
--- a/Source/WebCore/platform/graphics/filters/FEFlood.cpp
+++ b/Source/WebCore/platform/graphics/filters/FEFlood.cpp
@@ -85,7 +85,7 @@ TextStream& FEFlood::externalRepresentation(TextStream& ts, int indent) const
     writeIndent(ts, indent);
     ts << "[feFlood";
     FilterEffect::externalRepresentation(ts);
-    ts << " flood-color=\"" << floodColor().name() << "\" "
+    ts << " flood-color=\"" << floodColor().nameForRenderTreeAsText() << "\" "
        << "flood-opacity=\"" << floodOpacity() << "\"]\n";
     return ts;
 }
diff --git a/Source/WebCore/platform/graphics/filters/FEMorphology.cpp b/Source/WebCore/platform/graphics/filters/FEMorphology.cpp
index 1eb554b..aa01570 100644
--- a/Source/WebCore/platform/graphics/filters/FEMorphology.cpp
+++ b/Source/WebCore/platform/graphics/filters/FEMorphology.cpp
@@ -56,9 +56,12 @@ MorphologyOperatorType FEMorphology::morphologyOperator() const
     return m_type;
 }
 
-void FEMorphology::setMorphologyOperator(MorphologyOperatorType type)
+bool FEMorphology::setMorphologyOperator(MorphologyOperatorType type)
 {
+    if (m_type == type)
+        return false;
     m_type = type;
+    return true;
 }
 
 float FEMorphology::radiusX() const
@@ -66,9 +69,12 @@ float FEMorphology::radiusX() const
     return m_radiusX;
 }
 
-void FEMorphology::setRadiusX(float radiusX)
+bool FEMorphology::setRadiusX(float radiusX)
 {
+    if (m_radiusX == radiusX)
+        return false;
     m_radiusX = radiusX;
+    return true;
 }
 
 float FEMorphology::radiusY() const
@@ -86,9 +92,12 @@ void FEMorphology::determineAbsolutePaintRect()
     setAbsolutePaintRect(enclosingIntRect(paintRect));
 }
 
-void FEMorphology::setRadiusY(float radiusY)
+bool FEMorphology::setRadiusY(float radiusY)
 {
+    if (m_radiusY == radiusY)
+        return false;
     m_radiusY = radiusY;
+    return true;
 }
 
 void FEMorphology::apply()
diff --git a/Source/WebCore/platform/graphics/filters/FEMorphology.h b/Source/WebCore/platform/graphics/filters/FEMorphology.h
index 683e7d0..74c3b5a 100644
--- a/Source/WebCore/platform/graphics/filters/FEMorphology.h
+++ b/Source/WebCore/platform/graphics/filters/FEMorphology.h
@@ -38,13 +38,13 @@ class FEMorphology : public FilterEffect {
 public:
     static PassRefPtr<FEMorphology> create(Filter*, MorphologyOperatorType, float radiusX, float radiusY);  
     MorphologyOperatorType morphologyOperator() const;
-    void setMorphologyOperator(MorphologyOperatorType);
+    bool setMorphologyOperator(MorphologyOperatorType);
 
     float radiusX() const;
-    void setRadiusX(float);
+    bool setRadiusX(float);
 
     float radiusY() const;
-    void setRadiusY(float);
+    bool setRadiusY(float);
 
     virtual void apply();
     virtual void dump();
diff --git a/Source/WebCore/platform/graphics/filters/FESpecularLighting.cpp b/Source/WebCore/platform/graphics/filters/FESpecularLighting.cpp
index 36a6b72..a20eb8c 100644
--- a/Source/WebCore/platform/graphics/filters/FESpecularLighting.cpp
+++ b/Source/WebCore/platform/graphics/filters/FESpecularLighting.cpp
@@ -64,9 +64,12 @@ float FESpecularLighting::surfaceScale() const
     return m_surfaceScale;
 }
 
-void FESpecularLighting::setSurfaceScale(float surfaceScale)
+bool FESpecularLighting::setSurfaceScale(float surfaceScale)
 {
+    if (m_surfaceScale == surfaceScale)
+        return false;
     m_surfaceScale = surfaceScale;
+    return true;
 }
 
 float FESpecularLighting::specularConstant() const
@@ -74,9 +77,12 @@ float FESpecularLighting::specularConstant() const
     return m_specularConstant;
 }
 
-void FESpecularLighting::setSpecularConstant(float specularConstant)
+bool FESpecularLighting::setSpecularConstant(float specularConstant)
 {
+    if (m_specularConstant == specularConstant)
+        return false;
     m_specularConstant = specularConstant;
+    return true;
 }
 
 float FESpecularLighting::specularExponent() const
@@ -84,9 +90,12 @@ float FESpecularLighting::specularExponent() const
     return m_specularExponent;
 }
 
-void FESpecularLighting::setSpecularExponent(float specularExponent)
+bool FESpecularLighting::setSpecularExponent(float specularExponent)
 {
+    if (m_specularExponent == specularExponent)
+        return false;
     m_specularExponent = specularExponent;
+    return true;
 }
 
 float FESpecularLighting::kernelUnitLengthX() const
@@ -94,9 +103,12 @@ float FESpecularLighting::kernelUnitLengthX() const
     return m_kernelUnitLengthX;
 }
 
-void FESpecularLighting::setKernelUnitLengthX(float kernelUnitLengthX)
+bool FESpecularLighting::setKernelUnitLengthX(float kernelUnitLengthX)
 {
+    if (m_kernelUnitLengthX == kernelUnitLengthX)
+        return false;
     m_kernelUnitLengthX = kernelUnitLengthX;
+    return true;
 }
 
 float FESpecularLighting::kernelUnitLengthY() const
@@ -104,9 +116,12 @@ float FESpecularLighting::kernelUnitLengthY() const
     return m_kernelUnitLengthY;
 }
 
-void FESpecularLighting::setKernelUnitLengthY(float kernelUnitLengthY)
+bool FESpecularLighting::setKernelUnitLengthY(float kernelUnitLengthY)
 {
+    if (m_kernelUnitLengthY == kernelUnitLengthY)
+        return false;
     m_kernelUnitLengthY = kernelUnitLengthY;
+    return true;
 }
 
 const LightSource* FESpecularLighting::lightSource() const
diff --git a/Source/WebCore/platform/graphics/filters/FESpecularLighting.h b/Source/WebCore/platform/graphics/filters/FESpecularLighting.h
index b3ccfbc..9d3ea2d 100644
--- a/Source/WebCore/platform/graphics/filters/FESpecularLighting.h
+++ b/Source/WebCore/platform/graphics/filters/FESpecularLighting.h
@@ -37,19 +37,19 @@ public:
     void setLightingColor(const Color&);
 
     float surfaceScale() const;
-    void setSurfaceScale(float);
+    bool setSurfaceScale(float);
 
     float specularConstant() const;
-    void setSpecularConstant(float);
+    bool setSpecularConstant(float);
 
     float specularExponent() const;
-    void setSpecularExponent(float);
+    bool setSpecularExponent(float);
 
     float kernelUnitLengthX() const;
-    void setKernelUnitLengthX(float);
+    bool setKernelUnitLengthX(float);
 
     float kernelUnitLengthY() const;
-    void setKernelUnitLengthY(float);
+    bool setKernelUnitLengthY(float);
 
     const LightSource* lightSource() const;
     void setLightSource(PassRefPtr<LightSource>);
diff --git a/Source/WebCore/platform/graphics/filters/FETurbulence.cpp b/Source/WebCore/platform/graphics/filters/FETurbulence.cpp
index 068acee..63060e1 100644
--- a/Source/WebCore/platform/graphics/filters/FETurbulence.cpp
+++ b/Source/WebCore/platform/graphics/filters/FETurbulence.cpp
@@ -49,7 +49,7 @@ static const int s_randAmplitude = 16807; // 7**5; primitive root of m
 static const int s_randQ = 127773; // m / a
 static const int s_randR = 2836; // m % a
 
-FETurbulence::FETurbulence(Filter* filter, TurbulanceType type, float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed, bool stitchTiles)
+FETurbulence::FETurbulence(Filter* filter, TurbulenceType type, float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed, bool stitchTiles)
     : FilterEffect(filter)
     , m_type(type)
     , m_baseFrequencyX(baseFrequencyX)
@@ -60,19 +60,22 @@ FETurbulence::FETurbulence(Filter* filter, TurbulanceType type, float baseFreque
 {
 }
 
-PassRefPtr<FETurbulence> FETurbulence::create(Filter* filter, TurbulanceType type, float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed, bool stitchTiles)
+PassRefPtr<FETurbulence> FETurbulence::create(Filter* filter, TurbulenceType type, float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed, bool stitchTiles)
 {
     return adoptRef(new FETurbulence(filter, type, baseFrequencyX, baseFrequencyY, numOctaves, seed, stitchTiles));
 }
 
-TurbulanceType FETurbulence::type() const
+TurbulenceType FETurbulence::type() const
 {
     return m_type;
 }
 
-void FETurbulence::setType(TurbulanceType type)
+bool FETurbulence::setType(TurbulenceType type)
 {
+    if (m_type == type)
+        return false;
     m_type = type;
+    return true;
 }
 
 float FETurbulence::baseFrequencyY() const
@@ -80,9 +83,12 @@ float FETurbulence::baseFrequencyY() const
     return m_baseFrequencyY;
 }
 
-void FETurbulence::setBaseFrequencyY(float baseFrequencyY)
+bool FETurbulence::setBaseFrequencyY(float baseFrequencyY)
 {
+    if (m_baseFrequencyY == baseFrequencyY)
+        return false;
     m_baseFrequencyY = baseFrequencyY;
+    return true;
 }
 
 float FETurbulence::baseFrequencyX() const
@@ -90,9 +96,12 @@ float FETurbulence::baseFrequencyX() const
     return m_baseFrequencyX;
 }
 
-void FETurbulence::setBaseFrequencyX(float baseFrequencyX)
+bool FETurbulence::setBaseFrequencyX(float baseFrequencyX)
 {
-       m_baseFrequencyX = baseFrequencyX;
+    if (m_baseFrequencyX == baseFrequencyX)
+        return false;
+    m_baseFrequencyX = baseFrequencyX;
+    return true;
 }
 
 float FETurbulence::seed() const
@@ -100,9 +109,12 @@ float FETurbulence::seed() const
     return m_seed; 
 }
 
-void FETurbulence::setSeed(float seed)
+bool FETurbulence::setSeed(float seed)
 {
+    if (m_seed == seed)
+        return false;
     m_seed = seed;
+    return true;
 }
 
 int FETurbulence::numOctaves() const
@@ -110,9 +122,12 @@ int FETurbulence::numOctaves() const
     return m_numOctaves;
 }
 
-void FETurbulence::setNumOctaves(bool numOctaves)
+bool FETurbulence::setNumOctaves(int numOctaves)
 {
+    if (m_numOctaves == numOctaves)
+        return false;
     m_numOctaves = numOctaves;
+    return true;
 }
 
 bool FETurbulence::stitchTiles() const
@@ -120,9 +135,12 @@ bool FETurbulence::stitchTiles() const
     return m_stitchTiles;
 }
 
-void FETurbulence::setStitchTiles(bool stitch)
+bool FETurbulence::setStitchTiles(bool stitch)
 {
+    if (m_stitchTiles == stitch)
+        return false;
     m_stitchTiles = stitch;
+    return true;
 }
 
 // The turbulence calculation code is an adapted version of what appears in the SVG 1.1 specification:
@@ -353,7 +371,7 @@ void FETurbulence::dump()
 {
 }
 
-static TextStream& operator<<(TextStream& ts, const TurbulanceType& type)
+static TextStream& operator<<(TextStream& ts, const TurbulenceType& type)
 {
     switch (type) {
     case FETURBULENCE_TYPE_UNKNOWN:
diff --git a/Source/WebCore/platform/graphics/filters/FETurbulence.h b/Source/WebCore/platform/graphics/filters/FETurbulence.h
index 1bad123..dfeb220 100644
--- a/Source/WebCore/platform/graphics/filters/FETurbulence.h
+++ b/Source/WebCore/platform/graphics/filters/FETurbulence.h
@@ -30,7 +30,7 @@
 
 namespace WebCore {
 
-enum TurbulanceType {
+enum TurbulenceType {
     FETURBULENCE_TYPE_UNKNOWN = 0,
     FETURBULENCE_TYPE_FRACTALNOISE = 1,
     FETURBULENCE_TYPE_TURBULENCE = 2
@@ -38,25 +38,25 @@ enum TurbulanceType {
 
 class FETurbulence : public FilterEffect {
 public:
-    static PassRefPtr<FETurbulence> create(Filter*, TurbulanceType, float, float, int, float, bool);
+    static PassRefPtr<FETurbulence> create(Filter*, TurbulenceType, float, float, int, float, bool);
 
-    TurbulanceType type() const;
-    void setType(TurbulanceType);
+    TurbulenceType type() const;
+    bool setType(TurbulenceType);
 
     float baseFrequencyY() const;
-    void setBaseFrequencyY(float);
+    bool setBaseFrequencyY(float);
 
     float baseFrequencyX() const;
-    void setBaseFrequencyX(float);
+    bool setBaseFrequencyX(float);
 
     float seed() const;
-    void setSeed(float);
+    bool setSeed(float);
 
     int numOctaves() const;
-    void setNumOctaves(bool);
+    bool setNumOctaves(int);
 
     bool stitchTiles() const;
-    void setStitchTiles(bool);
+    bool setStitchTiles(bool);
 
     virtual void apply();
     virtual void dump();
@@ -84,13 +84,13 @@ private:
         inline long random();
     };
 
-    FETurbulence(Filter*, TurbulanceType, float, float, int, float, bool);
+    FETurbulence(Filter*, TurbulenceType, float, float, int, float, bool);
 
     inline void initPaint(PaintingData&);
     float noise2D(PaintingData&, const FloatPoint&);
     unsigned char calculateTurbulenceValueForPoint(PaintingData&, const FloatPoint&);
 
-    TurbulanceType m_type;
+    TurbulenceType m_type;
     float m_baseFrequencyX;
     float m_baseFrequencyY;
     int m_numOctaves;