Propagate writing-mode from the first region to the flow thread.

Source/core/rendering/RenderNamedFlowThread.cpp

 /*
  * Copyright (C) 2012 Apple 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 72 matching lines @@
         ASSERT(contentNode && contentNode->isElementNode());
         ASSERT(contentNode->inNamedFlow());
         ASSERT(contentNode->document() == document());
 
         contentNode->clearInNamedFlow();
     }
 
     m_contentNodes.clear();
 }
 
+void RenderNamedFlowThread::updateWritingMode()
+{
+    if (RenderRegion* firstRegion = m_regionList.first()) {
+        if (style()->writingMode() != firstRegion->style()->writingMode()) {
+            // The first region defines the principal writing mode for the entire flow.
+            RefPtr<RenderStyle> newStyle = RenderStyle::clone(style());
+            newStyle->setWritingMode(firstRegion->style()->writingMode());
+            setStyle(newStyle);
+        }
+    }
+}
+
 RenderObject* RenderNamedFlowThread::nextRendererForNode(Node* node) const
 {
     FlowThreadChildList::const_iterator it = m_flowThreadChildList.begin();
     FlowThreadChildList::const_iterator end = m_flowThreadChildList.end();
 
     for (; it != end; ++it) {
         RenderObject* child = *it;
         ASSERT(child->node());
         unsigned short position = node->compareDocumentPosition(child->node());
         if (position & Node::DOCUMENT_POSITION_FOLLOWING)
@@ skipping 134 matching lines @@
 void RenderNamedFlowThread::addRegionToNamedFlowThread(RenderRegion* renderRegion)
 {
     ASSERT(renderRegion);
     ASSERT(!renderRegion->isValid());
 
     if (renderRegion->parentNamedFlowThread())
         addDependencyOnFlowThread(renderRegion->parentNamedFlowThread());
 
     renderRegion->setIsValid(true);
     addRegionToList(m_regionList, renderRegion);
+
+    if (m_regionList.first() == renderRegion)
+        updateWritingMode();
 }
 
 void RenderNamedFlowThread::addRegionToThread(RenderRegion* renderRegion)
 {
     ASSERT(renderRegion);
     ASSERT(!renderRegion->isValid());
 
     resetMarkForDestruction();
 
     if (renderRegion->parentNamedFlowThread() && renderRegion->parentNamedFlowThread()->dependsOn(this)) {
@@ skipping 19 matching lines @@
             m_invalidRegionList.remove(renderRegion);
             renderRegion->parentNamedFlowThread()->m_observerThreadsSet.remove(this);
             // No need to invalidate the regions rectangles. The removed region
             // was not taken into account. Just return here.
             return;
         }
         removeDependencyOnFlowThread(renderRegion->parentNamedFlowThread());
     }
 
     ASSERT(m_regionList.contains(renderRegion));
+    bool wasFirst = m_regionList.first() == renderRegion;
     m_regionList.remove(renderRegion);
 
     if (canBeDestroyed())
         setMarkForDestruction();
 
     // After removing all the regions in the flow the following layout needs to dispatch the regionLayoutUpdate event
     if (m_regionList.isEmpty())
         setDispatchRegionLayoutUpdateEvent(true);
+    else if (wasFirst)
+        updateWritingMode();
 
     invalidateRegions();
 }
 
+void RenderNamedFlowThread::regionChangedWritingMode(RenderRegion* region)
+{
+    if (m_regionList.first() == region)
+        updateWritingMode();
+}
+
 void RenderNamedFlowThread::computeOversetStateForRegions(LayoutUnit oldClientAfterEdge)
 {
     LayoutUnit height = oldClientAfterEdge;
 
     // FIXME: the visual overflow of middle region (if it is the last one to contain any content in a render flow thread)
     // might not be taken into account because the render flow thread height is greater that that regions height + its visual overflow
     // because of how computeLogicalHeight is implemented for RenderFlowThread (as a sum of all regions height).
     // This means that the middle region will be marked as fit (even if it has visual overflow flowing into the next region)
     if (hasRenderOverflow()
         && ( (isHorizontalWritingMode() && visualOverflowRect().maxY() > clientBoxRect().maxY())
@@ skipping 379 matching lines @@
                     lastEndNode = node;
                 }
             }
         }
         if (foundStartPosition || skipOverOutsideNodes)
             rangeObjects.append(range);
     }
 }
 
 }