Remove calls to styleForLayoutObject() in LayoutTreeBuilder::style()

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
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "core/dom/Element.h"
 
+#include <memory>

[nainar, 2017/03/09 02:53:03]

git cl format. Will get rid of this.

 #include "bindings/core/v8/DOMDataStore.h"
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/V8DOMActivityLogger.h"
 #include "bindings/core/v8/V8DOMWrapper.h"
 #include "bindings/core/v8/V8PerContextData.h"
 #include "core/CSSValueKeywords.h"
 #include "core/SVGNames.h"
 #include "core/XMLNames.h"
@@ skipping 64 matching lines @@
 #include "core/frame/VisualViewport.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/ClassList.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLCollection.h"
 #include "core/html/HTMLDocument.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLFormControlsCollection.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLFrameOwnerElement.h"
+#include "core/html/HTMLObjectElement.h"

[nainar, 2017/03/09 02:53:03]

Not needed. 

 #include "core/html/HTMLOptionsCollection.h"
 #include "core/html/HTMLPlugInElement.h"
 #include "core/html/HTMLSlotElement.h"
 #include "core/html/HTMLTableRowsCollection.h"
 #include "core/html/HTMLTemplateElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/input/EventHandler.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/layout/LayoutTextFragment.h"
 #include "core/layout/api/LayoutBoxItem.h"
@@ skipping 16 matching lines @@
 #include "platform/EventDispatchForbiddenScope.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/CompositorMutableProperties.h"
 #include "platform/graphics/CompositorMutation.h"
 #include "platform/scroll/ScrollableArea.h"
 #include "wtf/BitVector.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/TextPosition.h"
-#include <memory>
 
 namespace blink {
 
 namespace {
 
 // We need to retain the scroll customization callbacks until the element
 // they're associated with is destroyed. It would be simplest if the callbacks
 // could be stored in ElementRareData, but we can't afford the space
 // increase. Instead, keep the scroll customization callbacks here. The other
 // option would be to store these callbacks on the FrameHost or document, but
@@ skipping 1572 matching lines @@
     if (ElementAnimations* elementAnimations =
             elementRareData()->elementAnimations()) {
       elementAnimations->cssAnimations().cancel();
       elementAnimations->setAnimationStyleChange(false);
     }
   }
 
   SelectorFilterParentScope filterScope(*this);
   StyleSharingDepthScope sharingScope(*this);
 
+  clearNeedsReattachLayoutTree();
   createPseudoElementIfNeeded(PseudoIdBefore);
 
   // When a shadow root exists, it does the work of attaching the children.
   if (ElementShadow* shadow = this->shadow())
     shadow->attach(context);
 
   ContainerNode::attachLayoutTree(context);
 
   createPseudoElementIfNeeded(PseudoIdAfter);
   createPseudoElementIfNeeded(PseudoIdBackdrop);
@@ skipping 262 matching lines @@
 
   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) {
+    // This mimicks Element::recalcStyleForReattach except it also stores the
+    // nextTextSibling information.
     StyleReattachData styleReattachData;
     styleReattachData.computedStyle = std::move(newStyle);
     styleReattachData.nextTextSibling = nextTextSibling;
     document().addStyleReattachData(*this, styleReattachData);
     setNeedsReattachLayoutTree();
+    recalcContainedStyleForReattach();
     return Reattach;
   }
 
   DCHECK(oldStyle);
 
   if (localChange != NoChange)
     updateCallbackSelectors(oldStyle.get(), newStyle.get());
 
   if (LayoutObject* layoutObject = this->layoutObject()) {
     if (localChange != NoChange) {
@@ skipping 24 matching lines @@
         return Inherit;
       newStyle->copyChildDependentFlagsFrom(*oldStyle);
     }
     if (oldStyle->hasPseudoElementStyle() || newStyle->hasPseudoElementStyle())
       return UpdatePseudoElements;
   }
 
   return localChange;
 }
 
+void Element::recalcStyleForReattach() {
+  StyleReattachData styleReattachData;
+  styleReattachData.computedStyle = styleForLayoutObject();
+  if (layoutObjectIsNeeded(*styleReattachData.computedStyle.get())) {
+    document().addStyleReattachData(*this, styleReattachData);
+    setNeedsReattachLayoutTree();
+    recalcContainedStyleForReattach();
+  }
+}
+
+void Element::recalcContainedStyleForReattach() {
+  if (!childrenCanHaveStyle())
+    return;
+  if (hasCustomStyleCallbacks())
+    return;
+
+  SelectorFilterParentScope filterScope(*this);
+  StyleSharingDepthScope sharingScope(*this);
+  recalcPseudoStyleForReattach(PseudoIdBefore);
+  recalcShadowRootStylesForReattach();
+  recalcDescendantStylesForReattach();
+  recalcPseudoStyleForReattach(PseudoIdAfter);
+  recalcPseudoStyleForReattach(PseudoIdBackdrop);
+  recalcPseudoStyleForReattach(PseudoIdFirstLetter);
+}
+
+void Element::recalcPseudoStyleForReattach(PseudoId pseudoId) {
+  if (PseudoElement* element = pseudoElement(pseudoId))
+    element->recalcStyleForReattach();
+}
+
+void Element::recalcShadowRootStylesForReattach() {
+  for (ShadowRoot* root = youngestShadowRoot(); root;
+       root = root->olderShadowRoot()) {
+    root->recalcDescendantStylesForReattach();
+  }
+}
+
 void Element::rebuildLayoutTree() {
   DCHECK(inActiveDocument());
   DCHECK(parentNode());
 
   if (needsReattachLayoutTree()) {
     StyleReattachData styleReattachData =
         document().getStyleReattachData(*this);
     AttachContext reattachContext;
+    // TODO(nainar): Shouldn't need AttachContext.resolvedStyle anymore
     reattachContext.resolvedStyle = styleReattachData.computedStyle.get();
     bool layoutObjectWillChange = needsAttach() || layoutObject();
     reattachLayoutTree(reattachContext);
     if (layoutObjectWillChange || layoutObject()) {
       // nextTextSibling is passed on to recalcStyle from recalcDescendantStyles
       // we can either traverse the current subtree from this node onwards
       // or store it.
       // The choice is between increased time and increased memory complexity.
       reattachWhitespaceSiblingsIfNeeded(styleReattachData.nextTextSibling);
     }
@@ skipping 2136 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(Element) {
   if (hasRareData()) {
     visitor->traceWrappers(elementRareData());
   }
   ContainerNode::traceWrappers(visitor);
 }
 
 }  // namespace blink