Move paints to the front of draw structs.

src/record/SkRecords.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkRecords_DEFINED
 #define SkRecords_DEFINED
 
 #include "SkCanvas.h"
 
 namespace SkRecords {
 
 // A list of all the types of canvas calls we can record.
 // Each of these is reified into a struct below.
 //
 // (We're using the macro-of-macro trick here to do several different things with the same list.)
 //
 // We leave this SK_RECORD_TYPES macro defined for use by code that wants to operate on SkRecords
 // types polymorphically.  (See SkRecord::Record::{visit,mutate} for an example.)
+//
+// Order doesn't technically matter here, but the compiler can generally generate better code if
+// you keep them semantically grouped, especially the Draws.  It's also nice to leave NoOp at 0.
 #define SK_RECORD_TYPES(M)                                          \
     M(NoOp)                                                         \
     M(Restore)                                                      \
     M(Save)                                                         \
     M(SaveLayer)                                                    \
+    M(PushCull)                                                     \
+    M(PopCull)                                                      \
+    M(PairedPushCull)         /*From SkRecordAnnotateCullingPairs*/ \
     M(Concat)                                                       \
     M(SetMatrix)                                                    \
     M(ClipPath)                                                     \
     M(ClipRRect)                                                    \
     M(ClipRect)                                                     \
     M(ClipRegion)                                                   \
     M(Clear)                                                        \
     M(DrawBitmap)                                                   \
     M(DrawBitmapMatrix)                                             \
     M(DrawBitmapNine)                                               \
     M(DrawBitmapRectToRect)                                         \
     M(DrawDRRect)                                                   \
     M(DrawOval)                                                     \
     M(DrawPaint)                                                    \
     M(DrawPath)                                                     \
     M(DrawPoints)                                                   \
     M(DrawPosText)                                                  \
     M(DrawPosTextH)                                                 \
     M(DrawRRect)                                                    \
     M(DrawRect)                                                     \
     M(DrawSprite)                                                   \
     M(DrawText)                                                     \
     M(DrawTextOnPath)                                               \
     M(DrawVertices)                                                 \
-    M(PushCull)                                                     \
-    M(PopCull)                                                      \
-    M(PairedPushCull)         /*From SkRecordAnnotateCullingPairs*/ \
     M(BoundedDrawPosTextH)    /*From SkRecordBoundDrawPosTextH*/
 
 // Defines SkRecords::Type, an enum of all record types.
 #define ENUM(T) T##_Type,
 enum Type { SK_RECORD_TYPES(ENUM) };
 #undef ENUM
 
 // Macros to make it easier to define a record for a draw call with 0 args, 1 args, 2 args, etc.
 // These should be clearer when you look at their use below.
 #define RECORD0(T)                      \
@@ skipping 124 matching lines @@
 
 RECORD1(Concat, SkMatrix, matrix);
 RECORD1(SetMatrix, SkMatrix, matrix);
 
 RECORD3(ClipPath, SkPath, path, SkRegion::Op, op, bool, doAA);
 RECORD3(ClipRRect, SkRRect, rrect, SkRegion::Op, op, bool, doAA);
 RECORD3(ClipRect, SkRect, rect, SkRegion::Op, op, bool, doAA);
 RECORD2(ClipRegion, SkRegion, region, SkRegion::Op, op);
 
 RECORD1(Clear, SkColor, color);
-RECORD4(DrawBitmap, ImmutableBitmap, bitmap,
+// While not strictly required, if you have an SkPaint, it's fastest to put it first.
+RECORD4(DrawBitmap, Optional<SkPaint>, paint,
+                    ImmutableBitmap, bitmap,
                     SkScalar, left,
-                    SkScalar, top,
-                    Optional<SkPaint>, paint);
-RECORD3(DrawBitmapMatrix, ImmutableBitmap, bitmap, SkMatrix, matrix, Optional<SkPaint>, paint);
-RECORD4(DrawBitmapNine, ImmutableBitmap, bitmap,
+                    SkScalar, top);
+RECORD3(DrawBitmapMatrix, Optional<SkPaint>, paint, ImmutableBitmap, bitmap, SkMatrix, matrix);
+RECORD4(DrawBitmapNine, Optional<SkPaint>, paint,
+                        ImmutableBitmap, bitmap,
                         SkIRect, center,
-                        SkRect, dst,
-                        Optional<SkPaint>, paint);
-RECORD5(DrawBitmapRectToRect, ImmutableBitmap, bitmap,
+                        SkRect, dst);
+RECORD5(DrawBitmapRectToRect, Optional<SkPaint>, paint,
+                              ImmutableBitmap, bitmap,
                               Optional<SkRect>, src,
                               SkRect, dst,
-                              Optional<SkPaint>, paint,
                               SkCanvas::DrawBitmapRectFlags, flags);
-RECORD3(DrawDRRect, SkRRect, outer, SkRRect, inner, SkPaint, paint);
-RECORD2(DrawOval, SkRect, oval, SkPaint, paint);
+RECORD3(DrawDRRect, SkPaint, paint, SkRRect, outer, SkRRect, inner);
+RECORD2(DrawOval, SkPaint, paint, SkRect, oval);
 RECORD1(DrawPaint, SkPaint, paint);
-RECORD2(DrawPath, SkPath, path, SkPaint, paint);
-RECORD4(DrawPoints, SkCanvas::PointMode, mode, size_t, count, SkPoint*, pts, SkPaint, paint);
-RECORD4(DrawPosText, PODArray<char>, text,
+RECORD2(DrawPath, SkPaint, paint, SkPath, path);
+RECORD4(DrawPoints, SkPaint, paint, SkCanvas::PointMode, mode, size_t, count, SkPoint*, pts);
+RECORD4(DrawPosText, SkPaint, paint,
+                     PODArray<char>, text,
                      size_t, byteLength,
-                     PODArray<SkPoint>, pos,
-                     SkPaint, paint);
-RECORD5(DrawPosTextH, PODArray<char>, text,
+                     PODArray<SkPoint>, pos);
+RECORD5(DrawPosTextH, SkPaint, paint,
+                      PODArray<char>, text,
                       size_t, byteLength,
                       PODArray<SkScalar>, xpos,
-                      SkScalar, y,
-                      SkPaint, paint);
-RECORD2(DrawRRect, SkRRect, rrect, SkPaint, paint);
-RECORD2(DrawRect, SkRect, rect, SkPaint, paint);
-RECORD4(DrawSprite, ImmutableBitmap, bitmap, int, left, int, top, Optional<SkPaint>, paint);
-RECORD5(DrawText, PODArray<char>, text,
+                      SkScalar, y);
+RECORD2(DrawRRect, SkPaint, paint, SkRRect, rrect);
+RECORD2(DrawRect, SkPaint, paint, SkRect, rect);
+RECORD4(DrawSprite, Optional<SkPaint>, paint, ImmutableBitmap, bitmap, int, left, int, top);
+RECORD5(DrawText, SkPaint, paint,
+                  PODArray<char>, text,
                   size_t, byteLength,
                   SkScalar, x,
-                  SkScalar, y,
-                  SkPaint, paint);
-RECORD5(DrawTextOnPath, PODArray<char>, text,
+                  SkScalar, y);
+RECORD5(DrawTextOnPath, SkPaint, paint,
+                        PODArray<char>, text,
                         size_t, byteLength,
                         SkPath, path,
-                        Optional<SkMatrix>, matrix,
-                        SkPaint, paint);
+                        Optional<SkMatrix>, matrix);
 
 // This guy is so ugly we just write it manually.
 struct DrawVertices {
     static const Type kType = DrawVertices_Type;
 
-    DrawVertices(SkCanvas::VertexMode vmode,
+    DrawVertices(const SkPaint& paint,
+                 SkCanvas::VertexMode vmode,
                  int vertexCount,
                  SkPoint* vertices,
                  SkPoint* texs,
                  SkColor* colors,
                  SkXfermode* xmode,
                  uint16_t* indices,
-                 int indexCount,
-                 const SkPaint& paint)
-        : vmode(vmode)
+                 int indexCount)
+        : paint(paint)
+        , vmode(vmode)
         , vertexCount(vertexCount)
         , vertices(vertices)
         , texs(texs)
         , colors(colors)
         , xmode(SkSafeRef(xmode))
         , indices(indices)
-        , indexCount(indexCount)
-        , paint(paint) {}
+        , indexCount(indexCount) {}
 
+    SkPaint paint;
     SkCanvas::VertexMode vmode;
     int vertexCount;
     PODArray<SkPoint> vertices;
     PODArray<SkPoint> texs;
     PODArray<SkColor> colors;
     SkAutoTUnref<SkXfermode> xmode;
     PODArray<uint16_t> indices;
     int indexCount;
-    SkPaint paint;
 };
 
 // Records added by optimizations.
 RECORD2(PairedPushCull, Adopted<PushCull>, base, unsigned, skip);
 RECORD3(BoundedDrawPosTextH, Adopted<DrawPosTextH>, base, SkScalar, minY, SkScalar, maxY);
 
 #undef RECORD0
 #undef RECORD1
 #undef RECORD2
 #undef RECORD3
 #undef RECORD4
 #undef RECORD5
 
 }  // namespace SkRecords
 
 #endif//SkRecords_DEFINED