fix more 64bit warnings

src/ports/SkFontHost_mac.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 <vector>
 #ifdef SK_BUILD_FOR_MAC
@@ skipping 131 matching lines @@
     return rect.origin.y + rect.size.height;
 }
 
 static CGFloat CGRectGetWidth_inline(const CGRect& rect) {
     return rect.size.width;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void sk_memset_rect32(uint32_t* ptr, uint32_t value,
-                             size_t width, size_t height, size_t rowBytes) {
+                             int width, int height, size_t rowBytes) {
     SkASSERT(width);
     SkASSERT(width * sizeof(uint32_t) <= rowBytes);
 
     if (width >= 32) {
         while (height) {
             sk_memset32(ptr, value, width);
             ptr = (uint32_t*)((char*)ptr + rowBytes);
             height -= 1;
         }
         return;
@@ skipping 1271 matching lines @@
     }
     CTFontRef ct = CTFontCreateWithGraphicsFont(cg, 0, NULL, NULL);
     return cg ? SkCreateTypefaceFromCTFont(ct) : NULL;
 }
 
 // Web fonts added to the the CTFont registry do not return their character set.
 // Iterate through the font in this case. The existing caller caches the result,
 // so the performance impact isn't too bad.
 static void populate_glyph_to_unicode_slow(CTFontRef ctFont, CFIndex glyphCount,
                                            SkTDArray<SkUnichar>* glyphToUnicode) {
-    glyphToUnicode->setCount(glyphCount);
+    glyphToUnicode->setCount(SkToInt(glyphCount));
     SkUnichar* out = glyphToUnicode->begin();
     sk_bzero(out, glyphCount * sizeof(SkUnichar));
     UniChar unichar = 0;
     while (glyphCount > 0) {
         CGGlyph glyph;
         if (CTFontGetGlyphsForCharacters(ctFont, &unichar, &glyph, 1)) {
             out[glyph] = unichar;
             --glyphCount;
         }
         if (++unichar == 0) {
@@ skipping 23 matching lines @@
         return;
     }
     if (length > 8192) {
         // TODO: Add support for Unicode above 0xFFFF
         // Consider only the BMP portion of the Unicode character points.
         // The bitmap may contain other planes, up to plane 16.
         // See http://developer.apple.com/library/ios/#documentation/CoreFoundation/Reference/CFCharacterSetRef/Reference/reference.html
         length = 8192;
     }
     const UInt8* bits = CFDataGetBytePtr(bitmap);
-    glyphToUnicode->setCount(glyphCount);
+    glyphToUnicode->setCount(SkToInt(glyphCount));
     SkUnichar* out = glyphToUnicode->begin();
     sk_bzero(out, glyphCount * sizeof(SkUnichar));
     for (int i = 0; i < length; i++) {
         int mask = bits[i];
         if (!mask) {
             continue;
         }
         for (int j = 0; j < 8; j++) {
             CGGlyph glyph;
             UniChar unichar = static_cast<UniChar>((i << 3) + j);
@@ skipping 119 matching lines @@
         info->fType = SkAdvancedTypefaceMetrics::kNotEmbeddable_Font;
     } else if (perGlyphInfo & SkAdvancedTypefaceMetrics::kHAdvance_PerGlyphInfo) {
         if (info->fStyle & SkAdvancedTypefaceMetrics::kFixedPitch_Style) {
             skia_advanced_typeface_metrics_utils::appendRange(&info->fGlyphWidths, 0);
             info->fGlyphWidths->fAdvance.append(1, &min_width);
             skia_advanced_typeface_metrics_utils::finishRange(info->fGlyphWidths.get(), 0,
                         SkAdvancedTypefaceMetrics::WidthRange::kDefault);
         } else {
             info->fGlyphWidths.reset(
                 skia_advanced_typeface_metrics_utils::getAdvanceData(ctFont.get(),
-                               glyphCount,
+                               SkToInt(glyphCount),
                                glyphIDs,
                                glyphIDsCount,
                                &getWidthAdvance));
         }
     }
     return info;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 78 matching lines @@
 
     // write tables
     SkSFNTHeader::TableDirectoryEntry* entry = (SkSFNTHeader::TableDirectoryEntry*)dataPtr;
     dataPtr += sizeof(SkSFNTHeader::TableDirectoryEntry) * numTables;
     for (int tableIndex = 0; tableIndex < numTables; ++tableIndex) {
         size_t tableSize = tableSizes[tableIndex];
         this->getTableData(tableTags[tableIndex], 0, tableSize, dataPtr);
         entry->tag = SkEndian_SwapBE32(tableTags[tableIndex]);
         entry->checksum = SkEndian_SwapBE32(SkOTUtils::CalcTableChecksum((SK_OT_ULONG*)dataPtr,
                                                                          tableSize));
-        entry->offset = SkEndian_SwapBE32(dataPtr - dataStart);
-        entry->logicalLength = SkEndian_SwapBE32(tableSize);
+        entry->offset = SkEndian_SwapBE32(SkToU32(dataPtr - dataStart));
+        entry->logicalLength = SkEndian_SwapBE32(SkToU32(tableSize));
 
         dataPtr += (tableSize + 3) & ~3;
         ++entry;
     }
 
     return stream;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 39 matching lines @@
     }
     return data;
 }
 
 int SkTypeface_Mac::onGetTableTags(SkFontTableTag tags[]) const {
     AutoCFRelease<CFArrayRef> cfArray(CTFontCopyAvailableTables(fFontRef,
                                                 kCTFontTableOptionNoOptions));
     if (NULL == cfArray) {
         return 0;
     }
-    int count = CFArrayGetCount(cfArray);
+    int count = SkToInt(CFArrayGetCount(cfArray));
     if (tags) {
         for (int i = 0; i < count; ++i) {
             uintptr_t fontTag = reinterpret_cast<uintptr_t>(CFArrayGetValueAtIndex(cfArray, i));
             tags[i] = static_cast<SkFontTableTag>(fontTag);
         }
     }
     return count;
 }
 
 size_t SkTypeface_Mac::onGetTableData(SkFontTableTag tag, size_t offset,
@@ skipping 124 matching lines @@
     int srcCount;
     switch (encoding) {
         case kUTF8_Encoding: {
             const char* utf8 = reinterpret_cast<const char*>(chars);
             UniChar* utf16 = charStorage.reset(2 * glyphCount);
             src = utf16;
             for (int i = 0; i < glyphCount; ++i) {
                 SkUnichar uni = SkUTF8_NextUnichar(&utf8);
                 utf16 += SkUTF16_FromUnichar(uni, utf16);
             }
-            srcCount = utf16 - src;
+            srcCount = SkToInt(utf16 - src);
             break;
         }
         case kUTF16_Encoding: {
             src = reinterpret_cast<const UniChar*>(chars);
             int extra = 0;
             for (int i = 0; i < glyphCount; ++i) {
                 if (SkUTF16_IsHighSurrogate(src[i + extra])) {
                     ++extra;
                 }
             }
             srcCount = glyphCount + extra;
             break;
         }
         case kUTF32_Encoding: {
             const SkUnichar* utf32 = reinterpret_cast<const SkUnichar*>(chars);
             UniChar* utf16 = charStorage.reset(2 * glyphCount);
             src = utf16;
             for (int i = 0; i < glyphCount; ++i) {
                 utf16 += SkUTF16_FromUnichar(utf32[i], utf16);
             }
-            srcCount = utf16 - src;
+            srcCount = SkToInt(utf16 - src);
             break;
         }
     }
 
     // If glyphs is NULL, CT still needs glyph storage for finding the first failure.
     // Also, if there are any non-bmp code points, the provided 'glyphs' storage will be inadequate.
     SkAutoSTMalloc<1024, uint16_t> glyphStorage;
     uint16_t* macGlyphs = glyphs;
     if (NULL == macGlyphs || srcCount > glyphCount) {
         macGlyphs = glyphStorage.reset(srcCount);
@@ skipping 27 matching lines @@
     for (int i = 0; i < glyphCount; ++i) {
         if (0 == compactedGlyphs[i]) {
             return i;
         }
     }
     // Odd to get here, as we expected CT to have returned true up front.
     return glyphCount;
 }
 
 int SkTypeface_Mac::onCountGlyphs() const {
-    return CTFontGetGlyphCount(fFontRef);
+    return SkToInt(CTFontGetGlyphCount(fFontRef));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 #if 1
 
 static bool find_desc_str(CTFontDescriptorRef desc, CFStringRef name, SkString* value) {
     AutoCFRelease<CFStringRef> ref((CFStringRef)CTFontDescriptorCopyAttribute(desc, name));
     if (NULL == ref.get()) {
         return false;
@@ skipping 122 matching lines @@
 class SkFontStyleSet_Mac : public SkFontStyleSet {
 public:
     SkFontStyleSet_Mac(CFStringRef familyName, CTFontDescriptorRef desc)
         : fArray(CTFontDescriptorCreateMatchingFontDescriptors(desc, NULL))
         , fFamilyName(familyName)
         , fCount(0) {
         CFRetain(familyName);
         if (NULL == fArray) {
             fArray = CFArrayCreate(NULL, NULL, 0, NULL);
         }
-        fCount = CFArrayGetCount(fArray);
+        fCount = SkToInt(CFArrayGetCount(fArray));
     }
 
     virtual ~SkFontStyleSet_Mac() {
         CFRelease(fArray);
         CFRelease(fFamilyName);
     }
 
     virtual int count() SK_OVERRIDE {
         return fCount;
     }
@@ skipping 56 matching lines @@
     CFArrayRef  fNames;
 
     CFStringRef stringAt(int index) const {
         SkASSERT((unsigned)index < (unsigned)fCount);
         return (CFStringRef)CFArrayGetValueAtIndex(fNames, index);
     }
 
     void lazyInit() {
         if (NULL == fNames) {
             fNames = SkCTFontManagerCopyAvailableFontFamilyNames();
-            fCount = fNames ? CFArrayGetCount(fNames) : 0;
+            fCount = fNames ? SkToInt(CFArrayGetCount(fNames)) : 0;
         }
     }
 
     static SkFontStyleSet* CreateSet(CFStringRef cfFamilyName) {
         AutoCFRelease<CFMutableDictionaryRef> cfAttr(
                  CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
                                            &kCFTypeDictionaryKeyCallBacks,
                                            &kCFTypeDictionaryValueCallBacks));
 
         CFDictionaryAddValue(cfAttr, kCTFontFamilyNameAttribute, cfFamilyName);
@@ skipping 80 matching lines @@
         return create_typeface(NULL, familyName, (SkTypeface::Style)styleBits);
     }
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFontMgr* SkFontMgr::Factory() {
     return SkNEW(SkFontMgr_Mac);
 }
 #endif