Ignore style changes on text node flowthread descendants.

Source/core/layout/LayoutMultiColumnFlowThread.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 627 matching lines @@
         ASSERT(columnSetToRemove);
         ASSERT(!columnSetToRemove->nextSiblingMultiColumnSet());
     }
     ASSERT(columnSetToRemove);
     columnSetToRemove->destroy();
 }
 
 void LayoutMultiColumnFlowThread::flowThreadDescendantStyleWillChange(LayoutObject* descendant, StyleDifference diff, const ComputedStyle& newStyle)
 {
     // If an in-flow descendant goes out-of-flow, we may have to remove a column set.
+    if (descendant->isText()) {
+        // Text nodes inherit all properties from the parent node (including non-inheritable

[dsinclair, 2015/05/25 13:42:47]

Is the larger bug here that we inherit non-inheritable properties? Would the
correct fix to be to fix that?

[mstensho (USE GERRIT), 2015/05/25 18:25:13]

I've been thinking that doing something as crazy as text nodes inheriting all
properties from its parent served some important purpose, such as being able to
share the property data, to save memory. But maybe I'm wrong.

OK, let me try fixing that instead. There are some !isText() checks (or actually
!isTextOrSVGChild()) in LayoutObject::containingBlock() (and probably a bunch of
similar things throughout the code) related to this.

+        // ones). We don't care what its 'position' is. In fact, we _must_ ignore it, since the
+        // parent may be the multicol container, and having that accidentally leaked into children
+        // of the multicol is bad.
+        return;
+    }
     if (newStyle.hasOutOfFlowPosition() && !styleRef().hasOutOfFlowPosition())
         flowThreadDescendantWillBeRemoved(descendant);
 }
 
 void LayoutMultiColumnFlowThread::flowThreadDescendantStyleDidChange(LayoutObject* descendant, StyleDifference diff, const ComputedStyle& oldStyle)
 {
     // If an out-of-flow descendant goes in-flow, we may have to insert a column set.
+    if (descendant->isText()) {
+        // Text nodes inherit all properties from the parent node (including non-inheritable
+        // ones). We don't care what its 'position' is. In fact, we _must_ ignore it, since the
+        // parent may be the multicol container, and having that accidentally leaked into children
+        // of the multicol is bad.
+        return;
+    }
     if (oldStyle.hasOutOfFlowPosition() && !styleRef().hasOutOfFlowPosition())
         flowThreadDescendantWasInserted(descendant);
 }
 
 void LayoutMultiColumnFlowThread::computePreferredLogicalWidths()
 {
     LayoutFlowThread::computePreferredLogicalWidths();
 
     // The min/max intrinsic widths calculated really tell how much space elements need when
     // laid out inside the columns. In order to eventually end up with the desired column width,
@@ skipping 79 matching lines @@
 }
 
 bool LayoutMultiColumnFlowThread::isPageLogicalHeightKnown() const
 {
     if (LayoutMultiColumnSet* columnSet = lastMultiColumnSet())
         return columnSet->pageLogicalHeight();
     return false;
 }
 
 }