create struct to hold all the params passed around for shader::context

include/core/SkShader.h

 /*
  * 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.
  */
 
 
 #ifndef SkShader_DEFINED
 #define SkShader_DEFINED
@@ skipping 101 matching lines @@
     };
 
     /**
      *  Returns true if the shader is guaranteed to produce only opaque
      *  colors, subject to the SkPaint using the shader to apply an opaque
      *  alpha value. Subclasses should override this to allow some
      *  optimizations.
      */
     virtual bool isOpaque() const { return false; }
 
+    struct ContextRec {

[scroggo, 2014/05/01 18:49:38]

Could you add some comments?

[reed1, 2014/05/01 18:57:41]

Done.

+        ContextRec() : fDevice(NULL), fPaint(NULL), fMatrix(NULL) {}
+        ContextRec(const ContextRec& other)
+            : fDevice(other.fDevice), fPaint(other.fPaint), fMatrix(other.fMatrix) {}
+        ContextRec(const SkBitmap& device, const SkPaint& paint, const SkMatrix& matrix)
+            : fDevice(&device)
+            , fPaint(&paint)
+            , fMatrix(&matrix) {}
+
+        const SkBitmap* fDevice;
+        const SkPaint*  fPaint;
+        const SkMatrix* fMatrix;
+    };
+
     class Context : public ::SkNoncopyable {
     public:
-        Context(const SkShader& shader, const SkBitmap& device,
-                const SkPaint& paint, const SkMatrix& matrix);
+        Context(const SkShader& shader, const ContextRec&);
 
         virtual ~Context();
 
         /**
          *  Called sometimes before drawing with this shader. Return the type of
          *  alpha your shader will return. The default implementation returns 0.
          *  Your subclass should override if it can (even sometimes) report a
          *  non-zero value, since that will enable various blitters to perform
          *  faster.
          */
@@ skipping 57 matching lines @@
         uint8_t             fPaintAlpha;
         uint8_t             fTotalInverseClass;
 
         typedef SkNoncopyable INHERITED;
     };
 
     /**
      *  Subclasses should be sure to call their INHERITED::validContext() if
      *  they override this method.
      */
-    virtual bool validContext(const SkBitmap& device, const SkPaint& paint,
-                              const SkMatrix& matrix, SkMatrix* totalInverse = NULL) const;
+    virtual bool validContext(const ContextRec&, SkMatrix* totalInverse = NULL) const;
 
     /**
      *  Create the actual object that does the shading.
      *  Returns NULL if validContext() returns false.
      *  Size of storage must be >= contextSize.
      *  Your subclass must also override contextSize() if it overrides createContext().
      *
      *  Base class implementation returns NULL.
      */
-    virtual Context* createContext(const SkBitmap& device,
-                                   const SkPaint& paint,
-                                   const SkMatrix& matrix,
-                                   void* storage) const;
+    virtual Context* createContext(const ContextRec&, void* storage) const;
 
     /**
      *  Return the size of a Context returned by createContext.
      *
      *  Override this if your subclass overrides createContext, to return the correct size of
      *  your subclass' context.
      */
     virtual size_t contextSize() const;
 
     /**
@@ skipping 174 matching lines @@
 
 private:
     SkMatrix            fLocalMatrix;
 
     bool computeTotalInverse(const SkMatrix& matrix, SkMatrix* totalInverse) const;
 
     typedef SkFlattenable INHERITED;
 };
 
 #endif