Bundle SkShader::asFragmentProcessor arguments in a struct

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 293 matching lines @@
 
     struct ComposeRec {
         const SkShader*     fShaderA;
         const SkShader*     fShaderB;
         const SkXfermode*   fMode;
     };
 
     virtual bool asACompose(ComposeRec*) const { return false; }
 
 #if SK_SUPPORT_GPU
+    struct AsFPArgs {
+        AsFPArgs(GrContext* context,
+                 const SkMatrix* viewMatrix,
+                 const SkMatrix* localMatrix,
+                 SkFilterQuality filterQuality,
+                 SkSourceGammaTreatment gammaTreatment)
+            : fContext(context)
+            , fViewMatrix(viewMatrix)
+            , fLocalMatrix(localMatrix)
+            , fFilterQuality(filterQuality)
+            , fGammaTreatment(gammaTreatment) {}
+
+        GrContext*             fContext;
+        const SkMatrix*        fViewMatrix;

[Brian Osman, 2016/07/22 17:19:26]

This is the only (slightly) interesting change - we used to take viewmatrix by
const&, and localmatrix by pointer (due to required/optional). But it seems like
we really shy away from storing refs inside structs/classes, and I didn't want
to be copying the view matrix by value, so I converted them both to pointers.
That leads to some de-referencing in the implementation of asFP...

[egdaniel, 2016/07/22 17:27:59]

personally I think the use of a ref in this use case is fine, but either is fine
with me. I'll let someone who cares more make the decision.

[bsalomon, 2016/07/22 17:38:11]

I'm not opposed to ref but I think ptr is more consistent with how other similar
args struct work (e.g. path renderers).

+        const SkMatrix*        fLocalMatrix;
+        SkFilterQuality        fFilterQuality;
+        SkSourceGammaTreatment fGammaTreatment;
+    };
+
     /**
      *  Returns a GrFragmentProcessor that implements the shader for the GPU backend. NULL is
      *  returned if there is no GPU implementation.
      *
      *  The GPU device does not call SkShader::createContext(), instead we pass the view matrix,
      *  local matrix, and filter quality directly.
      *
      *  The GrContext may be used by the to create textures that are required by the returned
      *  processor.
      *
      *  The returned GrFragmentProcessor should expect an unpremultiplied input color and
      *  produce a premultiplied output.
      */
-    virtual sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext*,
-                                                           const SkMatrix& viewMatrix,
-                                                           const SkMatrix* localMatrix,
-                                                           SkFilterQuality,
-                                                           SkSourceGammaTreatment) const;
+    virtual sk_sp<GrFragmentProcessor> asFragmentProcessor(const AsFPArgs&) const;
 #endif
 
     /**
      *  If the shader can represent its "average" luminance in a single color, return true and
      *  if color is not NULL, return that color. If it cannot, return false and ignore the color
      *  parameter.
      *
      *  Note: if this returns true, the returned color will always be opaque, as only the RGB
      *  components are used to compute luminance.
      */
@@ skipping 158 matching lines @@
     SkMatrix fLocalMatrix;
 
     // So the SkLocalMatrixShader can whack fLocalMatrix in its SkReadBuffer constructor.
     friend class SkLocalMatrixShader;
     friend class SkBitmapProcShader;    // for computeTotalInverse()
 
     typedef SkFlattenable INHERITED;
 };
 
 #endif