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 (m_regionList.isEmpty())

[mihnea, 2013/07/30 15:50:44]

I believe you want to add an assert here instead. In which situation do you call
this function with an empty region list?

[mstensho (USE GERRIT), 2013/07/31 13:09:37]

If you remove the last region, this list may be empty. But yes, the way the code
is right now, this method isn't even called then. I'm not sure. It's probably a
matter of taste. My idea was that this method should cope also when there are no
regions.

+        return;
+
+    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::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
@@ skipping 383 matching lines @@
                     lastEndNode = node;
                 }
             }
         }
         if (foundStartPosition || skipOverOutsideNodes)
             rangeObjects.append(range);
     }
 }
 
 }