Remove OwnPtr from Blink.

third_party/WebKit/Source/platform/fonts/FontCache.cpp

 /*
  * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  *
  * 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.
@@ skipping 32 matching lines @@
 #include "platform/fonts/FontSmoothingMode.h"
 #include "platform/fonts/SimpleFontData.h"
 #include "platform/fonts/TextRenderingMode.h"
 #include "platform/fonts/opentype/OpenTypeVerticalData.h"
 #include "platform/fonts/shaping/ShapeCache.h"
 #include "platform/web_memory_allocator_dump.h"
 #include "platform/web_process_memory_dump.h"
 #include "public/platform/Platform.h"
 #include "wtf/HashMap.h"
 #include "wtf/ListHashSet.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
 #include "wtf/text/AtomicStringHash.h"
 #include "wtf/text/StringHash.h"
+#include <memory>
 
 using namespace WTF;
 
 namespace blink {
 
 #if !OS(WIN) && !OS(LINUX)
 FontCache::FontCache()
     : m_purgePreventCount(0)
     , m_fontManager(nullptr)
 {
 }
 #endif // !OS(WIN) && !OS(LINUX)
 
-typedef HashMap<unsigned, OwnPtr<FontPlatformData>, WTF::IntHash<unsigned>, WTF::UnsignedWithZeroKeyHashTraits<unsigned>> SizedFontPlatformDataSet;
+typedef HashMap<unsigned, std::unique_ptr<FontPlatformData>, WTF::IntHash<unsigned>, WTF::UnsignedWithZeroKeyHashTraits<unsigned>> SizedFontPlatformDataSet;
 typedef HashMap<FontCacheKey, SizedFontPlatformDataSet, FontCacheKeyHash, FontCacheKeyTraits> FontPlatformDataCache;
-typedef HashMap<FallbackListCompositeKey, OwnPtr<ShapeCache>, FallbackListCompositeKeyHash, FallbackListCompositeKeyTraits> FallbackListShaperCache;
+typedef HashMap<FallbackListCompositeKey, std::unique_ptr<ShapeCache>, FallbackListCompositeKeyHash, FallbackListCompositeKeyTraits> FallbackListShaperCache;
 
 static FontPlatformDataCache* gFontPlatformDataCache = nullptr;
 static FallbackListShaperCache* gFallbackListShaperCache = nullptr;
 
 SkFontMgr* FontCache::s_fontManager = nullptr;
 
 #if OS(WIN)
 bool FontCache::s_antialiasedTextEnabled = false;
 bool FontCache::s_lcdTextEnabled = false;
 float FontCache::s_deviceScaleFactor = 1.0;
@@ skipping 28 matching lines @@
 
     {
         // addResult's scope must end before we recurse for alternate family names below,
         // to avoid trigering its dtor hash-changed asserts.
         SizedFontPlatformDataSet* sizedFonts = &gFontPlatformDataCache->add(key, SizedFontPlatformDataSet()).storedValue->value;
         bool wasEmpty = sizedFonts->isEmpty();
 
         // Take a different size instance of the same font before adding an entry to |sizedFont|.
         FontPlatformData* anotherSize = wasEmpty ? nullptr : sizedFonts->begin()->value.get();
         auto addResult = sizedFonts->add(roundedSize, nullptr);
-        OwnPtr<FontPlatformData>* found = &addResult.storedValue->value;
+        std::unique_ptr<FontPlatformData>* found = &addResult.storedValue->value;
         if (addResult.isNewEntry) {
             if (wasEmpty)
                 *found = createFontPlatformData(fontDescription, creationParams, size);
             else if (anotherSize)
                 *found = scaleFontPlatformData(*anotherSize, fontDescription, creationParams, size);
         }
 
         result = found->get();
         foundResult = result || !addResult.isNewEntry;
     }
 
     if (!foundResult && !checkingAlternateName && creationParams.creationType() == CreateFontByFamily) {
         // We were unable to find a font. We have a small set of fonts that we alias to other names,
         // e.g., Arial/Helvetica, Courier/Courier New, etc. Try looking up the font under the aliased name.
         const AtomicString& alternateName = alternateFamilyName(creationParams.family());
         if (!alternateName.isEmpty()) {
             FontFaceCreationParams createByAlternateFamily(alternateName);
             result = getFontPlatformData(fontDescription, createByAlternateFamily, true);
         }
         if (result) {
             // Cache the result under the old name.
             auto adding = &gFontPlatformDataCache->add(key, SizedFontPlatformDataSet()).storedValue->value;
-            adding->set(roundedSize, adoptPtr(new FontPlatformData(*result)));
+            adding->set(roundedSize, wrapUnique(new FontPlatformData(*result)));
         }
     }
 
     return result;
 }
 
-PassOwnPtr<FontPlatformData> FontCache::scaleFontPlatformData(const FontPlatformData& fontPlatformData, const FontDescription& fontDescription, const FontFaceCreationParams& creationParams, float fontSize)
+std::unique_ptr<FontPlatformData> FontCache::scaleFontPlatformData(const FontPlatformData& fontPlatformData, const FontDescription& fontDescription, const FontFaceCreationParams& creationParams, float fontSize)
 {
 #if OS(MACOSX)
     return createFontPlatformData(fontDescription, creationParams, fontSize);
 #else
-    return adoptPtr(new FontPlatformData(fontPlatformData, fontSize));
+    return wrapUnique(new FontPlatformData(fontPlatformData, fontSize));
 #endif
 }
 
 ShapeCache* FontCache::getShapeCache(const FallbackListCompositeKey& key)
 {
     if (!gFallbackListShaperCache)
         gFallbackListShaperCache = new FallbackListShaperCache;
 
     FallbackListShaperCache::iterator it = gFallbackListShaperCache->find(key);
     ShapeCache* result = nullptr;
     if (it == gFallbackListShaperCache->end()) {
         result = new ShapeCache();
-        gFallbackListShaperCache->set(key, adoptPtr(result));
+        gFallbackListShaperCache->set(key, wrapUnique(result));
     } else {
         result = it->value.get();
     }
 
     ASSERT(result);
     return result;
 }
 
 typedef HashMap<FontCache::FontFileKey, RefPtr<OpenTypeVerticalData>, IntHash<FontCache::FontFileKey>, UnsignedWithZeroKeyHashTraits<FontCache::FontFileKey>> FontVerticalDataCache;
 
@@ skipping 240 matching lines @@
     case USCRIPT_SIMPLIFIED_HAN:
         return "zh-Hans";
     case USCRIPT_TRADITIONAL_HAN:
         return "zh-Hant";
     default:
         return locale.ascii();
     }
 }
 
 } // namespace blink