Make SkFont a bit more useable

src/core/SkFont.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkFont.h"
 #include "SkTypeface.h"
 #include "SkUtils.h"
@@ skipping 30 matching lines @@
 
 sk_sp<SkFont> SkFont::Make(sk_sp<SkTypeface> face, SkScalar size, MaskType mt, uint32_t flags) {
     return SkFont::Make(std::move(face), size, 1, 0, mt, flags);
 }
 
 sk_sp<SkFont> SkFont::makeWithSize(SkScalar newSize) const {
     return SkFont::Make(sk_ref_sp(this->getTypeface()), newSize, this->getScaleX(),
                         this->getSkewX(), this->getMaskType(), this->getFlags());
 }
 
+sk_sp<SkFont> SkFont::makeWithFlags(uint32_t newFlags) const {
+    return SkFont::Make(sk_ref_sp(this->getTypeface()), this->getSize(), this->getScaleX(),
+                        this->getSkewX(), this->getMaskType(), newFlags);
+}
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 int SkFont::textToGlyphs(const void* text, size_t byteLength, SkTextEncoding encoding,
                          uint16_t glyphs[], int maxGlyphCount) const {
     if (0 == byteLength) {
         return 0;
     }
 
     SkASSERT(text);
 
     int count = 0;  // fix uninitialized warning (even though the switch is complete!)
 
     switch (encoding) {
         case kUTF8_SkTextEncoding:
             count = SkUTF8_CountUnichars((const char*)text, byteLength);
             break;
         case kUTF16_SkTextEncoding:
             count = SkUTF16_CountUnichars((const uint16_t*)text, SkToInt(byteLength >> 1));
             break;
         case kUTF32_SkTextEncoding:
             count = SkToInt(byteLength >> 2);
             break;
         case kGlyphID_SkTextEncoding:
             count = SkToInt(byteLength >> 1);
             break;
     }
-    if (nullptr == glyphs) {
+    if (!glyphs) {
         return count;
     }
 
     // TODO: unify/eliminate SkTypeface::Encoding with SkTextEncoding
-    SkTypeface::Encoding typeface_encoding;
+    SkTypeface::Encoding typefaceEncoding;
     switch (encoding) {
         case kUTF8_SkTextEncoding:
-            typeface_encoding = SkTypeface::kUTF8_Encoding;
+            typefaceEncoding = SkTypeface::kUTF8_Encoding;
             break;
         case kUTF16_SkTextEncoding:
-            typeface_encoding = SkTypeface::kUTF16_Encoding;
+            typefaceEncoding = SkTypeface::kUTF16_Encoding;
             break;
         case kUTF32_SkTextEncoding:
-            typeface_encoding = SkTypeface::kUTF32_Encoding;
+            typefaceEncoding = SkTypeface::kUTF32_Encoding;
             break;
         default:
             SkASSERT(kGlyphID_SkTextEncoding == encoding);
             // we can early exit, since we already have glyphIDs
             memcpy(glyphs, text, count << 1);
             return count;
     }
 
-    (void)fTypeface->charsToGlyphs(text, typeface_encoding, glyphs, count);
+    (void)fTypeface->charsToGlyphs(text, typefaceEncoding, glyphs, count);
     return count;
 }
 
 SkScalar SkFont::measureText(const void* text, size_t byteLength, SkTextEncoding encoding) const {
     // TODO: need access to the cache
     return -1;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 27 matching lines @@
     }
 
     MaskType maskType = SkFont::kBW_MaskType;
     if (paint.isAntiAlias()) {
         maskType = paint.isLCDRenderText() ? kLCD_MaskType : kA8_MaskType;
     }
 
     return Make(sk_ref_sp(paint.getTypeface()), paint.getTextSize(), paint.getTextScaleX(),
                 paint.getTextSkewX(), maskType, flags);
 }