Nobody defines SK_SUPPORT_HINTING_SCALE_FACTOR any more, so remove it.

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"
@@ skipping 52 matching lines @@
     fColorFilter = NULL;
     fRasterizer  = NULL;
     fLooper      = NULL;
     fImageFilter = NULL;
     fAnnotation  = NULL;
     fWidth      = 0;
 #endif
 
     fTextSize   = SkPaintDefaults_TextSize;
     fTextScaleX = SK_Scalar1;
-#ifdef SK_SUPPORT_HINTING_SCALE_FACTOR
-    fHintingScaleFactor = SK_Scalar1;
-#endif
     fColor      = SK_ColorBLACK;
     fMiterLimit = SkPaintDefaults_MiterLimit;
     fFlags      = SkPaintDefaults_Flags;
     fCapType    = kDefault_Cap;
     fJoinType   = kDefault_Join;
     fTextAlign  = kLeft_Align;
     fStyle      = kFill_Style;
     fTextEncoding = kUTF8_TextEncoding;
     fHinting    = SkPaintDefaults_Hinting;
     fPrivFlags  = 0;
@@ skipping 296 matching lines @@
 void SkPaint::setTextScaleX(SkScalar scaleX) {
     GEN_ID_INC_EVAL(scaleX != fTextScaleX);
     fTextScaleX = scaleX;
 }
 
 void SkPaint::setTextSkewX(SkScalar skewX) {
     GEN_ID_INC_EVAL(skewX != fTextSkewX);
     fTextSkewX = skewX;
 }
 
-#ifdef SK_SUPPORT_HINTING_SCALE_FACTOR
-void SkPaint::setHintingScaleFactor(SkScalar hintingScaleFactor) {
-    GEN_ID_INC_EVAL(hintingScaleFactor != fHintingScaleFactor);
-    fHintingScaleFactor = hintingScaleFactor;
-}
-#endif
-
 void SkPaint::setTextEncoding(TextEncoding encoding) {
     if ((unsigned)encoding <= kGlyphID_TextEncoding) {
         GEN_ID_INC_EVAL((unsigned)encoding != fTextEncoding);
         fTextEncoding = encoding;
     } else {
 #ifdef SK_REPORT_API_RANGE_CHECK
         SkDebugf("SkPaint::setTextEncoding(%d) out of range\n", encoding);
 #endif
     }
 }
@@ skipping 1178 matching lines @@
 
     SkTypeface* typeface = paint.getTypeface();
     if (NULL == typeface) {
         typeface = SkTypeface::GetDefaultTypeface();
     }
     rec->fOrigFontID = typeface->uniqueID();
     rec->fFontID = rec->fOrigFontID;
     rec->fTextSize = paint.getTextSize();
     rec->fPreScaleX = paint.getTextScaleX();
     rec->fPreSkewX  = paint.getTextSkewX();
-#ifdef SK_SUPPORT_HINTING_SCALE_FACTOR
-    rec->fHintingScaleFactor = paint.getHintingScaleFactor();
-#endif
 
     if (deviceMatrix) {
         rec->fPost2x2[0][0] = sk_relax(deviceMatrix->getScaleX());
         rec->fPost2x2[0][1] = sk_relax(deviceMatrix->getSkewX());
         rec->fPost2x2[1][0] = sk_relax(deviceMatrix->getSkewY());
         rec->fPost2x2[1][1] = sk_relax(deviceMatrix->getScaleY());
     } else {
         rec->fPost2x2[0][0] = rec->fPost2x2[1][1] = SK_Scalar1;
         rec->fPost2x2[0][1] = rec->fPost2x2[1][0] = 0;
     }
@@ skipping 441 matching lines @@
     }
 
 
     if (buffer.isOrderedBinaryBuffer()) {
         SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
         uint32_t* ptr = buffer.getOrderedBinaryBuffer()->reserve(kPODPaintSize);
 
         ptr = write_scalar(ptr, this->getTextSize());
         ptr = write_scalar(ptr, this->getTextScaleX());
         ptr = write_scalar(ptr, this->getTextSkewX());
-#ifdef SK_SUPPORT_HINTING_SCALE_FACTOR
-        ptr = write_scalar(ptr, this->getHintingScaleFactor());
-#else
-        // Dummy value.
+        // Dummy value for obsolete hinting scale factor.  TODO: remove with next picture version
         ptr = write_scalar(ptr, SK_Scalar1);
-#endif
         ptr = write_scalar(ptr, this->getStrokeWidth());
         ptr = write_scalar(ptr, this->getStrokeMiter());
         *ptr++ = this->getColor();
         // previously flags:16, textAlign:8, flatFlags:8
         // now flags:16, hinting:4, textAlign:4, flatFlags:8
         *ptr++ = (this->getFlags() << 16) |
                  // hinting added later. 0 in this nibble means use the default.
                  ((this->getHinting()+1) << 12) |
                  (this->getTextAlign() << 8) |
                  flatFlags;
         *ptr++ = pack_4(this->getStrokeCap(), this->getStrokeJoin(),
                         this->getStyle(), this->getTextEncoding());
     } else {
         buffer.writeScalar(fTextSize);
         buffer.writeScalar(fTextScaleX);
         buffer.writeScalar(fTextSkewX);
-#ifdef SK_SUPPORT_HINTING_SCALE_FACTOR
-        buffer.writeScalar(fHintingScaleFactor);
-#else
-        // Dummy value.
+        // Dummy value for obsolete hinting scale factor.  TODO: remove with next picture version
         buffer.writeScalar(SK_Scalar1);
-#endif
         buffer.writeScalar(fWidth);
         buffer.writeScalar(fMiterLimit);
         buffer.writeColor(fColor);
         buffer.writeUInt(fFlags);
         buffer.writeUInt(fHinting);
         buffer.writeUInt(fTextAlign);
         buffer.writeUInt(flatFlags);
 
         buffer.writeUInt(fCapType);
         buffer.writeUInt(fJoinType);
@@ skipping 25 matching lines @@
     uint8_t flatFlags = 0;
     if (buffer.isOrderedBinaryBuffer()) {
         SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
         const void* podData = buffer.getOrderedBinaryBuffer()->skip(kPODPaintSize);
         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));
-#ifdef SK_SUPPORT_HINTING_SCALE_FACTOR
-        this->setHintingScaleFactor(read_scalar(pod));
-#else
         // Skip the hinting scalar factor, which is not supported.
         read_scalar(pod);
-#endif
         this->setStrokeWidth(read_scalar(pod));
         this->setStrokeMiter(read_scalar(pod));
         this->setColor(*pod++);
 
         // previously flags:16, textAlign:8, flatFlags:8
         // now flags:16, hinting:4, textAlign:4, flatFlags:8
         uint32_t tmp = *pod++;
         this->setFlags(tmp >> 16);
 
         // hinting added later. 0 in this nibble means use the default.
         uint32_t hinting = (tmp >> 12) & 0xF;
         this->setHinting(0 == hinting ? kNormal_Hinting : static_cast<Hinting>(hinting-1));
 
         this->setTextAlign(static_cast<Align>((tmp >> 8) & 0xF));
 
         flatFlags = tmp & 0xFF;
 
         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));
     } else {
         this->setTextSize(buffer.readScalar());
         this->setTextScaleX(buffer.readScalar());
         this->setTextSkewX(buffer.readScalar());
-#ifdef SK_SUPPORT_HINTING_SCALE_FACTOR
-        this->setHintingScaleFactor(buffer.readScalar());
-#else
         // Skip the hinting scalar factor, which is not supported.
         buffer.readScalar();
-#endif
         this->setStrokeWidth(buffer.readScalar());
         this->setStrokeMiter(buffer.readScalar());
         this->setColor(buffer.readColor());
         this->setFlags(buffer.readUInt());
         this->setHinting(static_cast<SkPaint::Hinting>(buffer.readUInt()));
         this->setTextAlign(static_cast<SkPaint::Align>(buffer.readUInt()));
         flatFlags = buffer.readUInt();
 
         this->setStrokeCap(static_cast<SkPaint::Cap>(buffer.readUInt()));
         this->setStrokeJoin(static_cast<SkPaint::Join>(buffer.readUInt()));
@@ skipping 420 matching lines @@
             case SkXfermode::kPlus_Mode:
                 return 0 == this->getAlpha();
             case SkXfermode::kDst_Mode:
                 return true;
             default:
                 break;
         }
     }
     return false;
 }