Revert of Add inline style in the element's scope.

Source/core/css/resolver/StyleResolver.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 361 matching lines @@
             continue;
         if (ScopedStyleResolver* resolver = shadowRoot->scopedStyleResolver()) {
             collector.clearMatchedRules();
             resolver->collectMatchingShadowHostRules(collector, includeEmptyRules);
             collector.sortAndTransferMatchedRules();
             collector.finishAddingAuthorRulesForTreeScope();
         }
     }
 }
 
-void StyleResolver::matchElementScopeRules(const Element& element, ScopedStyleResolver* elementScopeResolver, ElementRuleCollector& collector, bool includeEmptyRules)
+void StyleResolver::matchElementScopeRules(ScopedStyleResolver& elementScopeResolver, ElementRuleCollector& collector, bool includeEmptyRules)
 {
-    if (elementScopeResolver) {
-        collector.clearMatchedRules();
-        elementScopeResolver->collectMatchingAuthorRules(collector, includeEmptyRules);
-        elementScopeResolver->collectMatchingTreeBoundaryCrossingRules(collector, includeEmptyRules);
-        collector.sortAndTransferMatchedRules();
-    }
-
-    if (element.isStyledElement() && element.inlineStyle() && !collector.isCollectingForPseudoElement()) {
-        // Inline style is immutable as long as there is no CSSOM wrapper.
-        bool isInlineStyleCacheable = !element.inlineStyle()->isMutable();
-        collector.addElementStyleProperties(element.inlineStyle(), isInlineStyleCacheable);
-    }
-
+    collector.clearMatchedRules();
+    elementScopeResolver.collectMatchingAuthorRules(collector, includeEmptyRules);
+    elementScopeResolver.collectMatchingTreeBoundaryCrossingRules(collector, includeEmptyRules);
+    collector.sortAndTransferMatchedRules();
     collector.finishAddingAuthorRulesForTreeScope();
 }
 
 void StyleResolver::matchScopedRules(const Element& element, ElementRuleCollector& collector, bool includeEmptyRules)
 {
     // Match rules from treeScopes in the reverse tree-of-trees order, since the
     // cascading order for normal rules is such that when comparing rules from
     // different shadow trees, the rule from the tree which comes first in the
     // tree-of-trees order wins. From other treeScopes than the element's own
     // scope, only tree-boundary-crossing rules may match.
 
     ScopedStyleResolver* elementScopeResolver = scopedResolverFor(element);
-    bool matchElementScopeDone = !elementScopeResolver && !element.inlineStyle();
+    bool matchElementScopeDone = !elementScopeResolver;
 
     for (auto it = m_treeBoundaryCrossingScopes.rbegin(); it != m_treeBoundaryCrossingScopes.rend(); ++it) {
         const TreeScope& scope = (*it)->treeScope();
         ScopedStyleResolver* resolver = scope.scopedStyleResolver();
         ASSERT(resolver);
 
         if (!matchElementScopeDone && scope.isInclusiveAncestorOf(element.treeScope())) {
 
             matchElementScopeDone = true;
 
             // At this point, the iterator has either encountered the scope for the element
             // itself (if that scope has boundary-crossing rules), or the iterator has moved
             // to a scope which appears before the element's scope in the tree-of-trees order.
             // Try to match all rules from the element's scope.
 
-            matchElementScopeRules(element, elementScopeResolver, collector, includeEmptyRules);
+            matchElementScopeRules(*elementScopeResolver, collector, includeEmptyRules);
             if (resolver == elementScopeResolver) {
                 // Boundary-crossing rules already collected in matchElementScopeRules.
                 continue;
             }
         }
 
         collector.clearMatchedRules();
         resolver->collectMatchingTreeBoundaryCrossingRules(collector, includeEmptyRules);
         collector.sortAndTransferMatchedRules();
         collector.finishAddingAuthorRulesForTreeScope();
     }
 
     if (!matchElementScopeDone)
-        matchElementScopeRules(element, elementScopeResolver, collector, includeEmptyRules);
+        matchElementScopeRules(*elementScopeResolver, collector, includeEmptyRules);
 }
 
 void StyleResolver::matchAuthorRules(const Element& element, ElementRuleCollector& collector, bool includeEmptyRules)
 {
     matchHostRules(element, collector, includeEmptyRules);
     matchScopedRules(element, collector, includeEmptyRules);
 }
 
 void StyleResolver::matchUARules(ElementRuleCollector& collector)
 {
@@ skipping 41 matching lines @@
             if (isAuto) {
                 state.setHasDirAutoAttribute(true);
                 collector.addElementStyleProperties(textDirection == LTR ? leftToRightDeclaration() : rightToLeftDeclaration());
             }
         }
     }
 
     matchAuthorRules(*state.element(), collector, false);
 
     if (state.element()->isStyledElement()) {
+        // TODO(rune@opera.com): Adding style attribute rules here is probably too late
+        // when you have shadow piercing combinators. When we don't have piercing combinators,
+        // the style attribute always belong to the outermost scope whose rules apply to
+        // the element. Thus, applying inline style here is correct. Fixing this for piercing
+        // combinators means moving the code below into matchElementScopeRules and _not_
+        // invoking it for pseudo style requests.
+        if (state.element()->inlineStyle()) {
+            // Inline style is immutable as long as there is no CSSOM wrapper.
+            bool isInlineStyleCacheable = !state.element()->inlineStyle()->isMutable();
+            collector.addElementStyleProperties(state.element()->inlineStyle(), isInlineStyleCacheable);
+        }
+
         // Now check SMIL animation override style.
         if (includeSMILProperties && state.element()->isSVGElement())
             collector.addElementStyleProperties(toSVGElement(state.element())->animatedSMILStyleProperties(), false /* isCacheable */);
     }
 
     collector.finishAddingAuthorRulesForTreeScope();
 }
 
 PassRefPtr<ComputedStyle> StyleResolver::styleForDocument(Document& document)
 {
@@ skipping 1026 matching lines @@
     visitor->trace(m_watchedSelectorsRules);
     visitor->trace(m_treeBoundaryCrossingScopes);
     visitor->trace(m_styleResourceLoader);
     visitor->trace(m_styleSharingLists);
     visitor->trace(m_pendingStyleSheets);
     visitor->trace(m_document);
 #endif
 }
 
 } // namespace blink