removing GrDrawEffect

include/gpu/GrEffect.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrEffect_DEFINED
 #define GrEffect_DEFINED
 
@@ skipping 112 matching lines @@
     void* operator new(size_t size);
     void operator delete(void* target);
 
     void* operator new(size_t size, void* placement) {
         return ::operator new(size, placement);
     }
     void operator delete(void* target, void* placement) {
         ::operator delete(target, placement);
     }
 
+    /**
+      * Helper for down-casting to a GrEffect subclass
+      */
+    template <typename T> static const T& CastEffect(const GrEffect& effect) {

[bsalomon, 2014/09/15 19:54:25]

How about

template <typename T> const T& cast() const { return static_cast<T>(*this); }

and then do

const MyEffect& me = effect.cast<MyEffect>();

in setData() and other spots?

I find the repeated GrEffect::CastEffect to be verbose.

+        return *static_cast<const T*>(&effect);
+    }
+
 protected:
     /**
      * Subclasses call this from their constructor to register coordinate transformations. The
      * effect subclass manages the lifetime of the transformations (this function only stores a
      * pointer). The GrCoordTransform is typically a member field of the GrEffect subclass. When the
      * matrix has perspective, the transformed coordinates will have 3 components. Otherwise they'll
      * have 2. This must only be called from the constructor because GrEffects are immutable.
      */
     void addCoordTransform(const GrCoordTransform* coordTransform);
 
     /**
      * Subclasses call this from their constructor to register GrTextureAccesses. The effect
      * subclass manages the lifetime of the accesses (this function only stores a pointer). The
      * GrTextureAccess is typically a member field of the GrEffect subclass. This must only be
      * called from the constructor because GrEffects are immutable.
      */
     void addTextureAccess(const GrTextureAccess* textureAccess);
 
     GrEffect()
         : fWillReadDstColor(false)
         , fWillReadFragmentPosition(false)
         , fWillUseInputColor(true)
         , fRequiresVertexShader(false) {}
 
     /**
-      * Helper for down-casting to a GrEffect subclass
-      */
-    template <typename T> static const T& CastEffect(const GrEffect& effect) {
-        return *static_cast<const T*>(&effect);
-    }
-
-    /**
      * If the effect subclass will read the destination pixel value then it must call this function
      * from its constructor. Otherwise, when its generated backend-specific effect class attempts
      * to generate code that reads the destination pixel it will fail.
      */
     void setWillReadDstColor() { fWillReadDstColor = true; }
 
     /**
      * If the effect will generate a backend-specific effect that will read the fragment position
      * in the FS then it must call this method from its constructor. Otherwise, the request to
      * access the fragment position will be denied.
@@ skipping 31 matching lines @@
 /**
  * This creates an effect outside of the effect memory pool. The effect's destructor will be called
  * at global destruction time. NAME will be the name of the created GrEffect.
  */
 #define GR_CREATE_STATIC_EFFECT(NAME, EFFECT_CLASS, ARGS)                                         \
 static SkAlignedSStorage<sizeof(EFFECT_CLASS)> g_##NAME##_Storage;                                \
 static GrEffect* NAME SkNEW_PLACEMENT_ARGS(g_##NAME##_Storage.get(), EFFECT_CLASS, ARGS);         \
 static SkAutoTDestroy<GrEffect> NAME##_ad(NAME);
 
 #endif