Fixing some warnings on Linux

src/animator/SkDrawExtraPathEffect.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkDrawExtraPathEffect.h"
@@ skipping 100 matching lines @@
         } else {
             SkApply* apply = (SkApply*) fDraw->addPath;
             apply->refresh(*fMaker);
             apply->activate(*fMaker);
             apply->interpolate(*fMaker, SkScalarMulRound(distance, 1000));
             drawPath = (SkDrawPath*) apply->getScope();
         }
         SkMatrix m;
         m.reset();
         if (fDraw->addMatrix) {
-            SkDrawMatrix* matrix;

[sugoi, 2013/03/06 16:14:59]

matrix is assigned, but unused, so it was deleted

-            if (fDraw->addMatrix->getType() == SkType_Matrix)
-                matrix = (SkDrawMatrix*) fDraw->addMatrix;
-            else {
+            if (fDraw->addMatrix->getType() != SkType_Matrix) {
                 SkApply* apply = (SkApply*) fDraw->addMatrix;
                 apply->refresh(*fMaker);
                 apply->activate(*fMaker);
                 apply->interpolate(*fMaker, SkScalarMulRound(distance, 1000));
-                matrix = (SkDrawMatrix*) apply->getScope();
             }
         }
         SkScalar result = 0;
         SkAnimatorScript::EvaluateFloat(*fMaker, NULL, fDraw->spacing.c_str(), &result);
         if (drawPath)
             dst->addPath(drawPath->getPath(), m);
         fMaker->clearExtraPropertyCallBack(fDraw->fType);
         return result;
     }
 
@@ skipping 77 matching lines @@
         maker.setErrorCode(SkDisplayXMLParserError::kUnknownError); // !!! add error
     else
         fPathEffect = new SkShape1DPathEffect(this, &maker);
 }
 
 ////////// SkShape2DPathEffect
 
 class SkShape2DPathEffect : public Sk2DPathEffect {
 public:
     SkShape2DPathEffect(SkDrawShape2DPathEffect* draw, SkAnimateMaker* maker,
-        const SkMatrix& matrix) : Sk2DPathEffect(matrix), fDraw(draw), fMaker(maker) {
+        const SkMatrix& matrix) : Sk2DPathEffect(matrix) {
+        fData = new SkShape2DPathEffectData(draw, maker);
+    }
+    ~SkShape2DPathEffect() {
+        delete fData;
     }
 
 protected:
-    virtual void begin(const SkIRect& uvBounds, SkPath* )
-    {
-        fUVBounds.set(SkIntToScalar(uvBounds.fLeft), SkIntToScalar(uvBounds.fTop),
-            SkIntToScalar(uvBounds.fRight), SkIntToScalar(uvBounds.fBottom));
+    virtual void begin(const SkIRect& uvBounds, SkPath*) const {

[sugoi, 2013/03/06 16:14:59]

These virtual functions are const in the base class, so I made them const here
too. In order to keep the original logic without doing anything illegal, I put
the data into a data struct so that the data may be modified while keeping these
functions const.

+        fData->begin(uvBounds);
     }
 
-    virtual void next(const SkPoint& loc, int u, int v, SkPath* dst)
-    {
-        fLoc = loc;
-        fU = u;
-        fV = v;
-        SkDrawPath* drawPath;
-        fMaker->setExtraPropertyCallBack(fDraw->fType, Get2D, this);
-        if (fDraw->addPath->isPath()) {
-            drawPath = (SkDrawPath*) fDraw->addPath;
-        } else {
-            SkApply* apply = (SkApply*) fDraw->addPath;
-            apply->refresh(*fMaker);
-            apply->activate(*fMaker);
-            apply->interpolate(*fMaker, v);
-            drawPath = (SkDrawPath*) apply->getScope();
-        }
-        if (drawPath == NULL)
-            goto clearCallBack;
-        if (fDraw->matrix) {
-            SkDrawMatrix* matrix;
-            if (fDraw->matrix->getType() == SkType_Matrix)
-                matrix = (SkDrawMatrix*) fDraw->matrix;
-            else {
-                SkApply* apply = (SkApply*) fDraw->matrix;
-                apply->activate(*fMaker);
-                apply->interpolate(*fMaker, v);
-                matrix = (SkDrawMatrix*) apply->getScope();
-            }
-            if (matrix) {
-                dst->addPath(drawPath->getPath(), matrix->getMatrix());
-                goto clearCallBack;
-            }
-        }
-        dst->addPath(drawPath->getPath());
-clearCallBack:
-        fMaker->clearExtraPropertyCallBack(fDraw->fType);
+    virtual void next(const SkPoint& loc, int u, int v, SkPath* dst) const {
+        fData->next(loc, u, v, dst);
     }
 
 private:
+    struct SkShape2DPathEffectData {
+        SkShape2DPathEffectData(SkDrawShape2DPathEffect* draw, SkAnimateMaker* maker) :
+            fDraw(draw), fMaker(maker) {}
+
+        void begin(const SkIRect& uvBounds) {
+            fUVBounds.set(SkIntToScalar(uvBounds.fLeft), SkIntToScalar(uvBounds.fTop),
+                SkIntToScalar(uvBounds.fRight), SkIntToScalar(uvBounds.fBottom));
+        }
+
+        void next(const SkPoint& loc, int u, int v, SkPath* dst) {
+            fLoc = loc;
+            fU = u;
+            fV = v;
+            SkDrawPath* drawPath;
+            fMaker->setExtraPropertyCallBack(fDraw->fType, Get2D, this);
+            if (fDraw->addPath->isPath()) {
+                drawPath = (SkDrawPath*) fDraw->addPath;
+            } else {
+                SkApply* apply = (SkApply*) fDraw->addPath;
+                apply->refresh(*fMaker);
+                apply->activate(*fMaker);
+                apply->interpolate(*fMaker, v);
+                drawPath = (SkDrawPath*) apply->getScope();
+            }
+            if (drawPath == NULL)
+                goto clearCallBack;
+            if (fDraw->matrix) {
+                SkDrawMatrix* matrix;
+                if (fDraw->matrix->getType() == SkType_Matrix)
+                    matrix = (SkDrawMatrix*) fDraw->matrix;
+                else {
+                    SkApply* apply = (SkApply*) fDraw->matrix;
+                    apply->activate(*fMaker);
+                    apply->interpolate(*fMaker, v);
+                    matrix = (SkDrawMatrix*) apply->getScope();
+                }
+                if (matrix) {
+                    dst->addPath(drawPath->getPath(), matrix->getMatrix());
+                    goto clearCallBack;
+                }
+            }
+            dst->addPath(drawPath->getPath());
+clearCallBack:
+            fMaker->clearExtraPropertyCallBack(fDraw->fType);
+        }
+
+        SkPoint fLoc;
+        SkRect fUVBounds;
+        int32_t fU;
+        int32_t fV;
+        SkDrawShape2DPathEffect* fDraw;
+        SkAnimateMaker* fMaker;
+    };
 
     static bool Get2D(const char* token, size_t len, void* s2D, SkScriptValue* value) {
         static const char match[] = "locX|locY|left|top|right|bottom|u|v" ;
         SkShape2DPathEffect* shape2D = (SkShape2DPathEffect*) s2D;
         int index;
         if (SkAnimatorScript::MapEnums(match, token, len, &index) == false)
             return false;
         SkASSERT((sizeof(SkPoint) +     sizeof(SkRect)) / sizeof(SkScalar) == 6);
         if (index < 6) {
             value->fType = SkType_Float;
-            value->fOperand.fScalar = (&shape2D->fLoc.fX)[index];
+            value->fOperand.fScalar = (&shape2D->fData->fLoc.fX)[index];
         } else {
             value->fType = SkType_Int;
-            value->fOperand.fS32 = (&shape2D->fU)[index - 6];
+            value->fOperand.fS32 = (&shape2D->fData->fU)[index - 6];
         }
         return true;
     }
 
-    SkPoint fLoc;
-    SkRect fUVBounds;
-    int32_t fU;
-    int32_t fV;
-    SkDrawShape2DPathEffect* fDraw;
-    SkAnimateMaker* fMaker;
+    SkShape2DPathEffectData* fData;
 
     // illegal
     SkShape2DPathEffect(const SkShape2DPathEffect&);
     SkShape2DPathEffect& operator=(const SkShape2DPathEffect&);
 };
 
 ////////// SkDrawShape2DPathEffect
 
 #if SK_USE_CONDENSED_INFO == 0
 
@@ skipping 189 matching lines @@
 
 void InitializeSkExtraPathEffects(SkAnimator* animator) {
     animator->addExtras(new SkExtraPathEffects(animator));
 }
 
 ////////////////
 
 
 SkExtras::SkExtras() : fExtraCallBack(NULL), fExtraStorage(NULL) {
 }