mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
308 lines
9.4 KiB
C++
308 lines
9.4 KiB
C++
/*
|
|
* 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<const TreeScope*, 16> chain1;
|
|
Vector<const TreeScope*, 16> 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<const TreeScope*, 16> thisChain;
|
|
for (const TreeScope* tree = this; tree; tree = tree->parentTreeScope())
|
|
thisChain.append(tree);
|
|
|
|
Vector<const TreeScope*, 16> 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<TreeScope*>(static_cast<const TreeScope&>(*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<RefPtr<blink::CSSStyleSheet> >& list = scopedStyleResolver().authorStyleSheets();
|
|
const Vector<RefPtr<blink::CSSStyleSheet> >& 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
|