Finish removing WebKitSystemInterface from Blink.

Source/core/platform/graphics/mac/SimpleFontDataMac.mm

 /*
  * Copyright (C) 2005, 2006, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 20 matching lines @@
 #import <ApplicationServices/ApplicationServices.h>
 #import <float.h>
 #import <unicode/uchar.h>
 #import "core/platform/SharedBuffer.h"
 #import "core/platform/graphics/Color.h"
 #import "core/platform/graphics/FloatRect.h"
 #import "core/platform/graphics/Font.h"
 #import "core/platform/graphics/FontCache.h"
 #import "core/platform/graphics/FontDescription.h"
 #import "core/platform/mac/BlockExceptions.h"
-#import "core/platform/mac/WebCoreSystemInterface.h"
 #import <wtf/Assertions.h>
 #import <wtf/RetainPtr.h>
 #import <wtf/StdLibExtras.h>
 #import <wtf/UnusedParam.h>
 
 @interface NSFont (WebAppKitSecretAPI)
 - (BOOL)_isFakeFixedPitch;
 @end
 
+// The names of these constants were taken from history
+// /trunk/WebKit/WebCoreSupport.subproj/WebTextRenderer.m@9311. The values
+// were derived from the assembly of libWebKitSystemInterfaceLeopard.a.
+enum CGFontRenderingMode {
+  kCGFontRenderingMode1BitPixelAligned = 0x0,
+  kCGFontRenderingModeAntialiasedPixelAligned = 0x1,
+  kCGFontRenderingModeAntialiased = 0xd
+};
+
+// Forward declare Mac SPIs.
+extern "C" {
+// Request for public API: rdar://13803586
+bool CGFontGetGlyphAdvancesForStyle(CGFontRef font, CGAffineTransform* transform, CGFontRenderingMode renderingMode, ATSGlyphRef* glyph, size_t count, CGSize* advance);
+
+// Request for public API: rdar://13803619
+CTLineRef CTLineCreateWithUniCharProvider(const UniChar* (*provide)(CFIndex stringIndex, CFIndex* charCount, CFDictionaryRef* attributes, void* context), void (*dispose)(const UniChar* chars, void* context), void* context);
+}
+
+static CGFontRenderingMode cgFontRenderingModeForNSFont(NSFont* font) {
+    if (!font)
+        return kCGFontRenderingModeAntialiasedPixelAligned;
+
+    switch ([font renderingMode]) {
+        case NSFontIntegerAdvancementsRenderingMode: return kCGFontRenderingMode1BitPixelAligned;
+        case NSFontAntialiasedIntegerAdvancementsRenderingMode: return kCGFontRenderingModeAntialiasedPixelAligned;
+        default: return kCGFontRenderingModeAntialiased;
+    }
+}
+
 using namespace std;
 
 namespace WebCore {
-  
+
 static bool fontHasVerticalGlyphs(CTFontRef ctFont)
 {
     // The check doesn't look neat but this is what AppKit does for vertical writing...
     RetainPtr<CFArrayRef> tableTags(AdoptCF, CTFontCopyAvailableTables(ctFont, kCTFontTableOptionNoOptions));
     CFIndex numTables = CFArrayGetCount(tableTags.get());
     for (CFIndex index = 0; index < numTables; ++index) {
         CTFontTableTag tag = (CTFontTableTag)(uintptr_t)CFArrayGetValueAtIndex(tableTags.get(), index);
         if (tag == kCTFontTableVhea || tag == kCTFontTableVORG)
             return true;
     }
@@ skipping 321 matching lines @@
 float SimpleFontData::platformWidthForGlyph(Glyph glyph) const
 {
     CGSize advance = CGSizeZero;
     if (platformData().orientation() == Horizontal || m_isBrokenIdeographFallback) {
         NSFont *font = platformData().font();
         if (font && platformData().isColorBitmapFont())
             advance = NSSizeToCGSize([font advancementForGlyph:glyph]);
         else {
             float pointSize = platformData().m_size;
             CGAffineTransform m = CGAffineTransformMakeScale(pointSize, pointSize);
-            if (!WKGetGlyphTransformedAdvances(platformData().cgFont(), font, &m, &glyph, &advance)) {
+            if (!CGFontGetGlyphAdvancesForStyle(platformData().cgFont(), &m, cgFontRenderingModeForNSFont(font), &glyph, 1, &advance)) {
                 LOG_ERROR("Unable to cache glyph widths for %@ %f", [font displayName], pointSize);
                 advance.width = 0;
             }
         }
     } else
         CTFontGetAdvancesForGlyphs(m_platformData.ctFont(), kCTFontVerticalOrientation, &glyph, &advance, 1);
 
     return advance.width + m_syntheticBoldOffset;
 }
 
@@ skipping 21 matching lines @@
     if (!m_combiningCharacterSequenceSupport)
         m_combiningCharacterSequenceSupport = adoptPtr(new HashMap<String, bool>);
 
     WTF::HashMap<String, bool>::AddResult addResult = m_combiningCharacterSequenceSupport->add(String(characters, length), false);
     if (!addResult.isNewEntry)
         return addResult.iterator->value;
 
     RetainPtr<CGFontRef> cgFont(AdoptCF, CTFontCopyGraphicsFont(platformData().ctFont(), 0));
 
     ProviderInfo info = { characters, length, getCFStringAttributes(0, platformData().orientation()) };
-    RetainPtr<CTLineRef> line(AdoptCF, WKCreateCTLineWithUniCharProvider(&provideStringAndAttributes, 0, &info));
+    RetainPtr<CTLineRef> line(AdoptCF, CTLineCreateWithUniCharProvider(&provideStringAndAttributes, 0, &info));
 
     CFArrayRef runArray = CTLineGetGlyphRuns(line.get());
     CFIndex runCount = CFArrayGetCount(runArray);
 
     for (CFIndex r = 0; r < runCount; r++) {
         CTRunRef ctRun = static_cast<CTRunRef>(CFArrayGetValueAtIndex(runArray, r));
         ASSERT(CFGetTypeID(ctRun) == CTRunGetTypeID());
         CFDictionaryRef runAttributes = CTRunGetAttributes(ctRun);
         CTFontRef runFont = static_cast<CTFontRef>(CFDictionaryGetValue(runAttributes, kCTFontAttributeName));
         RetainPtr<CGFontRef> runCGFont(AdoptCF, CTFontCopyGraphicsFont(runFont, 0));
         if (!CFEqual(runCGFont.get(), cgFont.get()))
             return false;
     }
 
     addResult.iterator->value = true;
     return true;
 }
 
 } // namespace WebCore