Make platform/graphics to use USING_FAST_MALLOC.

third_party/WebKit/Source/platform/graphics/ImageDecodingStore.h

 /*
  * Copyright (C) 2012 Google 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 43 matching lines @@
 //
 // ImageFrameGenerator
 //   This is a direct user of this cache. Responsible for generating bitmap images
 //   using an ImageDecoder. It contains encoded image data and is used to represent
 //   one image file. It is used to index image and decoder objects in the cache.
 //
 // THREAD SAFETY
 //
 // All public methods can be used on any thread.
 
-class PLATFORM_EXPORT ImageDecodingStore {
+class PLATFORM_EXPORT ImageDecodingStore final {
+    USING_FAST_MALLOC(ImageDecodingStore);
+    WTF_MAKE_NONCOPYABLE(ImageDecodingStore);
 public:
     static PassOwnPtr<ImageDecodingStore> create() { return adoptPtr(new ImageDecodingStore); }
     ~ImageDecodingStore();
 
     static ImageDecodingStore& instance();
 
     // Access a cached decoder object. A decoder is indexed by origin (ImageFrameGenerator)
     // and scaled size. Return true if the cached object is found.
     bool lockDecoder(const ImageFrameGenerator*, const SkISize& scaledSize, ImageDecoder**);
     void unlockDecoder(const ImageFrameGenerator*, const ImageDecoder*);
@@ skipping 10 matching lines @@
     int decoderCacheEntries();
 
 private:
     // Decoder cache entry is identified by:
     // 1. Pointer to ImageFrameGenerator.
     // 2. Size of the image.
     typedef std::pair<const ImageFrameGenerator*, SkISize> DecoderCacheKey;
 
     // Base class for all cache entries.
     class CacheEntry : public DoublyLinkedListNode<CacheEntry> {
+        USING_FAST_MALLOC(CacheEntry);
+        WTF_MAKE_NONCOPYABLE(CacheEntry);
         friend class WTF::DoublyLinkedListNode<CacheEntry>;
     public:
         enum CacheType {
             TypeDecoder,
         };
 
         CacheEntry(const ImageFrameGenerator* generator, int useCount)
             : m_generator(generator)
             , m_useCount(useCount)
             , m_prev(0)
@@ skipping 101 matching lines @@
 
     // Protect concurrent access to these members:
     //   m_orderedCacheList
     //   m_decoderCacheMap and all CacheEntrys stored in it
     //   m_decoderCacheKeyMap
     //   m_heapLimitInBytes
     //   m_heapMemoryUsageInBytes
     // This mutex also protects calls to underlying skBitmap's
     // lockPixels()/unlockPixels() as they are not threadsafe.
     Mutex m_mutex;
+
+#if COMPILER(MSVC)
+    friend struct ::WTF::OwnedPtrDeleter<CacheEntry>;
+    friend struct ::WTF::OwnedPtrDeleter<DecoderCacheEntry>;
+#endif
 };
 
 } // namespace blink
 
 #endif