Make swizzling in read/write pixel copy code more generic

src/gpu/GrGpu.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGpu_DEFINED
 #define GrGpu_DEFINED
 
 #include "GrPipelineBuilder.h"
 #include "GrProgramDesc.h"
 #include "GrStencil.h"
+#include "GrSwizzle.h"
 #include "GrTextureParamsAdjuster.h"
 #include "GrXferProcessor.h"
 #include "SkPath.h"
 
 class GrBatchTracker;
 class GrContext;
 class GrGLContext;
 class GrIndexBuffer;
 class GrNonInstancedVertices;
 class GrPath;
@@ skipping 124 matching lines @@
     /** Info struct returned by getReadPixelsInfo about performing intermediate draws before
         reading pixels for performance or correctness. */
     struct ReadPixelTempDrawInfo {
         /** If the GrGpu is requesting that the caller do a draw to an intermediate surface then
             this is descriptor for the temp surface. The draw should always be a rect with
             dst 0,0,w,h. */
         GrSurfaceDesc   fTempSurfaceDesc;
         /** Indicates whether there is a performance advantage to using an exact match texture
             (in terms of width and height) for the intermediate texture instead of approximate. */
         bool            fUseExactScratch;
-        /** The caller should swap the R and B channel in the temp draw and then instead of reading
-            the desired config back it should read GrPixelConfigSwapRAndB(readConfig). The swap
-            during the draw and the swap at readback time cancel and the client gets the correct
-            data. The swapped read back is either faster for or required by the underlying backend
-            3D API. */
-        bool            fSwapRAndB;
+        /** Swizzle to apply during the draw. This is used to compensate for either feature or
+            performance limitations in the underlying 3D API. */
+        GrSwizzle       fSwizzle;
+        /** The config that should be used to read from the temp surface after the draw. This may be
+            different than the original read config in order to compensate for swizzling. The
+            read data will effectively be in the original read config. */
+        GrPixelConfig   fReadConfig;
     };
+
     /** Describes why an intermediate draw must/should be performed before readPixels. */
     enum DrawPreference {
         /** On input means that the caller would proceed without draw if the GrGpu doesn't request
             one.
             On output means that the GrGpu is not requesting a draw. */
         kNoDraw_DrawPreference,
         /** Means that the client would prefer a draw for performance of the readback but
             can satisfy a straight readPixels call on the inputs without an intermediate draw.
             getReadPixelsInfo will never set the draw preference to this value but may leave
             it set. */
@@ skipping 20 matching lines @@
                            GrPixelConfig readConfig, DrawPreference*, ReadPixelTempDrawInfo*);
 
     /** Info struct returned by getWritePixelsInfo about performing an intermediate draw in order 
         to write pixels to a GrSurface for either performance or correctness reasons. */
     struct WritePixelTempDrawInfo {
         /** If the GrGpu is requesting that the caller upload to an intermediate surface and draw
             that to the dst then this is the descriptor for the intermediate surface. The caller
             should upload the pixels such that the upper left pixel of the upload rect is at 0,0 in
             the intermediate surface.*/
         GrSurfaceDesc   fTempSurfaceDesc;
-        /** If set, fTempSurfaceDesc's config will be a R/B swap of the src pixel config. The caller
-            should upload the pixels as is such that R and B will be swapped in the intermediate
-            surface. When the intermediate is drawn to the dst the shader should swap R/B again
-            such that the correct swizzle results in the dst. This is done to work around either
-            performance or API restrictions in the backend 3D API implementation. */
-        bool            fSwapRAndB;
+        /** Swizzle to apply during the draw. This is used to compensate for either feature or
+            performance limitations in the underlying 3D API. */
+        GrSwizzle       fSwizzle;
+        /** The config that should be specified when uploading the *original* data to the temp
+            surface before the draw. This may be different than the original src data config in
+            order to compensate for swizzling that will occur when drawing. */
+        GrPixelConfig   fWriteConfig;
     };
 
     /**
      * Used to negotiate whether and how an intermediate surface should be used to write pixels to
      * a GrSurface. If this returns false then GrGpu could not deduce an intermediate draw
      * that would allow a successful transfer of the src pixels to the dst. The passed width,
      * height, and rowBytes, must be non-zero and already reflect clipping to the dst bounds.
      */
     bool getWritePixelsInfo(GrSurface* dstSurface, int width, int height, size_t rowBytes,
                             GrPixelConfig srcConfig, DrawPreference*, WritePixelTempDrawInfo*);
@@ skipping 346 matching lines @@
     ResetTimestamp                                                      fResetTimestamp;
     uint32_t                                                            fResetBits;
     // The context owns us, not vice-versa, so this ptr is not ref'ed by Gpu.
     GrContext*                                                          fContext;
 
     friend class GrPathRendering;
     typedef SkRefCnt INHERITED;
 };
 
 #endif