Move rendering/RenderObject to layout/LayoutObject.

Source/core/rendering/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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef TextAutosizer_h
 #define TextAutosizer_h
 
+#include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTable.h"
-#include "core/rendering/RenderObject.h"
 #include "platform/heap/Handle.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 
 namespace blink {
 
 class Document;
@@ skipping 158 matching lines @@
         "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 {
     public:
-        void add(const RenderObject*, Fingerprint);
+        void add(const LayoutObject*, Fingerprint);
         void addTentativeClusterRoot(const RenderBlock*, Fingerprint);
         // Returns true if any BlockSet was modified or freed by the removal.
-        bool remove(const RenderObject*);
-        Fingerprint get(const RenderObject*);
+        bool remove(const LayoutObject*);
+        Fingerprint get(const LayoutObject*);
         BlockSet* getTentativeClusterRoots(Fingerprint);
         bool hasFingerprints() const { return !m_fingerprints.isEmpty(); }
     private:
-        typedef HashMap<const RenderObject*, Fingerprint> FingerprintMap;
+        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 {
@@ skipping 13 matching lines @@
         bool m_pageNeedsAutosizing;
         bool m_hasAutosized;
         bool m_settingEnabled;
     };
 
     explicit TextAutosizer(const Document*);
 
     void beginLayout(RenderBlock*);
     void endLayout(RenderBlock*);
     void inflateAutoTable(LayoutTable*);
-    float inflate(RenderObject*, InflateBehavior = ThisBlockOnly, float multiplier = 0);
+    float inflate(LayoutObject*, InflateBehavior = ThisBlockOnly, float multiplier = 0);
     bool shouldHandleLayout() const;
     IntSize windowSize() const;
     void setAllTextNeedsLayout();
     void resetMultipliers();
     BeginLayoutBehavior prepareForLayout(const RenderBlock*);
-    void prepareClusterStack(const RenderObject*);
+    void prepareClusterStack(const LayoutObject*);
     bool clusterHasEnoughTextToAutosize(Cluster*, const RenderBlock* widthProvider = 0);
     bool superclusterHasEnoughTextToAutosize(Supercluster*, const RenderBlock* widthProvider = 0);
     bool clusterWouldHaveEnoughTextToAutosize(const RenderBlock* root, const RenderBlock* widthProvider = 0);
-    Fingerprint getFingerprint(const RenderObject*);
-    Fingerprint computeFingerprint(const RenderObject*);
+    Fingerprint getFingerprint(const LayoutObject*);
+    Fingerprint computeFingerprint(const LayoutObject*);
     Cluster* maybeCreateCluster(const RenderBlock*);
     Supercluster* getSupercluster(const RenderBlock*);
     float clusterMultiplier(Cluster*);
     float superclusterMultiplier(Cluster*);
     // A cluster's width provider is typically the deepest block containing all text.
     // There are exceptions, such as tables and table cells which use the table itself for width.
     const RenderBlock* clusterWidthProvider(const RenderBlock*) const;
     const RenderBlock* maxClusterWidthProvider(const Supercluster*, const RenderBlock* currentRoot) const;
     // Typically this returns a block's computed width. In the case of tables layout, this
     // width is not yet known so the fixed width is used if it's available, or the containing
     // block's width otherwise.
     float widthFromBlock(const RenderBlock*) const;
     float multiplierFromBlock(const RenderBlock*);
-    void applyMultiplier(RenderObject*, float, RelayoutBehavior = AlreadyInLayout);
+    void applyMultiplier(LayoutObject*, float, RelayoutBehavior = AlreadyInLayout);
     bool isWiderOrNarrowerDescendant(Cluster*);
     Cluster* currentCluster() const;
     const RenderBlock* deepestBlockContainingAllText(Cluster*);
     const RenderBlock* deepestBlockContainingAllText(const RenderBlock*) const;
     // Returns the first text leaf that is in the current cluster. We attempt to not include text
     // from descendant clusters but because descendant clusters may not exist, this is only an approximation.
     // The TraversalDirection controls whether we return the first or the last text leaf.
-    const RenderObject* findTextLeaf(const RenderObject*, size_t&, TextLeafSearch) const;
-    BlockFlags classifyBlock(const RenderObject*, BlockFlags mask = UINT_MAX) const;
+    const LayoutObject* findTextLeaf(const LayoutObject*, size_t&, TextLeafSearch) const;
+    BlockFlags classifyBlock(const LayoutObject*, BlockFlags mask = UINT_MAX) const;
 #ifdef AUTOSIZING_DOM_DEBUG_INFO
     void writeClusterDebugInfo(Cluster*);
 #endif
 
     RawPtrWillBeMember<const Document> m_document;
     const RenderBlock* m_firstBlockToBeginLayout;
 #if ENABLE(ASSERT)
     BlockSet m_blocksThatHaveBegunLayout; // Used to ensure we don't compute properties of a block before beginLayout() is called on it.
 #endif
 
     // Clusters are created and destroyed during layout. The map key is the
     // cluster root. Clusters whose roots share the same fingerprint use the
     // same multiplier.
     SuperclusterMap m_superclusters;
     ClusterStack m_clusterStack;
     FingerprintMapper m_fingerprintMapper;
     Vector<RefPtr<RenderStyle> > m_stylesRetainedDuringLayout;
     // FIXME: All frames should share the same m_pageInfo instance.
     PageInfo m_pageInfo;
     bool m_updatePageInfoDeferred;
 };
 
 } // namespace blink
 
 #endif // TextAutosizer_h