Bump min picture version.

src/core/SkPaint.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 "SkPaint.h"
 #include "SkAnnotation.h"
 #include "SkAutoKern.h"
@@ skipping 1781 matching lines @@
         SkASSERT(bitCount > 0 && bitCount <= 32);
         uint32_t mask = ~0U;
         mask >>= (32 - bitCount);
         SkASSERT(0 == (value & ~mask));
     }
 #else
     #define ASSERT_FITS_IN(value, bitcount)
 #endif
 
 enum FlatFlags {
-    kHasTypeface_FlatFlag                      = 0x01,
-    kHasEffects_FlatFlag                       = 0x02,
-    kHasNonDefaultPaintOptionsAndroid_FlatFlag = 0x04,
+    kHasTypeface_FlatFlag = 0x1,
+    kHasEffects_FlatFlag  = 0x2,
 
-    kFlatFlagMask = 0x7,
+    kFlatFlagMask         = 0x3,
 };
 
 enum BitsPerField {
     kFlags_BPF  = 16,
     kHint_BPF   = 2,
     kAlign_BPF  = 2,
     kFilter_BPF = 2,
     kFlatFlags_BPF  = 3,
 };
 
@@ skipping 15 matching lines @@
 }
 
 static FlatFlags unpack_paint_flags(SkPaint* paint, uint32_t packed) {
     paint->setFlags(packed >> 16);
     paint->setHinting((SkPaint::Hinting)((packed >> 14) & BPF_Mask(kHint_BPF)));
     paint->setTextAlign((SkPaint::Align)((packed >> 12) & BPF_Mask(kAlign_BPF)));
     paint->setFilterLevel((SkPaint::FilterLevel)((packed >> 10) & BPF_Mask(kFilter_BPF)));
     return (FlatFlags)(packed & kFlatFlagMask);
 }
 
-// V22_COMPATIBILITY_CODE
-static FlatFlags unpack_paint_flags_v22(SkPaint* paint, uint32_t packed) {
-    enum {
-        kFilterBitmap_Flag    = 0x02,
-        kHighQualityFilterBitmap_Flag = 0x4000,
-
-        kAll_Flags = kFilterBitmap_Flag | kHighQualityFilterBitmap_Flag
-    };
-
-    // previously flags:16, textAlign:8, flatFlags:8
-    // now flags:16, hinting:4, textAlign:4, flatFlags:8
-    unsigned flags = packed >> 16;
-    int filter = 0;
-    if (flags & kFilterBitmap_Flag) {
-        filter |= 1;
-    }
-    if (flags & kHighQualityFilterBitmap_Flag) {
-        filter |= 2;
-    }
-    paint->setFilterLevel((SkPaint::FilterLevel)filter);
-    flags &= ~kAll_Flags;   // remove these (now dead) bit flags
-
-    paint->setFlags(flags);
-
-    // hinting added later. 0 in this nibble means use the default.
-    uint32_t hinting = (packed >> 12) & 0xF;
-    paint->setHinting(0 == hinting ? SkPaint::kNormal_Hinting : static_cast<SkPaint::Hinting>(hinting-1));
-    paint->setTextAlign(static_cast<SkPaint::Align>((packed >> 8) & 0xF));
-    return (FlatFlags)(packed & kFlatFlagMask);
-}
-
 // The size of a flat paint's POD fields
 static const uint32_t kPODPaintSize =   5 * sizeof(SkScalar) +
                                         1 * sizeof(SkColor) +
                                         1 * sizeof(uint16_t) +
                                         6 * sizeof(uint8_t);
 
 /*  To save space/time, we analyze the paint, and write a truncated version of
     it if there are not tricky elements like shaders, etc.
  */
 void SkPaint::flatten(SkWriteBuffer& buffer) const {
@@ skipping 58 matching lines @@
     const uint32_t* pod = reinterpret_cast<const uint32_t*>(podData);
 
     // the order we read must match the order we wrote in flatten()
     this->setTextSize(read_scalar(pod));
     this->setTextScaleX(read_scalar(pod));
     this->setTextSkewX(read_scalar(pod));
     this->setStrokeWidth(read_scalar(pod));
     this->setStrokeMiter(read_scalar(pod));
     this->setColor(*pod++);
 
-    unsigned flatFlags = 0;
-    if (buffer.isVersionLT(SkReadBuffer::kFilterLevelIsEnum_Version)) {
-        flatFlags = unpack_paint_flags_v22(this, *pod++);
-    } else {
-        flatFlags = unpack_paint_flags(this, *pod++);
-    }
+    unsigned flatFlags = unpack_paint_flags(this, *pod++);
 
     uint32_t tmp = *pod++;
     this->setStrokeCap(static_cast<Cap>((tmp >> 24) & 0xFF));
     this->setStrokeJoin(static_cast<Join>((tmp >> 16) & 0xFF));
     this->setStyle(static_cast<Style>((tmp >> 8) & 0xFF));
     this->setTextEncoding(static_cast<TextEncoding>((tmp >> 0) & 0xFF));
 
     if (flatFlags & kHasTypeface_FlatFlag) {
         this->setTypeface(buffer.readTypeface());
     } else {
@@ skipping 16 matching lines @@
     } else {
         this->setPathEffect(NULL);
         this->setShader(NULL);
         this->setXfermode(NULL);
         this->setMaskFilter(NULL);
         this->setColorFilter(NULL);
         this->setRasterizer(NULL);
         this->setLooper(NULL);
         this->setImageFilter(NULL);
     }
-
-    if (buffer.isVersionLT(SkReadBuffer::kRemoveAndroidPaintOpts_Version) &&
-            flatFlags & kHasNonDefaultPaintOptionsAndroid_FlatFlag) {
-        SkString tag;
-        buffer.readUInt();
-        buffer.readString(&tag);
-        buffer.readBool();
-    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkShader* SkPaint::setShader(SkShader* shader) {
     SkRefCnt_SafeAssign(fShader, shader);
     return shader;
 }
 
 SkColorFilter* SkPaint::setColorFilter(SkColorFilter* filter) {
@@ skipping 403 matching lines @@
 }
 
 uint32_t SkPaint::getHash() const {
     // We're going to hash 10 pointers and 7 32-bit values, finishing up with fBitfields,
     // so fBitfields should be 10 pointers and 6 32-bit values from the start.
     SK_COMPILE_ASSERT(offsetof(SkPaint, fBitfields) == 10 * sizeof(void*) + 6 * sizeof(uint32_t),
                       SkPaint_notPackedTightly);
     return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(this),
                                offsetof(SkPaint, fBitfields) + sizeof(fBitfields));
 }