Set ComputedStyle on Node and use that in buildOwnLayout()

third_party/WebKit/Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 549 matching lines @@
 
     // TODO(esprehn): This should use updateStyleAndLayoutIgnorePendingStylesheetsForNode.
     document().updateStyleAndLayoutIgnorePendingStylesheets();
 
     LayoutBox* boxToScroll = nullptr;
 
     // We should only ever scroll the effective root scroller this way when the
     // page removes the default applyScroll (ViewportScrollCallback).
     if (document().effectiveRootScroller() == this)
         boxToScroll = document().layoutView();
-    else if (layoutObject())
+    else if (hasLayoutObject())
         boxToScroll = toLayoutBox(layoutObject());
 
     if (!boxToScroll)
         return;
 
     ScrollResult result =
         LayoutBoxItem(boxToScroll).enclosingBox().scroll(
             ScrollGranularity(static_cast<int>(scrollState.deltaGranularity())),
             delta);
 
@@ skipping 1181 matching lines @@
     DCHECK(newStyle);
 
     StyleRecalcChange localChange = ComputedStyle::stylePropagationDiff(oldStyle.get(), newStyle.get());
     if (localChange == NoChange) {
         INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), stylesUnchanged, 1);
     } else {
         INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), stylesChanged, 1);
     }
 
     if (localChange == Reattach) {
-        AttachContext reattachContext;
-        reattachContext.resolvedStyle = newStyle.get();
-        bool layoutObjectWillChange = needsAttach() || layoutObject();
-        reattach(reattachContext);
-        if (layoutObjectWillChange || layoutObject())
-            return Reattach;
-        return ReattachNoLayoutObject;
+        setComputedStyle(newStyle);
+        return buildOwnLayout();

[sashab, 2016/07/04 07:57:12]

A suggestion that might make this a little easier to understand/track bugs
for/test:

1. Land a mechanical change patch that just calls buildOwnLayout(newStyle) here,
with a TODO to say //TODO(nainar): Remove the style parameter from this function
2. Make a separate patch that splits buildOwnLayout() into the two functions, an
actual behavioural change

From my experience it's a ton easier to land mechanical changes - they are less
likely to break things, get reverted, etc. Also if anything is wrong with them
you know the patch is wrong. If we can move all the significant changes for this
into a tiny change at the end it'll be much easier to see and understand. :)

[nainar, 2016/07/05 00:26:55]

In progress update: Made a new CL with the mechanical change and the TODO as you
suggested here: https://codereview.chromium.org/2118393002

     }
 
     DCHECK(oldStyle);
 
     if (localChange != NoChange)
         updateCallbackSelectors(oldStyle.get(), newStyle.get());
 
     if (LayoutObject* layoutObject = this->layoutObject()) {
         if (localChange != NoChange || pseudoStyleCacheIsInvalid(oldStyle.get(), newStyle.get()) || svgFilterNeedsLayerUpdate()) {
             layoutObject->setStyle(newStyle.get());
@@ skipping 18 matching lines @@
                 return Inherit;
             newStyle->copyChildDependentFlagsFrom(*oldStyle);
         }
         if (oldStyle->hasPseudoElementStyle() || newStyle->hasPseudoElementStyle())
             return UpdatePseudoElements;
     }
 
     return localChange;
 }
 
+StyleRecalcChange Element::buildOwnLayout()
+{
+    AttachContext reattachContext;
+    reattachContext.resolvedStyle = mutableComputedStyle();
+    bool layoutObjectWillChange = needsAttach() || hasLayoutObject();
+    reattach(reattachContext);
+    if (layoutObjectWillChange || hasLayoutObject())
+        return Reattach;
+    return ReattachNoLayoutObject;
+}
+
 void Element::updateCallbackSelectors(const ComputedStyle* oldStyle, const ComputedStyle* newStyle)
 {
     Vector<String> emptyVector;
     const Vector<String>& oldCallbackSelectors = oldStyle ? oldStyle->callbackSelectors() : emptyVector;
     const Vector<String>& newCallbackSelectors = newStyle ? newStyle->callbackSelectors() : emptyVector;
     if (oldCallbackSelectors.isEmpty() && newCallbackSelectors.isEmpty())
         return;
     if (oldCallbackSelectors != newCallbackSelectors)
         CSSSelectorWatch::from(document()).updateSelectorMatches(oldCallbackSelectors, newCallbackSelectors);
 }
@@ skipping 1901 matching lines @@
 
 DEFINE_TRACE_WRAPPERS(Element)
 {
     if (hasRareData()) {
         visitor->traceWrappers(elementRareData());
     }
     ContainerNode::traceWrappers(visitor);
 }
 
 } // namespace blink