getComputedStyle should not always force a layout inside shadow trees.

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
@@ skipping 2138 matching lines @@
 
   m_lifecycle.advanceTo(DocumentLifecycle::InLayoutSubtreeChange);
 
   layoutViewItem().handleSubtreeModifications();
   DCHECK(!layoutViewItem().wasNotifiedOfSubtreeChange());
 
   m_lifecycle.advanceTo(DocumentLifecycle::LayoutSubtreeChangeClean);
 }
 
 bool Document::needsLayoutTreeUpdateForNode(const Node& node) const {
-  if (!node.canParticipateInFlatTree())
-    return false;
   if (!needsLayoutTreeUpdate())
     return false;
   if (!node.isConnected())
     return false;
 
+  // Elements that are not distributed can still have a style, for example a
+  // <slot> can still be styled, but LayoutTreeBuilder::parent DCHECKs on
+  // things outside the flat tree, so we instead disable this optimization.
+  if (!node.canParticipateInFlatTree())
+    return true;
+
   if (needsFullLayoutTreeUpdate() || node.needsStyleRecalc() ||
       node.needsStyleInvalidation())
     return true;
-  for (const ContainerNode* ancestor = LayoutTreeBuilderTraversal::parent(node);
-       ancestor; ancestor = LayoutTreeBuilderTraversal::parent(*ancestor)) {
+
+  const ContainerNode* deepestParent = LayoutTreeBuilderTraversal::parent(node);
+
+  // If we're not distributed anywhere we need our style recomputed always.
+  if (!deepestParent)
+    return true;
+
+  for (const ContainerNode* ancestor = deepestParent; ancestor;
+       ancestor = LayoutTreeBuilderTraversal::parent(*ancestor)) {
     if (ancestor->needsStyleRecalc() || ancestor->needsStyleInvalidation() ||
         ancestor->needsAdjacentStyleRecalc())
       return true;
   }
+
+  ShadowRoot* scope = node.containingShadowRoot();
+  if (!scope)
+    return false;
+
+  // Traverse up the scopes from the node to the root checking for bits, we
+  // need to do this since the LayoutTreeBuilder::parent walk above skips all
+  // shadow roots.
+  for (const ShadowRoot* root = scope; root;
+       root = root->host().containingShadowRoot()) {
+    if (root->needsStyleRecalc() || root->needsStyleInvalidation() ||
+        root->needsAdjacentStyleRecalc())
+      return true;
+  }
+
+  // Traverse from the location where we were distributed up until we hit the
+  // scope that owns the node itself which we checked above.
+  for (const ShadowRoot* root = deepestParent->containingShadowRoot();
+       root && root != scope; root = root->host().containingShadowRoot()) {
+    if (root->needsStyleRecalc() || root->needsStyleInvalidation() ||
+        root->needsAdjacentStyleRecalc())
+      return true;
+  }
+
   return false;
 }
 
 void Document::updateStyleAndLayoutTreeForNode(const Node* node) {
   DCHECK(node);
   if (!needsLayoutTreeUpdateForNode(*node))
     return;
   updateStyleAndLayoutTree();
 }
 
@@ skipping 4465 matching lines @@
 }
 
 void showLiveDocumentInstances() {
   WeakDocumentSet& set = liveDocumentSet();
   fprintf(stderr, "There are %u documents currently alive:\n", set.size());
   for (blink::Document* document : set)
     fprintf(stderr, "- Document %p URL: %s\n", document,
             document->url().getString().utf8().data());
 }
 #endif