Pack BitmapTextBlob a bit tighter

src/gpu/GrAtlasTextContext.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrAtlasTextContext_DEFINED
 #define GrAtlasTextContext_DEFINED
 
@@ skipping 80 matching lines @@
         struct Run {
             Run()
                 : fColor(GrColor_ILLEGAL)
                 , fInitialized(false)
                 , fDrawAsPaths(false) {
                 fVertexBounds.setLargestInverted();
             }
             struct SubRunInfo {
                 SubRunInfo()
                     : fAtlasGeneration(GrBatchAtlas::kInvalidAtlasGeneration)
+                    , fVertexStartIndex(0)
+                    , fVertexEndIndex(0)
                     , fGlyphStartIndex(0)
                     , fGlyphEndIndex(0)
-                    , fVertexStartIndex(0)
-                    , fVertexEndIndex(0)
                     , fDrawAsDistanceFields(false) {}
-                GrMaskFormat fMaskFormat;
-                uint64_t fAtlasGeneration;
-                uint32_t fGlyphStartIndex;
-                uint32_t fGlyphEndIndex;
-                size_t fVertexStartIndex;
-                size_t fVertexEndIndex;
-                GrBatchAtlas::BulkUseTokenUpdater fBulkUseToken;
-
-                // distance field properties
-                bool fDrawAsDistanceFields;
-                bool fUseLCDText;
                 // Distance field text cannot draw coloremoji, and so has to fall back.  However,
                 // though the distance field text and the coloremoji may share the same run, they
                 // will have different descriptors.  If fOverrideDescriptor is non-NULL, then it
                 // will be used in place of the run's descriptor to regen texture coords
                 // TODO we could have a descriptor cache, it would reduce the size of these blobs
                 // significantly, and then the subrun could just have a refed pointer to the
                 // correct descriptor.
-                SkAutoTDelete<SkAutoDescriptor> fOverrideDescriptor;
+                SkAutoTDelete<SkAutoDescriptor> fOverrideDescriptor; // df properties
+                GrBatchAtlas::BulkUseTokenUpdater fBulkUseToken;
+                uint64_t fAtlasGeneration;
+                size_t fVertexStartIndex;
+                size_t fVertexEndIndex;
+                uint32_t fGlyphStartIndex;
+                uint32_t fGlyphEndIndex;
+                SkScalar fTextRatio; // df property
+                GrMaskFormat fMaskFormat;
+                bool fDrawAsDistanceFields; // df property
+                bool fUseLCDText; // df property
             };
 
             class SubRunInfoArray {
             public:
                 SubRunInfoArray()
                     : fSubRunCount(0)
                     , fSubRunAllocation(kMinSubRuns) {
                     SK_COMPILE_ASSERT(kMinSubRuns > 0, insufficient_subrun_allocation);
                     // We always seed with one here, so we can assume a valid subrun during
                     // push_back
@@ skipping 29 matching lines @@
                 SubRunInfo& operator[](int index) {
                     return fPtr[index];
                 }
                 const SubRunInfo& operator[](int index) const {
                     return fPtr[index];
                 }
 
             private:
                 static const int kMinSubRuns = 1;
                 static const int kMinSubRunStorage = kMinSubRuns * sizeof(SubRunInfo);
+                SubRunInfo* fPtr;
                 SkAutoSTMalloc<kMinSubRunStorage, unsigned char> fSubRunStorage;
                 int fSubRunCount;
                 int fSubRunAllocation;
-                SubRunInfo* fPtr;
             };
+            SkAutoTUnref<SkTypeface> fTypeface;
+            SkRect fVertexBounds;
             SubRunInfoArray fSubRunInfo;
             SkAutoDescriptor fDescriptor;
-            SkAutoTUnref<SkTypeface> fTypeface;
-            SkRect fVertexBounds;
             GrColor fColor;
             bool fInitialized;
             bool fDrawAsPaths;
         };
 
         struct BigGlyph {
             BigGlyph(const SkPath& path, int vx, int vy) : fPath(path), fVx(vx), fVy(vy) {}
             SkPath fPath;
             int fVx;
             int fVy;
         };
-#ifdef SK_DEBUG
-        mutable SkScalar fTotalXError;
-        mutable SkScalar fTotalYError;
-#endif
-        SkColor fPaintColor;
-        SkTArray<BigGlyph> fBigGlyphs;
-        SkMatrix fViewMatrix;
-        SkScalar fX;
-        SkScalar fY;
-        int fRunCount;
-        SkMaskFilter::BlurRec fBlurRec;
-        struct StrokeInfo {
-            SkScalar fFrameWidth;
-            SkScalar fMiterLimit;
-            SkPaint::Join fJoin;
-        };
-        StrokeInfo fStrokeInfo;
-        GrMemoryPool* fPool;
-
-        enum TextType {
-            kHasDistanceField_TextType = 0x1,
-            kHasBitmap_TextType = 0x2,
-        };
-        uint8_t fTextType;
-
-        BitmapTextBlob() : fTextType(0) {}
-
-        // all glyph / vertex offsets are into these pools.
-        unsigned char* fVertices;
-        GrGlyph::PackedID* fGlyphIDs;
-        Run* fRuns;
 
         struct Key {
             Key() {
                 sk_bzero(this, sizeof(Key));
             }
             uint32_t fUniqueID;
             SkPaint::Style fStyle;
             // Color may affect the gamma of the mask we generate, but in a fairly limited way.
             // Each color is assigned to on of a fixed number of buckets based on its
             // luminance. For each luminance bucket there is a "canonical color" that
             // represents the bucket.  This functionality is currently only supported for A8
             SkColor fCanonicalColor;
             bool fHasBlur;
 
             bool operator==(const Key& other) const {
                 return 0 == memcmp(this, &other, sizeof(Key));
             }
         };
+
+        struct StrokeInfo {
+            SkScalar fFrameWidth;
+            SkScalar fMiterLimit;
+            SkPaint::Join fJoin;
+        };
+
+        enum TextType {
+            kHasDistanceField_TextType = 0x1,
+            kHasBitmap_TextType = 0x2,
+        };
+
+        // all glyph / vertex offsets are into these pools.
+        unsigned char* fVertices;
+        GrGlyph::PackedID* fGlyphIDs;
+        Run* fRuns;
+        GrMemoryPool* fPool;
+        SkMaskFilter::BlurRec fBlurRec;
+        StrokeInfo fStrokeInfo;
+        SkTArray<BigGlyph> fBigGlyphs;
         Key fKey;
+        SkMatrix fViewMatrix;
+#ifdef SK_DEBUG
+        mutable SkScalar fTotalXError;
+        mutable SkScalar fTotalYError;
+#endif
+        SkScalar fX;
+        SkScalar fY;
+        SkColor fPaintColor;
+        int fRunCount;
+        uint8_t fTextType;
+
+        BitmapTextBlob() : fTextType(0) {}
 
         static const Key& GetKey(const BitmapTextBlob& blob) {
             return blob.fKey;
         }
 
         static uint32_t Hash(const Key& key) {
             return SkChecksum::Murmur3(&key, sizeof(Key));
         }
 
         void operator delete(void* p) {
@@ skipping 129 matching lines @@
     bool fEnableDFRendering;
     SkAutoTUnref<DistanceAdjustTable> fDistanceAdjustTable;
 
     friend class GrTextBlobCache;
     friend class BitmapTextBatch;
 
     typedef GrTextContext INHERITED;
 };
 
 #endif