Move rendering/RenderObject to layout/LayoutObject.

Source/core/layout/BidiRunForLine.cpp

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc.
  * All right reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 15 matching lines @@
 
 #include "config.h"
 #include "core/layout/BidiRunForLine.h"
 
 #include "core/layout/line/InlineIterator.h"
 
 namespace blink {
 
 using namespace WTF::Unicode;
 
-static RenderObject* firstRenderObjectForDirectionalityDetermination(
-    RenderObject* root, RenderObject* current = 0)
+static LayoutObject* firstLayoutObjectForDirectionalityDetermination(
+    LayoutObject* root, LayoutObject* current = 0)
 {
-    RenderObject* next = current;
+    LayoutObject* next = current;
     while (current) {
         if (isIsolated(current->style()->unicodeBidi())
             && (current->isRenderInline() || current->isRenderBlock())) {
             if (current != root)
                 current = 0;
             else
                 current = next;
             break;
         }
         current = current->parent();
@@ skipping 23 matching lines @@
 
         if (!next)
             break;
 
         current = next;
     }
 
     return current;
 }
 
-TextDirection determinePlaintextDirectionality(RenderObject* root,
-    RenderObject* current = 0, unsigned pos = 0)
+TextDirection determinePlaintextDirectionality(LayoutObject* root,
+    LayoutObject* current = 0, unsigned pos = 0)
 {
-    RenderObject* firstRenderObject = firstRenderObjectForDirectionalityDetermination(root, current);
-    InlineIterator iter(root, firstRenderObject, firstRenderObject == current ? pos : 0);
+    LayoutObject* firstLayoutObject = firstLayoutObjectForDirectionalityDetermination(root, current);
+    InlineIterator iter(root, firstLayoutObject, firstLayoutObject == current ? pos : 0);
     InlineBidiResolver observer;
     observer.setStatus(BidiStatus(root->style()->direction(),
         isOverride(root->style()->unicodeBidi())));
     observer.setPositionIgnoringNestedIsolates(iter);
     return observer.determineParagraphDirectionality();
 }
 
 // FIXME: This should be a BidiStatus constructor or create method.
 static inline BidiStatus statusWithDirection(TextDirection textDirection,
     bool isOverride)
 {
     WTF::Unicode::Direction direction = textDirection == LTR
         ? LeftToRight
         : RightToLeft;
     RefPtr<BidiContext> context = BidiContext::create(
         textDirection == LTR ? 0 : 1, direction, isOverride, FromStyleOrDOM);
 
     // This copies BidiStatus and may churn the ref on BidiContext.
     // I doubt it matters.
     return BidiStatus(direction, direction, direction, context.release());
 }
 
 static inline void setupResolverToResumeInIsolate(InlineBidiResolver& resolver,
-    RenderObject* root, RenderObject* startObject)
+    LayoutObject* root, LayoutObject* startObject)
 {
     if (root != startObject) {
-        RenderObject* parent = startObject->parent();
+        LayoutObject* parent = startObject->parent();
         setupResolverToResumeInIsolate(resolver, root, parent);
         notifyObserverEnteredObject(&resolver, startObject);
     }
 }
 
 static void restoreIsolatedMidpointStates(InlineBidiResolver& topResolver,
     InlineBidiResolver& isolatedResolver)
 {
     while (!isolatedResolver.isolatedRuns().isEmpty()) {
         BidiRun* run = isolatedResolver.isolatedRuns().last();
         isolatedResolver.isolatedRuns().removeLast();
         topResolver.setMidpointStateForIsolatedRun(run,
             isolatedResolver.midpointStateForIsolatedRun(run));
     }
 }
 
 void constructBidiRunsForLine(InlineBidiResolver& topResolver,
     BidiRunList<BidiRun>& bidiRuns, const InlineIterator& endOfLine,
     VisualDirectionOverride override, bool previousLineBrokeCleanly,
     bool isNewUBAParagraph)
 {
     // FIXME: We should pass a BidiRunList into createBidiRunsForLine instead
     // of the resolver owning the runs.
     ASSERT(&topResolver.runs() == &bidiRuns);
     ASSERT(topResolver.position() != endOfLine);
-    RenderObject* currentRoot = topResolver.position().root();
+    LayoutObject* currentRoot = topResolver.position().root();
     topResolver.createBidiRunsForLine(endOfLine, override,
         previousLineBrokeCleanly);
 
     while (!topResolver.isolatedRuns().isEmpty()) {
         // It does not matter which order we resolve the runs as long as we
         // resolve them all.
         BidiRun* isolatedRun = topResolver.isolatedRuns().last();
         topResolver.isolatedRuns().removeLast();
 
-        RenderObject* startObj = isolatedRun->object();
+        LayoutObject* startObj = isolatedRun->object();
 
         // Only inlines make sense with unicode-bidi: isolate (blocks are
         // already isolated).
-        // FIXME: Because enterIsolate is not passed a RenderObject, we have to
+        // FIXME: Because enterIsolate is not passed a LayoutObject, we have to
         // crawl up the tree to see which parent inline is the isolate. We could
-        // change enterIsolate to take a RenderObject and do this logic there,
+        // change enterIsolate to take a LayoutObject and do this logic there,
         // but that would be a layering violation for BidiResolver (which knows
-        // nothing about RenderObject).
+        // nothing about LayoutObject).
         RenderInline* isolatedInline = toRenderInline(
             highestContainingIsolateWithinRoot(startObj, currentRoot));
         ASSERT(isolatedInline);
 
         InlineBidiResolver isolatedResolver;
         LineMidpointState& isolatedLineMidpointState =
             isolatedResolver.midpointState();
         isolatedLineMidpointState = topResolver.midpointStateForIsolatedRun(
             isolatedRun);
         EUnicodeBidi unicodeBidi = isolatedInline->style()->unicodeBidi();
@@ skipping 37 matching lines @@
                 isolatedResolver.isolatedRuns());
             currentRoot = isolatedInline;
             restoreIsolatedMidpointStates(topResolver, isolatedResolver);
         }
     }
 }
 
 } // namespace blink
 
 #endif // BidiRunForLine_h