Implement closed shadow adjustment for Element.offsetParent

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 618 matching lines @@
         return document();
     Node* root = const_cast<Node*>(this);
     while (Node* host = root->shadowHost())
         root = host;
     while (Node* ancestor = root->parentNode())
         root = ancestor;
     DCHECK(!root->shadowHost());
     return *root;
 }
 
+bool Node::isUnclosedNodeOf(const Node& other) const
+{
+    if (treeScope() == other.treeScope())
+        return true;
+
+    for (TreeScope* scope = &other.treeScope(); scope; scope = scope->parentTreeScope()) {
+        if (scope == treeScope())
+            return true;
+    }
+
+    ContainerNode& root = treeScope().rootNode();
+    if (root.isShadowRoot() && toShadowRoot(root).isOpenOrV0())
+        return other.isUnclosedNodeOf(toShadowRoot(root).host());

[hayato, 2016/06/09 08:22:03]

Is this opposite of the definition? Could you re-check the definition of
"unclosed node"?

We do not have to implement "unclosed node" literally, which is O(N^2).

I think we can implement this in O(N). An algorithm can be:

bool Node::isUnclosedNodeOf(const Node& other) const
{
    if (!isInShadowTree() || treeScope() == other.treeScope())
        return true;
    TreeScope* thisScope = &treeScope();
    while (!thisScope.*isClosed()* && thisScope.parentTreeScope()) {
       thisScope = thisScope->parentScope();
    }
    for (TreeScope* scope = &other.treeScope(); scope; scope =
scope->parentTreeScope()) {
        if (scope == thisScope)
            return true;
    }
    return false;
}

[kochi, 2016/06/09 10:49:39]

Oops, you're right.
I read the latter half of the definition in the opposite way.
This means the test case isn't enough, so I'll add another one to catch it.
Thanks, after checking the tests are working, adopt this alogirthm.

+    return false;
+}
+
 bool Node::needsDistributionRecalc() const
 {
     return shadowIncludingRoot().childNeedsDistributionRecalc();
 }
 
 void Node::updateDistribution()
 {
     // Extra early out to avoid spamming traces.
     if (inShadowIncludingDocument() && !document().childNeedsDistributionRecalc())
         return;
@@ skipping 1835 matching lines @@
 
 void showNodePath(const blink::Node* node)
 {
     if (node)
         node->showNodePathForThis();
     else
         fprintf(stderr, "Cannot showNodePath for (nil)\n");
 }
 
 #endif