Source/WebCore/dom/TreeScope.cpp

   1 /*
   2  * Copyright (C) 2011 Google Inc. All Rights Reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "TreeScope.h"
  28
  29 #include "ComposedShadowTreeWalker.h"
  30 #include "ContainerNode.h"
  31 #include "ContextFeatures.h"
  32 #include "DOMSelection.h"
  33 #include "DOMWindow.h"
  34 #include "Document.h"
  35 #include "Element.h"
  36 #include "FocusController.h"
  37 #include "Frame.h"
  38 #include "HTMLAnchorElement.h"
  39 #include "HTMLFrameOwnerElement.h"
  40 #include "HTMLMapElement.h"
  41 #include "HTMLNames.h"
  42 #include "IdTargetObserverRegistry.h"
  43 #include "InsertionPoint.h"
  44 #include "Page.h"
  45 #include "ShadowRoot.h"
  46 #include "TreeScopeAdopter.h"
  47 #include <wtf/Vector.h>
  48 #include <wtf/text/AtomicString.h>
  49 #include <wtf/text/CString.h>
  50
  51 namespace WebCore {
  52
  53 using namespace HTMLNames;
  54
  55 TreeScope::TreeScope(ContainerNode* rootNode)
  56     : m_rootNode(rootNode)
  57     , m_parentTreeScope(0)
  58     , m_idTargetObserverRegistry(IdTargetObserverRegistry::create())
  59 {
  60     ASSERT(rootNode);
  61 }
  62
  63 TreeScope::~TreeScope()
  64 {
  65     if (m_selection) {
  66         m_selection->clearTreeScope();
  67         m_selection = 0;
  68     }
  69 }
  70
  71 void TreeScope::destroyTreeScopeData()
  72 {
  73     m_elementsById.clear();
  74     m_imageMapsByName.clear();
  75 }
  76
  77 void TreeScope::setParentTreeScope(TreeScope* newParentScope)
  78 {
  79     // A document node cannot be re-parented.
  80     ASSERT(!rootNode()->isDocumentNode());
  81     // Every scope other than document needs a parent scope.
  82     ASSERT(newParentScope);
  83
  84     m_parentTreeScope = newParentScope;
  85 }
  86
  87 Element* TreeScope::getElementById(const AtomicString& elementId) const
  88 {
  89     if (elementId.isEmpty())
  90         return 0;
  91     return m_elementsById.getElementById(elementId.impl(), this);
  92 }
  93
  94 void TreeScope::addElementById(const AtomicString& elementId, Element* element)
  95 {
  96     m_elementsById.add(elementId.impl(), element);
  97     m_idTargetObserverRegistry->notifyObservers(elementId);
  98 }
  99
 100 void TreeScope::removeElementById(const AtomicString& elementId, Element* element)
 101 {
 102     m_elementsById.remove(elementId.impl(), element);
 103     m_idTargetObserverRegistry->notifyObservers(elementId);
 104 }
 105
 106 Node* TreeScope::ancestorInThisScope(Node* node) const
 107 {
 108     while (node) {
 109         if (node->treeScope() == this)
 110             return node;
 111         if (!node->isInShadowTree())
 112             return 0;
 113         node = node->shadowAncestorNode();
 114     }
 115
 116     return 0;
 117 }
 118
 119 void TreeScope::addImageMap(HTMLMapElement* imageMap)
 120 {
 121     AtomicStringImpl* name = imageMap->getName().impl();
 122     if (!name)
 123         return;
 124     m_imageMapsByName.add(name, imageMap);
 125 }
 126
 127 void TreeScope::removeImageMap(HTMLMapElement* imageMap)
 128 {
 129     AtomicStringImpl* name = imageMap->getName().impl();
 130     if (!name)
 131         return;
 132     m_imageMapsByName.remove(name, imageMap);
 133 }
 134
 135 HTMLMapElement* TreeScope::getImageMap(const String& url) const
 136 {
 137     if (url.isNull())
 138         return 0;
 139     size_t hashPos = url.find('#');
 140     String name = (hashPos == notFound ? url : url.substring(hashPos + 1)).impl();
 141     if (rootNode()->document()->isHTMLDocument())
 142         return static_cast<HTMLMapElement*>(m_imageMapsByName.getElementByLowercasedMapName(AtomicString(name.lower()).impl(), this));
 143     return static_cast<HTMLMapElement*>(m_imageMapsByName.getElementByMapName(AtomicString(name).impl(), this));
 144 }
 145
 146 DOMSelection* TreeScope::getSelection() const
 147 {
 148     if (!rootNode()->document()->frame())
 149         return 0;
 150
 151     if (m_selection)
 152         return m_selection.get();
 153
 154     // FIXME: The correct selection in Shadow DOM requires that Position can have a ShadowRoot
 155     // as a container. It is now enabled only if runtime Shadow DOM feature is enabled.
 156     // See https://bugs.webkit.org/show_bug.cgi?id=82697
 157 #if ENABLE(SHADOW_DOM)
 158     if (ContextFeatures::shadowDOMEnabled(rootNode()->document())) {
 159         m_selection = DOMSelection::create(this);
 160         return m_selection.get();
 161     }
 162 #endif
 163
 164     if (this != rootNode()->document())
 165         return rootNode()->document()->getSelection();
 166
 167     m_selection = DOMSelection::create(rootNode()->document());
 168     return m_selection.get();
 169 }
 170
 171 Element* TreeScope::findAnchor(const String& name)
 172 {
 173     if (name.isEmpty())
 174         return 0;
 175     if (Element* element = getElementById(name))
 176         return element;
 177     for (Node* node = rootNode(); node; node = node->traverseNextNode()) {
 178         if (node->hasTagName(aTag)) {
 179             HTMLAnchorElement* anchor = static_cast<HTMLAnchorElement*>(node);
 180             if (rootNode()->document()->inQuirksMode()) {
 181                 // Quirks mode, case insensitive comparison of names.
 182                 if (equalIgnoringCase(anchor->name(), name))
 183                     return anchor;
 184             } else {
 185                 // Strict mode, names need to match exactly.
 186                 if (anchor->name() == name)
 187                     return anchor;
 188             }
 189         }
 190     }
 191     return 0;
 192 }
 193
 194 bool TreeScope::applyAuthorStyles() const
 195 {
 196     return true;
 197 }
 198
 199 bool TreeScope::resetStyleInheritance() const
 200 {
 201     return false;
 202 }
 203
 204 void TreeScope::adoptIfNeeded(Node* node)
 205 {
 206     ASSERT(this);
 207     ASSERT(node);
 208     ASSERT(!node->isDocumentNode());
 209     ASSERT(!node->m_deletionHasBegun);
 210     TreeScopeAdopter adopter(node, this);
 211     if (adopter.needsScopeChange())
 212         adopter.execute();
 213 }
 214
 215 static Node* focusedFrameOwnerElement(Frame* focusedFrame, Frame* currentFrame)
 216 {
 217     for (; focusedFrame; focusedFrame = focusedFrame->tree()->parent()) {
 218         if (focusedFrame->tree()->parent() == currentFrame)
 219             return focusedFrame->ownerElement();
 220     }
 221     return 0;
 222 }
 223
 224 Node* TreeScope::focusedNode()
 225 {
 226     Document* document = rootNode()->document();
 227     Node* node = document->focusedNode();
 228     if (!node && document->page())
 229         node = focusedFrameOwnerElement(document->page()->focusController()->focusedFrame(), document->frame());
 230     if (!node)
 231         return 0;
 232     Vector<Node*> targetStack;
 233     Node* last = 0;
 234     for (ComposedShadowTreeParentWalker walker(node); walker.get(); walker.parentIncludingInsertionPointAndShadowRoot()) {
 235         Node* node = walker.get();
 236         if (targetStack.isEmpty())
 237             targetStack.append(node);
 238         else if (isInsertionPoint(node) && toInsertionPoint(node)->contains(last))
 239             targetStack.append(targetStack.last());
 240         if (node == rootNode())
 241             return targetStack.last();
 242         last = node;
 243         if (node->isShadowRoot()) {
 244             ASSERT(!targetStack.isEmpty());
 245             targetStack.removeLast();
 246         }
 247     }
 248     return 0;
 249 }
 250
 251 static void listTreeScopes(Node* node, Vector<TreeScope*, 5>& treeScopes)
 252 {
 253     while (true) {
 254         treeScopes.append(node->treeScope());
 255         Element* ancestor = node->shadowHost();
 256         if (!ancestor)
 257             break;
 258         node = ancestor;
 259     }
 260 }
 261
 262 TreeScope* commonTreeScope(Node* nodeA, Node* nodeB)
 263 {
 264     if (!nodeA || !nodeB)
 265         return 0;
 266
 267     if (nodeA->treeScope() == nodeB->treeScope())
 268         return nodeA->treeScope();
 269
 270     Vector<TreeScope*, 5> treeScopesA;
 271     listTreeScopes(nodeA, treeScopesA);
 272
 273     Vector<TreeScope*, 5> treeScopesB;
 274     listTreeScopes(nodeB, treeScopesB);
 275
 276     size_t indexA = treeScopesA.size();
 277     size_t indexB = treeScopesB.size();
 278
 279     for (; indexA > 0 && indexB > 0 && treeScopesA[indexA - 1] == treeScopesB[indexB - 1]; --indexA, --indexB) { }
 280
 281     return treeScopesA[indexA] == treeScopesB[indexB] ? treeScopesA[indexA] : 0;
 282 }
 283
 284 } // namespace WebCore
 285