Use nullptr_t for RefPtr, PassRefPtr and RawPtr.

Source/core/css/CSSFontFaceSource.cpp

 /*
  * Copyright (C) 2007, 2008, 2010, 2011 Apple Inc. All rights reserved.
  *
  * 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 112 matching lines @@
 
     pruneTable();
     if (m_face)
         m_face->fontLoaded(this);
 }
 
 PassRefPtr<SimpleFontData> CSSFontFaceSource::getFontData(const FontDescription& fontDescription)
 {
     // If the font hasn't loaded or an error occurred, then we've got nothing.
     if (!isValid())
-        return 0;
+        return nullptr;
 
     if (isLocal()) {
         // We're local. Just return a SimpleFontData from the normal cache.
         // We don't want to check alternate font family names here, so pass true as the checkingAlternateName parameter.
         RefPtr<SimpleFontData> fontData = FontCache::fontCache()->getFontData(fontDescription, m_string, true);
         m_histograms.recordLocalFont(fontData);
         return fontData;
     }
 
     // See if we have a mapping in our FontData cache.
     AtomicString emptyFontFamily = "";
     FontCacheKey key = fontDescription.cacheKey(emptyFontFamily);
 
-    RefPtr<SimpleFontData>& fontData = m_fontDataTable.add(key.hash(), 0).storedValue->value;
+    RefPtr<SimpleFontData>& fontData = m_fontDataTable.add(key.hash(), nullptr).storedValue->value;
     if (fontData)
         return fontData; // No release, because fontData is a reference to a RefPtr that is held in the m_fontDataTable.
 
     // If we are still loading, then we let the system pick a font.
     if (isLoaded()) {
         if (m_font) {
 #if ENABLE(SVG_FONTS)
             if (m_hasExternalSVGFont) {
                 // For SVG fonts parse the external SVG document, and extract the <font> element.
                 if (!m_font->ensureSVGFontData())
-                    return 0;
+                    return nullptr;
 
                 if (!m_externalSVGFontElement) {
                     String fragmentIdentifier;
                     size_t start = m_string.find('#');
                     if (start != kNotFound)
                         fragmentIdentifier = m_string.string().substring(start + 1);
                     m_externalSVGFontElement = m_font->getSVGFontById(fragmentIdentifier);
                 }
 
                 if (!m_externalSVGFontElement)
-                    return 0;
+                    return nullptr;
 
                 SVGFontFaceElement* fontFaceElement = 0;
 
                 // Select first <font-face> child
                 for (Node* fontChild = m_externalSVGFontElement->firstChild(); fontChild; fontChild = fontChild->nextSibling()) {
                     if (fontChild->hasTagName(SVGNames::font_faceTag)) {
                         fontFaceElement = toSVGFontFaceElement(fontChild);
                         break;
                     }
                 }
 
                 if (fontFaceElement) {
                     if (!m_svgFontFaceElement) {
                         // We're created using a CSS @font-face rule, that means we're not associated with a SVGFontFaceElement.
                         // Use the imported <font-face> tag as referencing font-face element for these cases.
                         m_svgFontFaceElement = fontFaceElement;
                     }
 
                     fontData = SimpleFontData::create(
                         SVGFontData::create(fontFaceElement),
                         fontDescription.effectiveFontSize(),
                         fontDescription.isSyntheticBold(),
                         fontDescription.isSyntheticItalic());
                 }
             } else
 #endif
             {
                 // Create new FontPlatformData from our CGFontRef, point size and ATSFontRef.
                 if (!m_font->ensureCustomFontData())
-                    return 0;
+                    return nullptr;
 
                 fontData = SimpleFontData::create(
                     m_font->platformDataFromCustomData(fontDescription.effectiveFontSize(),
                         fontDescription.isSyntheticBold(), fontDescription.isSyntheticItalic(),
                         fontDescription.orientation(), fontDescription.widthVariant()), CustomFontData::create(false));
             }
         } else {
 #if ENABLE(SVG_FONTS)
             // In-Document SVG Fonts
             if (m_svgFontFaceElement) {
                 fontData = SimpleFontData::create(
                     SVGFontData::create(m_svgFontFaceElement.get()),
                     fontDescription.effectiveFontSize(),
                     fontDescription.isSyntheticBold(),
                     fontDescription.isSyntheticItalic());
             }
 #endif
         }
     } else {
         // This temporary font is not retained and should not be returned.
         FontCachePurgePreventer fontCachePurgePreventer;
         SimpleFontData* temporaryFont = FontCache::fontCache()->getNonRetainedLastResortFallbackFont(fontDescription);
         if (!temporaryFont) {
             ASSERT_NOT_REACHED();
-            return 0;
+            return nullptr;
         }
         RefPtr<CSSCustomFontData> cssFontData = CSSCustomFontData::create(true);
         cssFontData->setCSSFontFaceSource(this);
         fontData = SimpleFontData::create(temporaryFont->platformData(), cssFontData);
     }
 
     return fontData; // No release, because fontData is a reference to a RefPtr that is held in the m_fontDataTable.
 }
 
 #if ENABLE(SVG_FONTS)
@@ skipping 77 matching lines @@
     if (size < 50 * 1024)
         return "WebFont.DownloadTime.1.10KBTo50KB";
     if (size < 100 * 1024)
         return "WebFont.DownloadTime.2.50KBTo100KB";
     if (size < 1024 * 1024)
         return "WebFont.DownloadTime.3.100KBTo1MB";
     return "WebFont.DownloadTime.4.Over1MB";
 }
 
 }