/* * Copyright (C) 2011 Google Inc. All Rights Reserved. * Copyright (C) 2012 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "sky/engine/core/dom/TreeScope.h" #include "gen/sky/core/HTMLNames.h" #include "sky/engine/core/css/resolver/ScopedStyleResolver.h" #include "sky/engine/core/dom/ContainerNode.h" #include "sky/engine/core/dom/Document.h" #include "sky/engine/core/dom/Element.h" #include "sky/engine/core/dom/ElementTraversal.h" #include "sky/engine/core/dom/NodeRenderStyle.h" #include "sky/engine/core/dom/TreeScopeAdopter.h" #include "sky/engine/core/frame/FrameView.h" #include "sky/engine/core/frame/LocalFrame.h" #include "sky/engine/core/page/Page.h" #include "sky/engine/core/rendering/HitTestResult.h" #include "sky/engine/core/rendering/RenderView.h" #include "sky/engine/wtf/Vector.h" namespace blink { TreeScope::TreeScope(ContainerNode& rootNode, Document& document) : m_rootNode(&rootNode) , m_document(&document) , m_parentTreeScope(&document) , m_scopedStyleResolver(ScopedStyleResolver::create(*this)) , m_guardRefCount(0) { ASSERT(rootNode != document); m_parentTreeScope->guardRef(); m_rootNode->setTreeScope(this); } TreeScope::TreeScope(Document& document) : m_rootNode(document) , m_document(&document) , m_parentTreeScope(nullptr) , m_scopedStyleResolver(ScopedStyleResolver::create(*this)) , m_guardRefCount(0) { m_rootNode->setTreeScope(this); } TreeScope::~TreeScope() { ASSERT(!m_guardRefCount); m_rootNode->setTreeScope(0); if (m_parentTreeScope) m_parentTreeScope->guardDeref(); } bool TreeScope::rootNodeHasTreeSharedParent() const { return rootNode().hasTreeSharedParent(); } #if !ENABLE(OILPAN) void TreeScope::destroyTreeScopeData() { m_elementsById.clear(); m_imageMapsByName.clear(); m_labelsByForAttribute.clear(); } #endif void TreeScope::setParentTreeScope(TreeScope& newParentScope) { // A document node cannot be re-parented. ASSERT(!rootNode().isDocumentNode()); #if !ENABLE(OILPAN) newParentScope.guardRef(); if (m_parentTreeScope) m_parentTreeScope->guardDeref(); #endif m_parentTreeScope = &newParentScope; setDocument(newParentScope.document()); } Element* TreeScope::getElementById(const AtomicString& elementId) const { if (elementId.isEmpty()) return 0; if (!m_elementsById) return 0; return m_elementsById->getElementById(elementId, this); } void TreeScope::addElementById(const AtomicString& elementId, Element* element) { if (!m_elementsById) m_elementsById = DocumentOrderedMap::create(); m_elementsById->add(elementId, element); } void TreeScope::removeElementById(const AtomicString& elementId, Element* element) { if (!m_elementsById) return; m_elementsById->remove(elementId, element); } Node* TreeScope::ancestorInThisScope(Node* node) const { if (node->treeScope() == this) return node; return 0; } HitTestResult hitTestInDocument(const Document* document, int x, int y) { LocalFrame* frame = document->frame(); if (!frame) return HitTestResult(); FrameView* frameView = frame->view(); if (!frameView) return HitTestResult(); IntPoint point(x, y); if (!frameView->visibleContentRect().contains(point)) return HitTestResult(); HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active); HitTestResult result(point); document->renderView()->hitTest(request, result); return result; } Element* TreeScope::elementFromPoint(int x, int y) const { HitTestResult result = hitTestInDocument(&rootNode().document(), x, y); Node* node = result.innerNode(); if (!node || node->isDocumentNode()) return 0; if (node->isTextNode()) node = node->parentNode(); ASSERT(!node || node->isElementNode()); node = ancestorInThisScope(node); if (!node || !node->isElementNode()) return 0; return toElement(node); } void TreeScope::adoptIfNeeded(Node& node) { ASSERT(this); ASSERT(!node.isDocumentNode()); #if !ENABLE(OILPAN) ASSERT_WITH_SECURITY_IMPLICATION(!node.m_deletionHasBegun); #endif TreeScopeAdopter adopter(node, *this); if (adopter.needsScopeChange()) adopter.execute(); } unsigned short TreeScope::comparePosition(const TreeScope& otherScope) const { if (otherScope == this) return Node::DOCUMENT_POSITION_EQUIVALENT; Vector chain1; Vector chain2; const TreeScope* current; for (current = this; current; current = current->parentTreeScope()) chain1.append(current); for (current = &otherScope; current; current = current->parentTreeScope()) chain2.append(current); unsigned index1 = chain1.size(); unsigned index2 = chain2.size(); if (chain1[index1 - 1] != chain2[index2 - 1]) return Node::DOCUMENT_POSITION_DISCONNECTED | Node::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC; for (unsigned i = std::min(index1, index2); i; --i) { const TreeScope* child1 = chain1[--index1]; const TreeScope* child2 = chain2[--index2]; if (child1 != child2) { return Node::DOCUMENT_POSITION_PRECEDING; } } // There was no difference between the two parent chains, i.e., one was a subset of the other. The shorter // chain is the ancestor. return index1 < index2 ? Node::DOCUMENT_POSITION_FOLLOWING | Node::DOCUMENT_POSITION_CONTAINED_BY : Node::DOCUMENT_POSITION_PRECEDING | Node::DOCUMENT_POSITION_CONTAINS; } const TreeScope* TreeScope::commonAncestorTreeScope(const TreeScope& other) const { Vector thisChain; for (const TreeScope* tree = this; tree; tree = tree->parentTreeScope()) thisChain.append(tree); Vector otherChain; for (const TreeScope* tree = &other; tree; tree = tree->parentTreeScope()) otherChain.append(tree); // Keep popping out the last elements of these chains until a mismatched pair is found. If |this| and |other| // belong to different documents, null will be returned. const TreeScope* lastAncestor = 0; while (!thisChain.isEmpty() && !otherChain.isEmpty() && thisChain.last() == otherChain.last()) { lastAncestor = thisChain.last(); thisChain.removeLast(); otherChain.removeLast(); } return lastAncestor; } TreeScope* TreeScope::commonAncestorTreeScope(TreeScope& other) { return const_cast(static_cast(*this).commonAncestorTreeScope(other)); } TreeScope* commonTreeScope(Node* nodeA, Node* nodeB) { if (!nodeA || !nodeB) return 0; if (nodeA->treeScope() == nodeB->treeScope()) return &nodeA->treeScope(); return 0; } #if ENABLE(SECURITY_ASSERT) && !ENABLE(OILPAN) bool TreeScope::deletionHasBegun() { return rootNode().m_deletionHasBegun; } void TreeScope::beginDeletion() { rootNode().m_deletionHasBegun = true; } #endif #if !ENABLE(OILPAN) int TreeScope::refCount() const { return rootNode().refCount(); } #endif bool TreeScope::isInclusiveAncestorOf(const TreeScope& scope) const { for (const TreeScope* current = &scope; current; current = current->parentTreeScope()) { if (current == this) return true; } return false; } void TreeScope::setNeedsStyleRecalcForViewportUnits() { for (Element* element = ElementTraversal::firstWithin(rootNode()); element; element = ElementTraversal::next(*element)) { RenderStyle* style = element->renderStyle(); if (style && style->hasViewportUnits()) element->setNeedsStyleRecalc(LocalStyleChange); } } bool TreeScope::hasSameStyles(TreeScope& other) { if (this == &other) return true; const Vector >& list = scopedStyleResolver().authorStyleSheets(); const Vector >& otherList = other.scopedStyleResolver().authorStyleSheets(); if (list.size() != otherList.size()) return false; for (size_t i = 0; i < list.size(); i++) { if (list[i]->contents() != otherList[i]->contents()) return false; } return true; } } // namespace blink