Make classes and structures in core/layout fast-allocated.

Source/core/layout/TextAutosizer.h

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 34 matching lines @@
 
 class Document;
 class LayoutListItem;
 class LayoutListMarker;
 class LayoutBlock;
 
 // Single-pass text autosizer. Documentation at:
 // http://tinyurl.com/TextAutosizer
 
 class CORE_EXPORT TextAutosizer final : public NoBaseWillBeGarbageCollectedFinalized<TextAutosizer> {
+    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(TextAutosizer);
     WTF_MAKE_NONCOPYABLE(TextAutosizer);
 public:
     static PassOwnPtrWillBeRawPtr<TextAutosizer> create(const Document* document)
     {
         return adoptPtrWillBeNoop(new TextAutosizer(document));
     }
     static float computeAutosizedFontSize(float specifiedSize, float multiplier);
 
     void updatePageInfoInAllFrames();
     void updatePageInfo();
     void record(const LayoutBlock*);
     void destroy(const LayoutBlock*);
 
     bool pageNeedsAutosizing() const;
 
     DECLARE_TRACE();
 
     class LayoutScope {
         STACK_ALLOCATED();
     public:
         explicit LayoutScope(LayoutBlock*);
         ~LayoutScope();
     protected:
         RawPtrWillBeMember<TextAutosizer> m_textAutosizer;
         LayoutBlock* m_block;
     };
 
     class TableLayoutScope : LayoutScope {
+        STACK_ALLOCATED();
     public:
         explicit TableLayoutScope(LayoutTable*);
     };
 
     class CORE_EXPORT DeferUpdatePageInfo {
         STACK_ALLOCATED();
     public:
         explicit DeferUpdatePageInfo(Page*);
         ~DeferUpdatePageInfo();
     private:
@@ skipping 38 matching lines @@
         SUPPRESSING = 1 << 4
     };
 
     typedef unsigned BlockFlags;
 
     // A supercluster represents autosizing information about a set of two or
     // more blocks that all have the same fingerprint. Clusters whose roots
     // belong to a supercluster will share a common multiplier and
     // text-length-based autosizing status.
     struct Supercluster {
+        WTF_MAKE_FAST_ALLOCATED(Supercluster);
+    public:
         explicit Supercluster(const BlockSet* roots)
             : m_roots(roots)
             , m_hasEnoughTextToAutosize(UnknownAmountOfText)
             , m_multiplier(0)
         {
         }
 
         const BlockSet* const m_roots;
         HasEnoughTextToAutosize m_hasEnoughTextToAutosize;
         float m_multiplier;
     };
 
     struct Cluster {
+        WTF_MAKE_FAST_ALLOCATED(Cluster);
+    public:
         explicit Cluster(const LayoutBlock* root, BlockFlags flags, Cluster* parent, Supercluster* supercluster = nullptr)
             : m_root(root)
             , m_flags(flags)
             , m_deepestBlockContainingAllText(nullptr)
             , m_parent(parent)
             , m_multiplier(0)
             , m_hasEnoughTextToAutosize(UnknownAmountOfText)
             , m_supercluster(supercluster)
             , m_hasTableAncestor(root->isTableCell() || (m_parent && m_parent->m_hasTableAncestor))
         {
@@ skipping 15 matching lines @@
         Supercluster* m_supercluster;
         bool m_hasTableAncestor;
     };
 
     enum TextLeafSearch {
         First,
         Last
     };
 
     struct FingerprintSourceData {
+        STACK_ALLOCATED();
         FingerprintSourceData()
             : m_parentHash(0)
             , m_qualifiedNameHash(0)
             , m_packedStyleProperties(0)
             , m_column(0)
             , m_width(0)
         {
         }
 
         unsigned m_parentHash;
         unsigned m_qualifiedNameHash;
         // Style specific selection of signals
         unsigned m_packedStyleProperties;
         unsigned m_column;
         float m_width;
     };
     // Ensures efficient hashing using StringHasher.
     static_assert(!(sizeof(FingerprintSourceData) % sizeof(UChar)),
         "sizeof(FingerprintSourceData) must be a multiple of UChar");
 
     typedef unsigned Fingerprint;
     typedef HashMap<Fingerprint, OwnPtr<Supercluster>> SuperclusterMap;
     typedef Vector<OwnPtr<Cluster>> ClusterStack;
 
     // Fingerprints are computed during style recalc, for (some subset of)
     // blocks that will become cluster roots.
     class FingerprintMapper {
+        DISALLOW_ALLOCATION();
     public:
         void add(const LayoutObject*, Fingerprint);
         void addTentativeClusterRoot(const LayoutBlock*, Fingerprint);
         // Returns true if any BlockSet was modified or freed by the removal.
         bool remove(const LayoutObject*);
         Fingerprint get(const LayoutObject*);
         BlockSet* getTentativeClusterRoots(Fingerprint);
         bool hasFingerprints() const { return !m_fingerprints.isEmpty(); }
     private:
         typedef HashMap<const LayoutObject*, Fingerprint> FingerprintMap;
         typedef HashMap<Fingerprint, OwnPtr<BlockSet>> ReverseFingerprintMap;
 
         FingerprintMap m_fingerprints;
         ReverseFingerprintMap m_blocksForFingerprint;
 #if ENABLE(ASSERT)
         void assertMapsAreConsistent();
 #endif
     };
 
     struct PageInfo {
+        DISALLOW_ALLOCATION();
         PageInfo()
             : m_frameWidth(0)
             , m_layoutWidth(0)
             , m_baseMultiplier(0)
             , m_pageNeedsAutosizing(false)
             , m_hasAutosized(false)
             , m_settingEnabled(false)
         {
         }
 
@@ skipping 63 matching lines @@
     FingerprintMapper m_fingerprintMapper;
     Vector<RefPtr<ComputedStyle>> m_stylesRetainedDuringLayout;
     // FIXME: All frames should share the same m_pageInfo instance.
     PageInfo m_pageInfo;
     bool m_updatePageInfoDeferred;
 };
 
 } // namespace blink
 
 #endif // TextAutosizer_h