*** NOT FOR LANDING *** Text nodes should only inherit inheritable properties.

Source/core/layout/LayoutObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 742 matching lines @@
 
     while (object) {
         if (object->selfNeedsLayout())
             return;
 
         // Don't mark the outermost object of an unrooted subtree. That object will be
         // marked when the subtree is added to the document.
         LayoutObject* container = object->container();
         if (!container && !object->isLayoutView())
             return;
-        if (!last->isTextOrSVGChild() && last->style()->hasOutOfFlowPosition()) {
+        if (!last->isSVGChild() && last->style()->hasOutOfFlowPosition()) {
             bool willSkipRelativelyPositionedInlines = !object->isLayoutBlock() || object->isAnonymousBlock();
             // Skip relatively positioned inlines and anonymous blocks to get to the enclosing LayoutBlock.
             while (object && (!object->isLayoutBlock() || object->isAnonymousBlock()))
                 object = object->container();
             if (!object || object->posChildNeedsLayout())
                 return;
             if (willSkipRelativelyPositionedInlines)
                 container = object->container();
             object->setPosChildNeedsLayout(true);
             simplifiedNormalFlowLayout = true;
@@ skipping 35 matching lines @@
     ASSERT(!needsLayout());
 
     if (isLayoutBlock())
         toLayoutBlock(this)->checkPositionedObjectsNeedLayout();
 }
 #endif
 
 void LayoutObject::setPreferredLogicalWidthsDirty(MarkingBehavior markParents)
 {
     m_bitfields.setPreferredLogicalWidthsDirty(true);
-    if (markParents == MarkContainerChain && (isText() || !style()->hasOutOfFlowPosition()))
+    if (markParents == MarkContainerChain && !style()->hasOutOfFlowPosition())
         invalidateContainerPreferredLogicalWidths();
 }
 
 void LayoutObject::clearPreferredLogicalWidthsDirty()
 {
     m_bitfields.setPreferredLogicalWidthsDirty(false);
 }
 
 inline void LayoutObject::invalidateContainerPreferredLogicalWidths()
 {
@@ skipping 13 matching lines @@
             // We can optimize this case and not go up any further.
             break;
         }
         o = container;
     }
 }
 
 LayoutBlock* LayoutObject::containerForFixedPosition(const LayoutBoxModelObject* paintInvalidationContainer, bool* paintInvalidationContainerSkipped) const
 {
     ASSERT(!paintInvalidationContainerSkipped || !*paintInvalidationContainerSkipped);
-    ASSERT(!isText());
     ASSERT(style()->position() == FixedPosition);
 
     LayoutObject* ancestor = parent();
     for (; ancestor && !ancestor->canContainFixedPositionObjects(); ancestor = ancestor->parent()) {
         if (paintInvalidationContainerSkipped && ancestor == paintInvalidationContainer)
             *paintInvalidationContainerSkipped = true;
     }
 
     ASSERT(!ancestor || !ancestor->isAnonymousBlock());
     return toLayoutBlock(ancestor);
 }
 
 LayoutBlock* LayoutObject::containingBlock() const
 {
     LayoutObject* o = parent();
     if (!o && isLayoutScrollbarPart())
         o = toLayoutScrollbarPart(this)->layoutObjectOwningScrollbar();
-    if (!isTextOrSVGChild() && m_style->position() == FixedPosition)
+    if (!isSVGChild() && m_style->position() == FixedPosition)
         return containerForFixedPosition();
-    if (!isTextOrSVGChild() && m_style->position() == AbsolutePosition) {
+    if (!isSVGChild() && m_style->position() == AbsolutePosition) {
         while (o) {
             // For relpositioned inlines, we return the nearest non-anonymous enclosing block. We don't try
             // to return the inline itself.  This allows us to avoid having a positioned objects
             // list in all LayoutInlines and lets us return a strongly-typed LayoutBlock* result
             // from this method.  The container() method can actually be used to obtain the
             // inline directly.
             if (o->style()->position() != StaticPosition && (!o->isInline() || o->isReplaced()))
                 break;
 
             if (o->canContainFixedPositionObjects())
@@ skipping 689 matching lines @@
 bool LayoutObject::isSelectable() const
 {
     return !isInert() && !(style()->userSelect() == SELECT_NONE && style()->userModify() == READ_ONLY);
 }
 
 Color LayoutObject::selectionBackgroundColor() const
 {
     if (!isSelectable())
         return Color::transparent;
 
+    if ((!node() || node()->isTextNode()) && parent())
+        return parent()->selectionBackgroundColor();
     if (RefPtr<ComputedStyle> pseudoStyle = getUncachedPseudoStyleFromParentOrShadowHost())
         return resolveColor(*pseudoStyle, CSSPropertyBackgroundColor).blendWithWhite();
     return frame()->selection().isFocusedAndActive() ?
         LayoutTheme::theme().activeSelectionBackgroundColor() :
         LayoutTheme::theme().inactiveSelectionBackgroundColor();
 }
 
 Color LayoutObject::selectionColor(int colorProperty) const
 {
     // If the element is unselectable, or we are only painting the selection,
     // don't override the foreground color with the selection foreground color.
     if (!isSelectable() || (frame()->view()->paintBehavior() & PaintBehaviorSelectionOnly))
         return resolveColor(colorProperty);
 
+    if ((!node() || node()->isTextNode()) && parent())
+        return parent()->selectionColor(colorProperty);
     if (RefPtr<ComputedStyle> pseudoStyle = getUncachedPseudoStyleFromParentOrShadowHost())
         return resolveColor(*pseudoStyle, colorProperty);
     if (!LayoutTheme::theme().supportsSelectionForegroundColors())
         return resolveColor(colorProperty);
     return frame()->selection().isFocusedAndActive() ?
         LayoutTheme::theme().activeSelectionForegroundColor() :
         LayoutTheme::theme().inactiveSelectionForegroundColor();
 }
 
 Color LayoutObject::selectionForegroundColor() const
@@ skipping 33 matching lines @@
     }
 }
 
 StyleDifference LayoutObject::adjustStyleDifference(StyleDifference diff) const
 {
     if (diff.transformChanged() && isSVG())
         diff.setNeedsFullLayout();
 
     // If transform changed, and the layer does not paint into its own separate backing, then we need to invalidate paints.
     if (diff.transformChanged()) {
-        // Text nodes share style with their parents but transforms don't apply to them,
-        // hence the !isText() check.
-        if (!isText() && (!hasLayer() || !toLayoutBoxModelObject(this)->layer()->hasStyleDeterminedDirectCompositingReasons()))
+        if (!hasLayer() || !toLayoutBoxModelObject(this)->layer()->hasStyleDeterminedDirectCompositingReasons())
             diff.setNeedsPaintInvalidationLayer();
     }
 
     // If opacity or zIndex changed, and the layer does not paint into its own separate backing, then we need to invalidate paints (also
     // ignoring text nodes)
     if (diff.opacityChanged() || diff.zIndexChanged()) {
-        if (!isText() && (!hasLayer() || !toLayoutBoxModelObject(this)->layer()->hasStyleDeterminedDirectCompositingReasons()))
+        if (!hasLayer() || !toLayoutBoxModelObject(this)->layer()->hasStyleDeterminedDirectCompositingReasons())
             diff.setNeedsPaintInvalidationLayer();
     }
 
     // If filter changed, and the layer does not paint into its own separate backing or it paints with filters, then we need to invalidate paints.
     if (diff.filterChanged() && hasLayer()) {
         DeprecatedPaintLayer* layer = toLayoutBoxModelObject(this)->layer();
         if (!layer->hasStyleDeterminedDirectCompositingReasons() || layer->paintsWithFilters())
             diff.setNeedsPaintInvalidationLayer();
     }
 
@@ skipping 17 matching lines @@
         diff.clearNeedsPaintInvalidation();
         diff.setNeedsPaintInvalidationObject();
     }
 
     return diff;
 }
 
 void LayoutObject::setPseudoStyle(PassRefPtr<ComputedStyle> pseudoStyle)
 {
     ASSERT(pseudoStyle->styleType() == BEFORE || pseudoStyle->styleType() == AFTER || pseudoStyle->styleType() == FIRST_LETTER);
-
-    // FIXME: We should consider just making all pseudo items use an inherited style.
-
-    // Images are special and must inherit the pseudoStyle so the width and height of
-    // the pseudo element doesn't change the size of the image. In all other cases we
-    // can just share the style.
-    //
-    // Quotes are also LayoutInline, so we need to create an inherited style to avoid
-    // getting an inline with positioning or an invalid display.
-    //
-    if (isImage() || isQuote()) {
-        RefPtr<ComputedStyle> style = ComputedStyle::create();
-        style->inheritFrom(*pseudoStyle);
-        setStyle(style.release());
-        return;
-    }
-
-    setStyle(pseudoStyle);
+    RefPtr<ComputedStyle> style = ComputedStyle::createWithInheritableProperties(*pseudoStyle);
+    setStyle(style.release());
 }
 
 void LayoutObject::markContainingBlocksForOverflowRecalc()
 {
     for (LayoutBlock* container = containingBlock(); container && !container->childNeedsOverflowRecalcAfterStyleChange(); container = container->containingBlock())
         container->setChildNeedsOverflowRecalcAfterStyleChange(true);
 }
 
 void LayoutObject::setNeedsOverflowRecalcAfterStyleChange()
 {
@@ skipping 613 matching lines @@
     // exceptions.
     // (1) It can be used on orphaned subtrees, i.e., it can be called safely even when
     // the object is not part of the primary document subtree yet.
     // (2) For normal flow elements, it just returns the parent.
     // (3) For absolute positioned elements, it will return a relative positioned inline.
     // containingBlock() simply skips relpositioned inlines and lets an enclosing block handle
     // the layout of the positioned object.  This does mean that computePositionedLogicalWidth and
     // computePositionedLogicalHeight have to use container().
     LayoutObject* o = parent();
 
-    if (isTextOrSVGChild())
+    if (isSVGChild())
         return o;
 
     EPosition pos = m_style->position();
     if (pos == FixedPosition)
         return containerForFixedPosition(paintInvalidationContainer, paintInvalidationContainerSkipped);
 
     if (pos == AbsolutePosition) {
         // We technically just want our containing block, but
         // we may not have one if we're part of an uninstalled
         // subtree. We'll climb as high as we can though.
@@ skipping 939 matching lines @@
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     } else {
         fprintf(stderr, "Cannot showLayoutTree. Root is (nil)\n");
     }
 }
 
 #endif