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

src/core/SkBlitter.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 "SkBlitter.h"
@@ skipping 573 matching lines @@
     }
 
     virtual size_t contextSize() const SK_OVERRIDE {
         size_t size = sizeof(Sk3DShaderContext);
         if (fProxy) {
             size += fProxy->contextSize();
         }
         return size;
     }
 
-    virtual bool validContext(const SkBitmap& device, const SkPaint& paint,
-                              const SkMatrix& matrix, SkMatrix* totalInverse = NULL) const
-            SK_OVERRIDE
-    {
-        if (!this->INHERITED::validContext(device, paint, matrix, totalInverse)) {
+    virtual bool validContext(const ContextRec& rec, SkMatrix* totalInverse) const SK_OVERRIDE {
+        if (!this->INHERITED::validContext(rec, totalInverse)) {
             return false;
         }
         if (fProxy) {
-            return fProxy->validContext(device, paint, matrix);
+            return fProxy->validContext(rec);
         }
         return true;
     }
 
-    virtual SkShader::Context* createContext(const SkBitmap& device,
-                                             const SkPaint& paint,
-                                             const SkMatrix& matrix,
-                                             void* storage) const SK_OVERRIDE
+    virtual SkShader::Context* createContext(const ContextRec& rec, void* storage) const SK_OVERRIDE
     {
-        if (!this->validContext(device, paint, matrix)) {
+        if (!this->validContext(rec, NULL)) {
             return NULL;
         }
 
         SkShader::Context* proxyContext;
         if (fProxy) {
             char* proxyContextStorage = (char*) storage + sizeof(Sk3DShaderContext);
-            proxyContext = fProxy->createContext(device, paint, matrix, proxyContextStorage);
+            proxyContext = fProxy->createContext(rec, proxyContextStorage);
             SkASSERT(proxyContext);
         } else {
             proxyContext = NULL;
         }
-        return SkNEW_PLACEMENT_ARGS(storage, Sk3DShaderContext, (*this, device, paint, matrix,
-                                                                 proxyContext));
+        return SkNEW_PLACEMENT_ARGS(storage, Sk3DShaderContext, (*this, rec, proxyContext));
     }
 
     class Sk3DShaderContext : public SkShader::Context {
     public:
         // Calls proxyContext's destructor but will NOT free its memory.
-        Sk3DShaderContext(const Sk3DShader& shader, const SkBitmap& device, const SkPaint& paint,
-                          const SkMatrix& matrix, SkShader::Context* proxyContext)
-            : INHERITED(shader, device, paint, matrix)
+        Sk3DShaderContext(const Sk3DShader& shader, const ContextRec& rec,
+                          SkShader::Context* proxyContext)
+            : INHERITED(shader, rec)
             , fMask(NULL)
             , fProxyContext(proxyContext)
         {
             if (!fProxyContext) {
-                fPMColor = SkPreMultiplyColor(paint.getColor());
+                fPMColor = SkPreMultiplyColor(rec.fPaint->getColor());
             }
         }
 
         virtual ~Sk3DShaderContext() {
             if (fProxyContext) {
                 fProxyContext->~Context();
             }
         }
 
         void setMask(const SkMask* mask) { fMask = mask; }
@@ skipping 298 matching lines @@
         paint.writable()->setShader(shader)->unref();
         // blitters should ignore the presence/absence of a filter, since
         // if there is one, the shader will take care of it.
     }
 
     /*
      *  We create a SkShader::Context object, and store it on the blitter.
      */
     SkShader::Context* shaderContext;
     if (shader) {
+        SkShader::ContextRec rec(device, *paint, matrix);
         // Try to create the ShaderContext
         void* storage = allocator->reserveT<SkShader::Context>(shader->contextSize());
-        shaderContext = shader->createContext(device, *paint, matrix, storage);
+        shaderContext = shader->createContext(rec, storage);
         if (!shaderContext) {
             allocator->freeLast();
             blitter = allocator->createT<SkNullBlitter>();
             return blitter;
         }
         SkASSERT(shaderContext);
         SkASSERT((void*) shaderContext == storage);
     } else {
         shaderContext = NULL;
     }
@@ skipping 63 matching lines @@
     fShader->ref();
     fShaderFlags = fShaderContext->getFlags();
 }
 
 SkShaderBlitter::~SkShaderBlitter() {
     fShader->unref();
 }
 
 bool SkShaderBlitter::resetShaderContext(const SkBitmap& device, const SkPaint& paint,
                                          const SkMatrix& matrix) {
-    if (!fShader->validContext(device, paint, matrix)) {
+    SkShader::ContextRec rec(device, paint, matrix);
+    if (!fShader->validContext(rec)) {
         return false;
     }
 
     // Only destroy the old context if we have a new one. We need to ensure to have a
     // live context in fShaderContext because the storage is owned by an SkSmallAllocator
     // outside of this class.
     // The new context will be of the same size as the old one because we use the same
     // shader to create it. It is therefore safe to re-use the storage.
     fShaderContext->~Context();
-    fShaderContext = fShader->createContext(device, paint, matrix, (void*)fShaderContext);
+    fShaderContext = fShader->createContext(rec, (void*)fShaderContext);
     SkASSERT(fShaderContext);
 
     return true;
 }