Delete WKCACFLayer.{cpp,h}
[WebKit-https.git] / Source / WebCore / inspector / InspectorDOMAgent.cpp
1 /*
2  * Copyright (C) 2009 Apple Inc. All rights reserved.
3  * Copyright (C) 2009 Google Inc. All rights reserved.
4  * Copyright (C) 2009 Joseph Pecoraro
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1.  Redistributions of source code must retain the above copyright
11  *     notice, this list of conditions and the following disclaimer.
12  * 2.  Redistributions in binary form must reproduce the above copyright
13  *     notice, this list of conditions and the following disclaimer in the
14  *     documentation and/or other materials provided with the distribution.
15  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
16  *     its contributors may be used to endorse or promote products derived
17  *     from this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
20  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
23  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32 #include "InspectorDOMAgent.h"
33
34 #if ENABLE(INSPECTOR)
35
36 #include "Attr.h"
37 #include "CSSComputedStyleDeclaration.h"
38 #include "CSSMutableStyleDeclaration.h"
39 #include "CSSPropertyNames.h"
40 #include "CSSPropertySourceData.h"
41 #include "CSSRule.h"
42 #include "CSSRuleList.h"
43 #include "CSSStyleRule.h"
44 #include "CSSStyleSelector.h"
45 #include "CSSStyleSheet.h"
46 #include "CharacterData.h"
47 #include "ContainerNode.h"
48 #include "Cookie.h"
49 #include "CookieJar.h"
50 #include "DOMWindow.h"
51 #include "Document.h"
52 #include "DocumentType.h"
53 #include "Event.h"
54 #include "EventContext.h"
55 #include "EventListener.h"
56 #include "EventNames.h"
57 #include "EventTarget.h"
58 #include "Frame.h"
59 #include "FrameTree.h"
60 #include "HTMLElement.h"
61 #include "HTMLFrameOwnerElement.h"
62 #include "InspectorFrontend.h"
63 #include "MutationEvent.h"
64 #include "Node.h"
65 #include "NodeList.h"
66 #include "Pasteboard.h"
67 #include "PlatformString.h"
68 #include "RenderStyle.h"
69 #include "RenderStyleConstants.h"
70 #include "ScriptEventListener.h"
71 #include "StyleSheetList.h"
72 #include "Text.h"
73
74 #if ENABLE(XPATH)
75 #include "XPathResult.h"
76 #endif
77
78 #include "markup.h"
79
80 #include <wtf/text/CString.h>
81 #include <wtf/text/StringConcatenate.h>
82 #include <wtf/HashSet.h>
83 #include <wtf/ListHashSet.h>
84 #include <wtf/OwnPtr.h>
85 #include <wtf/Vector.h>
86 #include <wtf/text/AtomicString.h>
87
88 namespace WebCore {
89
90 class MatchJob {
91 public:
92     virtual void match(ListHashSet<Node*>& resultCollector) = 0;
93     virtual ~MatchJob() { }
94
95 protected:
96     MatchJob(Document* document, const String& query)
97         : m_document(document)
98         , m_query(query) { }
99
100     void addNodesToResults(PassRefPtr<NodeList> nodes, ListHashSet<Node*>& resultCollector)
101     {
102         for (unsigned i = 0; nodes && i < nodes->length(); ++i)
103             resultCollector.add(nodes->item(i));
104     }
105
106     RefPtr<Document> m_document;
107     String m_query;
108 };
109
110 namespace {
111
112 class MatchExactIdJob : public WebCore::MatchJob {
113 public:
114     MatchExactIdJob(Document* document, const String& query) : WebCore::MatchJob(document, query) { }
115     virtual ~MatchExactIdJob() { }
116
117 protected:
118     virtual void match(ListHashSet<Node*>& resultCollector)
119     {
120         if (m_query.isEmpty())
121             return;
122
123         Element* element = m_document->getElementById(m_query);
124         if (element)
125             resultCollector.add(element);
126     }
127 };
128
129 class MatchExactClassNamesJob : public WebCore::MatchJob {
130 public:
131     MatchExactClassNamesJob(Document* document, const String& query) : WebCore::MatchJob(document, query) { }
132     virtual ~MatchExactClassNamesJob() { }
133
134     virtual void match(ListHashSet<Node*>& resultCollector)
135     {
136         if (!m_query.isEmpty())
137             addNodesToResults(m_document->getElementsByClassName(m_query), resultCollector);
138     }
139 };
140
141 class MatchExactTagNamesJob : public WebCore::MatchJob {
142 public:
143     MatchExactTagNamesJob(Document* document, const String& query) : WebCore::MatchJob(document, query) { }
144     virtual ~MatchExactTagNamesJob() { }
145
146     virtual void match(ListHashSet<Node*>& resultCollector)
147     {
148         if (!m_query.isEmpty())
149             addNodesToResults(m_document->getElementsByName(m_query), resultCollector);
150     }
151 };
152
153 class MatchQuerySelectorAllJob : public WebCore::MatchJob {
154 public:
155     MatchQuerySelectorAllJob(Document* document, const String& query) : WebCore::MatchJob(document, query) { }
156     virtual ~MatchQuerySelectorAllJob() { }
157
158     virtual void match(ListHashSet<Node*>& resultCollector)
159     {
160         if (m_query.isEmpty())
161             return;
162
163         ExceptionCode ec = 0;
164         RefPtr<NodeList> list = m_document->querySelectorAll(m_query, ec);
165         if (!ec)
166             addNodesToResults(list, resultCollector);
167     }
168 };
169
170 class MatchXPathJob : public WebCore::MatchJob {
171 public:
172     MatchXPathJob(Document* document, const String& query) : WebCore::MatchJob(document, query) { }
173     virtual ~MatchXPathJob() { }
174
175     virtual void match(ListHashSet<Node*>& resultCollector)
176     {
177 #if ENABLE(XPATH)
178         if (m_query.isEmpty())
179             return;
180
181         ExceptionCode ec = 0;
182         RefPtr<XPathResult> result = m_document->evaluate(m_query, m_document.get(), 0, XPathResult::ORDERED_NODE_SNAPSHOT_TYPE, 0, ec);
183         if (ec || !result)
184             return;
185
186         unsigned long size = result->snapshotLength(ec);
187         for (unsigned long i = 0; !ec && i < size; ++i) {
188             Node* node = result->snapshotItem(i, ec);
189             if (!ec)
190                 resultCollector.add(node);
191         }
192 #else
193         UNUSED_PARAM(resultCollector);
194 #endif
195     }
196 };
197
198 class MatchPlainTextJob : public MatchXPathJob {
199 public:
200     MatchPlainTextJob(Document* document, const String& query) : MatchXPathJob(document, query)
201     {
202         m_query = "//text()[contains(., '" + m_query + "')] | //comment()[contains(., '" + m_query + "')]";
203     }
204     virtual ~MatchPlainTextJob() { }
205 };
206
207 enum DOMBreakpointType {
208     SubtreeModified = 0,
209     AttributeModified,
210     NodeRemoved,
211     DOMBreakpointTypesCount
212 };
213
214 const uint32_t inheritableDOMBreakpointTypesMask = (1 << SubtreeModified);
215 const int domBreakpointDerivedTypeShift = 16;
216
217 }
218
219 InspectorDOMAgent::InspectorDOMAgent(InspectorFrontend* frontend)
220     : EventListener(InspectorDOMAgentType)
221     , m_frontend(frontend)
222     , m_domListener(0)
223     , m_lastNodeId(1)
224     , m_matchJobsTimer(this, &InspectorDOMAgent::onMatchJobsTimer)
225 {
226 }
227
228 InspectorDOMAgent::~InspectorDOMAgent()
229 {
230     reset();
231 }
232
233 void InspectorDOMAgent::reset()
234 {
235     searchCanceled();
236     discardBindings();
237
238     ListHashSet<RefPtr<Document> > copy = m_documents;
239     for (ListHashSet<RefPtr<Document> >::iterator it = copy.begin(); it != copy.end(); ++it)
240         stopListening((*it).get());
241
242     ASSERT(!m_documents.size());
243 }
244
245 void InspectorDOMAgent::setDOMListener(DOMListener* listener)
246 {
247     m_domListener = listener;
248 }
249
250 void InspectorDOMAgent::setDocument(Document* doc)
251 {
252     if (doc == mainFrameDocument())
253         return;
254
255     reset();
256
257     if (doc) {
258         startListening(doc);
259         if (doc->documentElement())
260             pushDocumentToFrontend();
261     } else
262         m_frontend->setDocument(InspectorValue::null());
263 }
264
265 void InspectorDOMAgent::releaseDanglingNodes()
266 {
267     deleteAllValues(m_danglingNodeToIdMaps);
268     m_danglingNodeToIdMaps.clear();
269 }
270
271 void InspectorDOMAgent::startListening(Document* doc)
272 {
273     if (m_documents.contains(doc))
274         return;
275
276     doc->addEventListener(eventNames().DOMContentLoadedEvent, this, false);
277     doc->addEventListener(eventNames().loadEvent, this, true);
278     m_documents.add(doc);
279 }
280
281 void InspectorDOMAgent::stopListening(Document* doc)
282 {
283     if (!m_documents.contains(doc))
284         return;
285
286     doc->removeEventListener(eventNames().DOMContentLoadedEvent, this, false);
287     doc->removeEventListener(eventNames().loadEvent, this, true);
288     m_documents.remove(doc);
289 }
290
291 void InspectorDOMAgent::handleEvent(ScriptExecutionContext*, Event* event)
292 {
293     AtomicString type = event->type();
294     Node* node = event->target()->toNode();
295
296     if (type == eventNames().DOMContentLoadedEvent) {
297         // Re-push document once it is loaded.
298         discardBindings();
299         pushDocumentToFrontend();
300     } else if (type == eventNames().loadEvent) {
301         long frameOwnerId = m_documentNodeToIdMap.get(node);
302         if (!frameOwnerId)
303             return;
304
305         if (!m_childrenRequested.contains(frameOwnerId)) {
306             // No children are mapped yet -> only notify on changes of hasChildren.
307             m_frontend->childNodeCountUpdated(frameOwnerId, innerChildNodeCount(node));
308         } else {
309             // Re-add frame owner element together with its new children.
310             long parentId = m_documentNodeToIdMap.get(innerParentNode(node));
311             m_frontend->childNodeRemoved(parentId, frameOwnerId);
312             RefPtr<InspectorObject> value = buildObjectForNode(node, 0, &m_documentNodeToIdMap);
313             Node* previousSibling = innerPreviousSibling(node);
314             long prevId = previousSibling ? m_documentNodeToIdMap.get(previousSibling) : 0;
315             m_frontend->childNodeInserted(parentId, prevId, value.release());
316             // Invalidate children requested flag for the element.
317             m_childrenRequested.remove(m_childrenRequested.find(frameOwnerId));
318         }
319     }
320 }
321
322 long InspectorDOMAgent::bind(Node* node, NodeToIdMap* nodesMap)
323 {
324     long id = nodesMap->get(node);
325     if (id)
326         return id;
327     id = m_lastNodeId++;
328     nodesMap->set(node, id);
329     m_idToNode.set(id, node);
330     m_idToNodesMap.set(id, nodesMap);
331     return id;
332 }
333
334 void InspectorDOMAgent::unbind(Node* node, NodeToIdMap* nodesMap)
335 {
336     if (node->isFrameOwnerElement()) {
337         const HTMLFrameOwnerElement* frameOwner = static_cast<const HTMLFrameOwnerElement*>(node);
338         stopListening(frameOwner->contentDocument());
339         if (m_domListener)
340             m_domListener->didRemoveDocument(frameOwner->contentDocument());
341     }
342
343     long id = nodesMap->get(node);
344     if (!id)
345         return;
346     m_idToNode.remove(id);
347     nodesMap->remove(node);
348     bool childrenRequested = m_childrenRequested.contains(id);
349     if (childrenRequested) {
350         // Unbind subtree known to client recursively.
351         m_childrenRequested.remove(id);
352         Node* child = innerFirstChild(node);
353         while (child) {
354             unbind(child, nodesMap);
355             child = innerNextSibling(child);
356         }
357     }
358 }
359
360 bool InspectorDOMAgent::pushDocumentToFrontend()
361 {
362     Document* document = mainFrameDocument();
363     if (!document)
364         return false;
365     if (!m_documentNodeToIdMap.contains(document))
366         m_frontend->setDocument(buildObjectForNode(document, 2, &m_documentNodeToIdMap));
367     return true;
368 }
369
370 void InspectorDOMAgent::pushChildNodesToFrontend(long nodeId)
371 {
372     Node* node = nodeForId(nodeId);
373     if (!node || (node->nodeType() != Node::ELEMENT_NODE && node->nodeType() != Node::DOCUMENT_NODE && node->nodeType() != Node::DOCUMENT_FRAGMENT_NODE))
374         return;
375     if (m_childrenRequested.contains(nodeId))
376         return;
377
378     NodeToIdMap* nodeMap = m_idToNodesMap.get(nodeId);
379     RefPtr<InspectorArray> children = buildArrayForContainerChildren(node, 1, nodeMap);
380     m_childrenRequested.add(nodeId);
381     m_frontend->setChildNodes(nodeId, children.release());
382 }
383
384 long InspectorDOMAgent::inspectedNode(unsigned long num)
385 {
386     if (num < m_inspectedNodes.size())
387         return m_inspectedNodes[num];
388     return 0;
389 }
390
391 void InspectorDOMAgent::discardBindings()
392 {
393     m_documentNodeToIdMap.clear();
394     m_idToNode.clear();
395     releaseDanglingNodes();
396     m_childrenRequested.clear();
397     m_inspectedNodes.clear();
398     m_breakpoints.clear();
399 }
400
401 Node* InspectorDOMAgent::nodeForId(long id)
402 {
403     if (!id)
404         return 0;
405
406     HashMap<long, Node*>::iterator it = m_idToNode.find(id);
407     if (it != m_idToNode.end())
408         return it->second;
409     return 0;
410 }
411
412 void InspectorDOMAgent::getChildNodes(long nodeId)
413 {
414     pushChildNodesToFrontend(nodeId);
415 }
416
417 long InspectorDOMAgent::pushNodePathToFrontend(Node* nodeToPush)
418 {
419     ASSERT(nodeToPush);  // Invalid input
420
421     // If we are sending information to the client that is currently being created. Send root node first.
422     if (!pushDocumentToFrontend())
423         return 0;
424
425     // Return id in case the node is known.
426     long result = m_documentNodeToIdMap.get(nodeToPush);
427     if (result)
428         return result;
429
430     Node* node = nodeToPush;
431     Vector<Node*> path;
432     NodeToIdMap* danglingMap = 0;
433     while (true) {
434         Node* parent = innerParentNode(node);
435         if (!parent) {
436             // Node being pushed is detached -> push subtree root.
437             danglingMap = new NodeToIdMap();
438             m_danglingNodeToIdMaps.append(danglingMap);
439             m_frontend->setDetachedRoot(buildObjectForNode(node, 0, danglingMap));
440             break;
441         } else {
442             path.append(parent);
443             if (m_documentNodeToIdMap.get(parent))
444                 break;
445             else
446                 node = parent;
447         }
448     }
449
450     NodeToIdMap* map = danglingMap ? danglingMap : &m_documentNodeToIdMap;
451     for (int i = path.size() - 1; i >= 0; --i) {
452         long nodeId = map->get(path.at(i));
453         ASSERT(nodeId);
454         pushChildNodesToFrontend(nodeId);
455     }
456     return map->get(nodeToPush);
457 }
458
459 void InspectorDOMAgent::setAttribute(long elementId, const String& name, const String& value, bool* success)
460 {
461     Node* node = nodeForId(elementId);
462     if (node && (node->nodeType() == Node::ELEMENT_NODE)) {
463         Element* element = static_cast<Element*>(node);
464         ExceptionCode ec = 0;
465         element->setAttribute(name, value, ec);
466         *success = !ec;
467     }
468 }
469
470 void InspectorDOMAgent::removeAttribute(long elementId, const String& name, bool* success)
471 {
472     Node* node = nodeForId(elementId);
473     if (node && (node->nodeType() == Node::ELEMENT_NODE)) {
474         Element* element = static_cast<Element*>(node);
475         ExceptionCode ec = 0;
476         element->removeAttribute(name, ec);
477         *success = !ec;
478     }
479 }
480
481 void InspectorDOMAgent::removeNode(long nodeId, long* outNodeId)
482 {
483     Node* node = nodeForId(nodeId);
484     if (!node)
485         return;
486
487     ContainerNode* parentNode = node->parentNode();
488     if (!parentNode)
489         return;
490
491     ExceptionCode ec = 0;
492     parentNode->removeChild(node, ec);
493     if (ec)
494         return;
495
496     *outNodeId = nodeId;
497 }
498
499 void InspectorDOMAgent::changeTagName(long nodeId, const String& tagName, long* newId)
500 {
501     Node* oldNode = nodeForId(nodeId);
502     if (!oldNode || !oldNode->isElementNode())
503         return;
504
505     ExceptionCode ec = 0;
506     RefPtr<Element> newElem = oldNode->document()->createElement(tagName, ec);
507     if (ec)
508         return;
509
510     // Copy over the original node's attributes.
511     Element* oldElem = static_cast<Element*>(oldNode);
512     newElem->copyNonAttributeProperties(oldElem);
513     if (oldElem->attributes())
514         newElem->attributes()->setAttributes(*(oldElem->attributes(true)));
515
516     // Copy over the original node's children.
517     Node* child;
518     while ((child = oldNode->firstChild()))
519         newElem->appendChild(child, ec);
520
521     // Replace the old node with the new node
522     ContainerNode* parent = oldNode->parentNode();
523     parent->insertBefore(newElem, oldNode->nextSibling(), ec);
524     parent->removeChild(oldNode, ec);
525
526     if (ec)
527         return;
528
529     *newId = pushNodePathToFrontend(newElem.get());
530     if (m_childrenRequested.contains(nodeId))
531         pushChildNodesToFrontend(*newId);
532 }
533
534 void InspectorDOMAgent::getOuterHTML(long nodeId, WTF::String* outerHTML)
535 {
536     Node* node = nodeForId(nodeId);
537     if (!node || !node->isHTMLElement())
538         return;
539
540     *outerHTML = static_cast<HTMLElement*>(node)->outerHTML();
541 }
542
543 void InspectorDOMAgent::setOuterHTML(long nodeId, const String& outerHTML, long* newId)
544 {
545     Node* node = nodeForId(nodeId);
546     if (!node || !node->isHTMLElement())
547         return;
548
549     bool requiresTotalUpdate = node->nodeName() == "HTML" || node->nodeName() == "BODY" || node->nodeName() == "HEAD";
550
551     bool childrenRequested = m_childrenRequested.contains(nodeId);
552     Node* previousSibling = node->previousSibling();
553     ContainerNode* parentNode = node->parentNode();
554
555     HTMLElement* htmlElement = static_cast<HTMLElement*>(node);
556     ExceptionCode ec = 0;
557     htmlElement->setOuterHTML(outerHTML, ec);
558     if (ec)
559         return;
560
561     if (requiresTotalUpdate) {
562         Document* document = mainFrameDocument();
563         reset();
564         setDocument(document);
565         *newId = 0;
566         return;
567     }
568
569     Node* newNode = previousSibling ? previousSibling->nextSibling() : parentNode->firstChild();
570     if (!newNode) {
571         // The only child node has been deleted.
572         *newId = 0;
573         return;
574     }
575
576     *newId = pushNodePathToFrontend(newNode);
577     if (childrenRequested)
578         pushChildNodesToFrontend(*newId);
579 }
580
581 void InspectorDOMAgent::setTextNodeValue(long nodeId, const String& value, bool* success)
582 {
583     Node* node = nodeForId(nodeId);
584     if (node && (node->nodeType() == Node::TEXT_NODE)) {
585         Text* text_node = static_cast<Text*>(node);
586         ExceptionCode ec = 0;
587         text_node->replaceWholeText(value, ec);
588         *success = !ec;
589     }
590 }
591
592 void InspectorDOMAgent::getEventListenersForNode(long nodeId, long* outNodeId, RefPtr<InspectorArray>* listenersArray)
593 {
594     Node* node = nodeForId(nodeId);
595     *outNodeId = nodeId;
596     EventTargetData* d;
597
598     // Quick break if a null node or no listeners at all
599     if (!node || !(d = node->eventTargetData()))
600         return;
601
602     // Get the list of event types this Node is concerned with
603     Vector<AtomicString> eventTypes;
604     const EventListenerMap& listenerMap = d->eventListenerMap;
605     EventListenerMap::const_iterator end = listenerMap.end();
606     for (EventListenerMap::const_iterator iter = listenerMap.begin(); iter != end; ++iter)
607         eventTypes.append(iter->first);
608
609     // Quick break if no useful listeners
610     size_t eventTypesLength = eventTypes.size();
611     if (!eventTypesLength)
612         return;
613
614     // The Node's Event Ancestors (not including self)
615     Vector<EventContext> ancestors;
616     node->getEventAncestors(ancestors, node);
617
618     // Nodes and their Listeners for the concerned event types (order is top to bottom)
619     Vector<EventListenerInfo> eventInformation;
620     for (size_t i = ancestors.size(); i; --i) {
621         Node* ancestor = ancestors[i - 1].node();
622         for (size_t j = 0; j < eventTypesLength; ++j) {
623             AtomicString& type = eventTypes[j];
624             if (ancestor->hasEventListeners(type))
625                 eventInformation.append(EventListenerInfo(static_cast<Node*>(ancestor), type, ancestor->getEventListeners(type)));
626         }
627     }
628
629     // Insert the Current Node at the end of that list (last in capturing, first in bubbling)
630     for (size_t i = 0; i < eventTypesLength; ++i) {
631         const AtomicString& type = eventTypes[i];
632         eventInformation.append(EventListenerInfo(node, type, node->getEventListeners(type)));
633     }
634
635     // Get Capturing Listeners (in this order)
636     size_t eventInformationLength = eventInformation.size();
637     for (size_t i = 0; i < eventInformationLength; ++i) {
638         const EventListenerInfo& info = eventInformation[i];
639         const EventListenerVector& vector = info.eventListenerVector;
640         for (size_t j = 0; j < vector.size(); ++j) {
641             const RegisteredEventListener& listener = vector[j];
642             if (listener.useCapture)
643                 (*listenersArray)->pushObject(buildObjectForEventListener(listener, info.eventType, info.node));
644         }
645     }
646
647     // Get Bubbling Listeners (reverse order)
648     for (size_t i = eventInformationLength; i; --i) {
649         const EventListenerInfo& info = eventInformation[i - 1];
650         const EventListenerVector& vector = info.eventListenerVector;
651         for (size_t j = 0; j < vector.size(); ++j) {
652             const RegisteredEventListener& listener = vector[j];
653             if (!listener.useCapture)
654                 (*listenersArray)->pushObject(buildObjectForEventListener(listener, info.eventType, info.node));
655         }
656     }
657 }
658
659 void InspectorDOMAgent::addInspectedNode(long nodeId)
660 {
661     m_inspectedNodes.prepend(nodeId);
662     while (m_inspectedNodes.size() > 5)
663         m_inspectedNodes.removeLast();
664 }
665
666 void InspectorDOMAgent::performSearch(const String& whitespaceTrimmedQuery, bool runSynchronously)
667 {
668     // FIXME: Few things are missing here:
669     // 1) Search works with node granularity - number of matches within node is not calculated.
670     // 2) There is no need to push all search results to the front-end at a time, pushing next / previous result
671     //    is sufficient.
672
673     unsigned queryLength = whitespaceTrimmedQuery.length();
674     bool startTagFound = !whitespaceTrimmedQuery.find('<');
675     bool endTagFound = whitespaceTrimmedQuery.reverseFind('>') + 1 == queryLength;
676
677     String tagNameQuery = whitespaceTrimmedQuery;
678     if (startTagFound || endTagFound)
679         tagNameQuery = tagNameQuery.substring(startTagFound ? 1 : 0, endTagFound ? queryLength - 1 : queryLength);
680     if (!Document::isValidName(tagNameQuery))
681         tagNameQuery = "";
682
683     String attributeNameQuery = whitespaceTrimmedQuery;
684     if (!Document::isValidName(attributeNameQuery))
685         attributeNameQuery = "";
686
687     String escapedQuery = whitespaceTrimmedQuery;
688     escapedQuery.replace("'", "\\'");
689     String escapedTagNameQuery = tagNameQuery;
690     escapedTagNameQuery.replace("'", "\\'");
691
692     // Clear pending jobs.
693     searchCanceled();
694
695     // Find all frames, iframes and object elements to search their documents.
696     for (Frame* frame = mainFrameDocument()->frame(); frame; frame = frame->tree()->traverseNext()) {
697         Document* document = frame->document();
698         if (!document)
699             continue;
700
701         if (!tagNameQuery.isEmpty() && startTagFound && endTagFound) {
702             m_pendingMatchJobs.append(new MatchExactTagNamesJob(document, tagNameQuery));
703             m_pendingMatchJobs.append(new MatchPlainTextJob(document, escapedQuery));
704             continue;
705         }
706
707         if (!tagNameQuery.isEmpty() && startTagFound) {
708             m_pendingMatchJobs.append(new MatchXPathJob(document, "//*[starts-with(name(), '" + escapedTagNameQuery + "')]"));
709             m_pendingMatchJobs.append(new MatchPlainTextJob(document, escapedQuery));
710             continue;
711         }
712
713         if (!tagNameQuery.isEmpty() && endTagFound) {
714             // FIXME: we should have a matchEndOfTagNames search function if endTagFound is true but not startTagFound.
715             // This requires ends-with() support in XPath, WebKit only supports starts-with() and contains().
716             m_pendingMatchJobs.append(new MatchXPathJob(document, "//*[contains(name(), '" + escapedTagNameQuery + "')]"));
717             m_pendingMatchJobs.append(new MatchPlainTextJob(document, escapedQuery));
718             continue;
719         }
720
721         bool matchesEveryNode = whitespaceTrimmedQuery == "//*" || whitespaceTrimmedQuery == "*";
722         if (matchesEveryNode) {
723             // These queries will match every node. Matching everything isn't useful and can be slow for large pages,
724             // so limit the search functions list to plain text and attribute matching for these.
725             m_pendingMatchJobs.append(new MatchXPathJob(document, "//*[contains(@*, '" + escapedQuery + "')]"));
726             m_pendingMatchJobs.append(new MatchPlainTextJob(document, escapedQuery));
727             continue;
728         }
729
730         m_pendingMatchJobs.append(new MatchExactIdJob(document, whitespaceTrimmedQuery));
731         m_pendingMatchJobs.append(new MatchExactClassNamesJob(document, whitespaceTrimmedQuery));
732         m_pendingMatchJobs.append(new MatchExactTagNamesJob(document, tagNameQuery));
733         m_pendingMatchJobs.append(new MatchQuerySelectorAllJob(document, "[" + attributeNameQuery + "]"));
734         m_pendingMatchJobs.append(new MatchQuerySelectorAllJob(document, whitespaceTrimmedQuery));
735         m_pendingMatchJobs.append(new MatchXPathJob(document, "//*[contains(@*, '" + escapedQuery + "')]"));
736         if (!tagNameQuery.isEmpty())
737             m_pendingMatchJobs.append(new MatchXPathJob(document, "//*[contains(name(), '" + escapedTagNameQuery + "')]"));
738         m_pendingMatchJobs.append(new MatchPlainTextJob(document, escapedQuery));
739         m_pendingMatchJobs.append(new MatchXPathJob(document, whitespaceTrimmedQuery));
740     }
741
742     if (runSynchronously) {
743         // For tests.
744         ListHashSet<Node*> resultCollector;
745         for (Deque<MatchJob*>::iterator it = m_pendingMatchJobs.begin(); it != m_pendingMatchJobs.end(); ++it)
746             (*it)->match(resultCollector);
747         reportNodesAsSearchResults(resultCollector);
748         searchCanceled();
749         return;
750     }
751     m_matchJobsTimer.startOneShot(0);
752 }
753
754 void InspectorDOMAgent::searchCanceled()
755 {
756     if (m_matchJobsTimer.isActive())
757         m_matchJobsTimer.stop();
758     deleteAllValues(m_pendingMatchJobs);
759     m_pendingMatchJobs.clear();
760     m_searchResults.clear();
761 }
762
763 void InspectorDOMAgent::setDOMBreakpoint(long nodeId, long type)
764 {
765     Node* node = nodeForId(nodeId);
766     if (!node)
767         return;
768
769     uint32_t rootBit = 1 << type;
770     m_breakpoints.set(node, m_breakpoints.get(node) | rootBit);
771     if (rootBit & inheritableDOMBreakpointTypesMask) {
772         for (Node* child = innerFirstChild(node); child; child = innerNextSibling(child))
773             updateSubtreeBreakpoints(child, rootBit, true);
774     }
775 }
776
777 void InspectorDOMAgent::removeDOMBreakpoint(long nodeId, long type)
778 {
779     Node* node = nodeForId(nodeId);
780     if (!node)
781         return;
782
783     uint32_t rootBit = 1 << type;
784     uint32_t mask = m_breakpoints.get(node) & ~rootBit;
785     if (mask)
786         m_breakpoints.set(node, mask);
787     else
788         m_breakpoints.remove(node);
789
790     if ((rootBit & inheritableDOMBreakpointTypesMask) && !(mask & (rootBit << domBreakpointDerivedTypeShift))) {
791         for (Node* child = innerFirstChild(node); child; child = innerNextSibling(child))
792             updateSubtreeBreakpoints(child, rootBit, false);
793     }
794 }
795
796 bool InspectorDOMAgent::shouldBreakOnNodeInsertion(Node*, Node* parent, PassRefPtr<InspectorObject> details)
797 {
798     if (hasBreakpoint(parent, SubtreeModified)) {
799         descriptionForDOMEvent(parent, SubtreeModified, true, details);
800         return true;
801     }
802     return false;
803 }
804
805 bool InspectorDOMAgent::shouldBreakOnNodeRemoval(Node* node, PassRefPtr<InspectorObject> details)
806 {
807     if (hasBreakpoint(node, NodeRemoved)) {
808         descriptionForDOMEvent(node, NodeRemoved, false, details);
809         return true;
810     }
811     if (hasBreakpoint(innerParentNode(node), SubtreeModified)) {
812         descriptionForDOMEvent(node, SubtreeModified, false, details);
813         return true;
814     }
815     return false;
816 }
817
818 bool InspectorDOMAgent::shouldBreakOnAttributeModification(Element* element, PassRefPtr<InspectorObject> details)
819 {
820     if (hasBreakpoint(element, AttributeModified)) {
821         descriptionForDOMEvent(element, AttributeModified, false, details);
822         return true;
823     }
824     return false;
825 }
826
827 void InspectorDOMAgent::descriptionForDOMEvent(Node* target, long breakpointType, bool insertion, PassRefPtr<InspectorObject> description)
828 {
829     ASSERT(hasBreakpoint(target, breakpointType));
830
831     Node* breakpointOwner = target;
832     if ((1 << breakpointType) & inheritableDOMBreakpointTypesMask) {
833         // For inheritable breakpoint types, target node isn't always the same as the node that owns a breakpoint.
834         // Target node may be unknown to frontend, so we need to push it first.
835         long targetNodeId = pushNodePathToFrontend(target);
836         ASSERT(targetNodeId);
837         description->setNumber("targetNodeId", targetNodeId);
838
839         // Find breakpoint owner node.
840         if (!insertion)
841             breakpointOwner = innerParentNode(target);
842         ASSERT(breakpointOwner);
843         while (!(m_breakpoints.get(breakpointOwner) & (1 << breakpointType))) {
844             breakpointOwner = innerParentNode(breakpointOwner);
845             ASSERT(breakpointOwner);
846         }
847
848         if (breakpointType == SubtreeModified)
849             description->setBoolean("insertion", insertion);
850     }
851
852     long breakpointOwnerNodeId = m_documentNodeToIdMap.get(breakpointOwner);
853     ASSERT(breakpointOwnerNodeId);
854     description->setNumber("nodeId", breakpointOwnerNodeId);
855     description->setNumber("type", breakpointType);
856 }
857
858 String InspectorDOMAgent::documentURLString(Document* document) const
859 {
860     if (!document || document->url().isNull())
861         return "";
862     return document->url().string();
863 }
864
865 PassRefPtr<InspectorObject> InspectorDOMAgent::buildObjectForNode(Node* node, int depth, NodeToIdMap* nodesMap)
866 {
867     RefPtr<InspectorObject> value = InspectorObject::create();
868
869     long id = bind(node, nodesMap);
870     String nodeName;
871     String localName;
872     String nodeValue;
873
874     switch (node->nodeType()) {
875         case Node::TEXT_NODE:
876         case Node::COMMENT_NODE:
877         case Node::CDATA_SECTION_NODE:
878             nodeValue = node->nodeValue();
879             break;
880         case Node::ATTRIBUTE_NODE:
881             localName = node->localName();
882             break;
883         case Node::DOCUMENT_FRAGMENT_NODE:
884             break;
885         case Node::DOCUMENT_NODE:
886         case Node::ELEMENT_NODE:
887         default:
888             nodeName = node->nodeName();
889             localName = node->localName();
890             break;
891     }
892
893     value->setNumber("id", id);
894     value->setNumber("nodeType", node->nodeType());
895     value->setString("nodeName", nodeName);
896     value->setString("localName", localName);
897     value->setString("nodeValue", nodeValue);
898
899     if (node->nodeType() == Node::ELEMENT_NODE || node->nodeType() == Node::DOCUMENT_NODE || node->nodeType() == Node::DOCUMENT_FRAGMENT_NODE) {
900         int nodeCount = innerChildNodeCount(node);
901         value->setNumber("childNodeCount", nodeCount);
902         RefPtr<InspectorArray> children = buildArrayForContainerChildren(node, depth, nodesMap);
903         if (children->length() > 0)
904             value->setArray("children", children.release());
905
906         if (node->nodeType() == Node::ELEMENT_NODE) {
907             Element* element = static_cast<Element*>(node);
908             value->setArray("attributes", buildArrayForElementAttributes(element));
909             if (node->isFrameOwnerElement()) {
910                 HTMLFrameOwnerElement* frameOwner = static_cast<HTMLFrameOwnerElement*>(node);
911                 value->setString("documentURL", documentURLString(frameOwner->contentDocument()));
912             }
913         } else if (node->nodeType() == Node::DOCUMENT_NODE) {
914             Document* document = static_cast<Document*>(node);
915             value->setString("documentURL", documentURLString(document));
916         }
917     } else if (node->nodeType() == Node::DOCUMENT_TYPE_NODE) {
918         DocumentType* docType = static_cast<DocumentType*>(node);
919         value->setString("publicId", docType->publicId());
920         value->setString("systemId", docType->systemId());
921         value->setString("internalSubset", docType->internalSubset());
922     } else if (node->nodeType() == Node::ATTRIBUTE_NODE) {
923         Attr* attribute = static_cast<Attr*>(node);
924         value->setString("name", attribute->name());
925         value->setString("value", attribute->value());
926     }
927     return value.release();
928 }
929
930 PassRefPtr<InspectorArray> InspectorDOMAgent::buildArrayForElementAttributes(Element* element)
931 {
932     RefPtr<InspectorArray> attributesValue = InspectorArray::create();
933     // Go through all attributes and serialize them.
934     const NamedNodeMap* attrMap = element->attributes(true);
935     if (!attrMap)
936         return attributesValue.release();
937     unsigned numAttrs = attrMap->length();
938     for (unsigned i = 0; i < numAttrs; ++i) {
939         // Add attribute pair
940         const Attribute *attribute = attrMap->attributeItem(i);
941         attributesValue->pushString(attribute->name().toString());
942         attributesValue->pushString(attribute->value());
943     }
944     return attributesValue.release();
945 }
946
947 PassRefPtr<InspectorArray> InspectorDOMAgent::buildArrayForContainerChildren(Node* container, int depth, NodeToIdMap* nodesMap)
948 {
949     RefPtr<InspectorArray> children = InspectorArray::create();
950     if (depth == 0) {
951         // Special case the_only text child.
952         if (innerChildNodeCount(container) == 1) {
953             Node *child = innerFirstChild(container);
954             if (child->nodeType() == Node::TEXT_NODE)
955                 children->pushObject(buildObjectForNode(child, 0, nodesMap));
956         }
957         return children.release();
958     } else if (depth > 0) {
959         depth--;
960     }
961
962     for (Node *child = innerFirstChild(container); child; child = innerNextSibling(child))
963         children->pushObject(buildObjectForNode(child, depth, nodesMap));
964     return children.release();
965 }
966
967 PassRefPtr<InspectorObject> InspectorDOMAgent::buildObjectForEventListener(const RegisteredEventListener& registeredEventListener, const AtomicString& eventType, Node* node)
968 {
969     RefPtr<EventListener> eventListener = registeredEventListener.listener;
970     RefPtr<InspectorObject> value = InspectorObject::create();
971     value->setString("type", eventType);
972     value->setBoolean("useCapture", registeredEventListener.useCapture);
973     value->setBoolean("isAttribute", eventListener->isAttribute());
974     value->setNumber("nodeId", pushNodePathToFrontend(node));
975     value->setString("listenerBody", eventListenerHandlerBody(node->document(), eventListener.get()));
976     String sourceName;
977     int lineNumber;
978     if (eventListenerHandlerLocation(node->document(), eventListener.get(), sourceName, lineNumber)) {
979         value->setString("sourceName", sourceName);
980         value->setNumber("lineNumber", lineNumber);
981     }
982     return value.release();
983 }
984
985 Node* InspectorDOMAgent::innerFirstChild(Node* node)
986 {
987     if (node->isFrameOwnerElement()) {
988         HTMLFrameOwnerElement* frameOwner = static_cast<HTMLFrameOwnerElement*>(node);
989         Document* doc = frameOwner->contentDocument();
990         if (doc) {
991             startListening(doc);
992             return doc->firstChild();
993         }
994     }
995     node = node->firstChild();
996     while (isWhitespace(node))
997         node = node->nextSibling();
998     return node;
999 }
1000
1001 Node* InspectorDOMAgent::innerNextSibling(Node* node)
1002 {
1003     do {
1004         node = node->nextSibling();
1005     } while (isWhitespace(node));
1006     return node;
1007 }
1008
1009 Node* InspectorDOMAgent::innerPreviousSibling(Node* node)
1010 {
1011     do {
1012         node = node->previousSibling();
1013     } while (isWhitespace(node));
1014     return node;
1015 }
1016
1017 unsigned InspectorDOMAgent::innerChildNodeCount(Node* node)
1018 {
1019     unsigned count = 0;
1020     Node* child = innerFirstChild(node);
1021     while (child) {
1022         count++;
1023         child = innerNextSibling(child);
1024     }
1025     return count;
1026 }
1027
1028 Node* InspectorDOMAgent::innerParentNode(Node* node)
1029 {
1030     ContainerNode* parent = node->parentNode();
1031     if (parent && parent->isDocumentNode())
1032         return static_cast<Document*>(parent)->ownerElement();
1033     return parent;
1034 }
1035
1036 bool InspectorDOMAgent::isWhitespace(Node* node)
1037 {
1038     //TODO: pull ignoreWhitespace setting from the frontend and use here.
1039     return node && node->nodeType() == Node::TEXT_NODE && node->nodeValue().stripWhiteSpace().length() == 0;
1040 }
1041
1042 Document* InspectorDOMAgent::mainFrameDocument() const
1043 {
1044     ListHashSet<RefPtr<Document> >::const_iterator it = m_documents.begin();
1045     if (it != m_documents.end())
1046         return it->get();
1047     return 0;
1048 }
1049
1050 bool InspectorDOMAgent::operator==(const EventListener& listener)
1051 {
1052     if (const InspectorDOMAgent* inspectorDOMAgentListener = InspectorDOMAgent::cast(&listener))
1053         return mainFrameDocument() == inspectorDOMAgentListener->mainFrameDocument();
1054     return false;
1055 }
1056
1057 void InspectorDOMAgent::didInsertDOMNode(Node* node)
1058 {
1059     if (isWhitespace(node))
1060         return;
1061
1062     if (m_breakpoints.size()) {
1063         uint32_t mask = m_breakpoints.get(innerParentNode(node));
1064         uint32_t inheritableTypesMask = (mask | (mask >> domBreakpointDerivedTypeShift)) & inheritableDOMBreakpointTypesMask;
1065         if (inheritableTypesMask)
1066             updateSubtreeBreakpoints(node, inheritableTypesMask, true);
1067     }
1068
1069     // We could be attaching existing subtree. Forget the bindings.
1070     unbind(node, &m_documentNodeToIdMap);
1071
1072     ContainerNode* parent = node->parentNode();
1073     long parentId = m_documentNodeToIdMap.get(parent);
1074     // Return if parent is not mapped yet.
1075     if (!parentId)
1076         return;
1077
1078     if (!m_childrenRequested.contains(parentId)) {
1079         // No children are mapped yet -> only notify on changes of hasChildren.
1080         m_frontend->childNodeCountUpdated(parentId, innerChildNodeCount(parent));
1081     } else {
1082         // Children have been requested -> return value of a new child.
1083         Node* prevSibling = innerPreviousSibling(node);
1084         long prevId = prevSibling ? m_documentNodeToIdMap.get(prevSibling) : 0;
1085         RefPtr<InspectorObject> value = buildObjectForNode(node, 0, &m_documentNodeToIdMap);
1086         m_frontend->childNodeInserted(parentId, prevId, value.release());
1087     }
1088 }
1089
1090 void InspectorDOMAgent::didRemoveDOMNode(Node* node)
1091 {
1092     if (isWhitespace(node))
1093         return;
1094
1095     if (m_breakpoints.size()) {
1096         // Remove subtree breakpoints.
1097         m_breakpoints.remove(node);
1098         Vector<Node*> stack(1, innerFirstChild(node));
1099         do {
1100             Node* node = stack.last();
1101             stack.removeLast();
1102             if (!node)
1103                 continue;
1104             m_breakpoints.remove(node);
1105             stack.append(innerFirstChild(node));
1106             stack.append(innerNextSibling(node));
1107         } while (!stack.isEmpty());
1108     }
1109
1110     ContainerNode* parent = node->parentNode();
1111     long parentId = m_documentNodeToIdMap.get(parent);
1112     // If parent is not mapped yet -> ignore the event.
1113     if (!parentId)
1114         return;
1115
1116     if (m_domListener)
1117         m_domListener->didRemoveDOMNode(node);
1118
1119     if (!m_childrenRequested.contains(parentId)) {
1120         // No children are mapped yet -> only notify on changes of hasChildren.
1121         if (innerChildNodeCount(parent) == 1)
1122             m_frontend->childNodeCountUpdated(parentId, 0);
1123     } else
1124         m_frontend->childNodeRemoved(parentId, m_documentNodeToIdMap.get(node));
1125     unbind(node, &m_documentNodeToIdMap);
1126 }
1127
1128 void InspectorDOMAgent::didModifyDOMAttr(Element* element)
1129 {
1130     long id = m_documentNodeToIdMap.get(element);
1131     // If node is not mapped yet -> ignore the event.
1132     if (!id)
1133         return;
1134
1135     if (m_domListener)
1136         m_domListener->didModifyDOMAttr(element);
1137
1138     m_frontend->attributesUpdated(id, buildArrayForElementAttributes(element));
1139 }
1140
1141 void InspectorDOMAgent::characterDataModified(CharacterData* characterData)
1142 {
1143     long id = m_documentNodeToIdMap.get(characterData);
1144     if (!id)
1145         return;
1146     m_frontend->characterDataModified(id, characterData->data());
1147 }
1148
1149 bool InspectorDOMAgent::hasBreakpoint(Node* node, long type)
1150 {
1151     uint32_t rootBit = 1 << type;
1152     uint32_t derivedBit = rootBit << domBreakpointDerivedTypeShift;
1153     return m_breakpoints.get(node) & (rootBit | derivedBit);
1154 }
1155
1156 void InspectorDOMAgent::updateSubtreeBreakpoints(Node* node, uint32_t rootMask, bool set)
1157 {
1158     uint32_t oldMask = m_breakpoints.get(node);
1159     uint32_t derivedMask = rootMask << domBreakpointDerivedTypeShift;
1160     uint32_t newMask = set ? oldMask | derivedMask : oldMask & ~derivedMask;
1161     if (newMask)
1162         m_breakpoints.set(node, newMask);
1163     else
1164         m_breakpoints.remove(node);
1165
1166     uint32_t newRootMask = rootMask & ~newMask;
1167     if (!newRootMask)
1168         return;
1169
1170     for (Node* child = innerFirstChild(node); child; child = innerNextSibling(child))
1171         updateSubtreeBreakpoints(child, newRootMask, set);
1172 }
1173
1174 Node* InspectorDOMAgent::nodeForPath(const String& path)
1175 {
1176     // The path is of form "1,HTML,2,BODY,1,DIV"
1177     Node* node = mainFrameDocument();
1178     if (!node)
1179         return 0;
1180
1181     Vector<String> pathTokens;
1182     path.split(",", false, pathTokens);
1183     if (!pathTokens.size())
1184         return 0;
1185     for (size_t i = 0; i < pathTokens.size() - 1; i += 2) {
1186         bool success = true;
1187         unsigned childNumber = pathTokens[i].toUInt(&success);
1188         if (!success)
1189             return 0;
1190         if (childNumber >= innerChildNodeCount(node))
1191             return 0;
1192
1193         Node* child = innerFirstChild(node);
1194         String childName = pathTokens[i + 1];
1195         for (size_t j = 0; child && j < childNumber; ++j)
1196             child = innerNextSibling(child);
1197
1198         if (!child || child->nodeName() != childName)
1199             return 0;
1200         node = child;
1201     }
1202     return node;
1203 }
1204
1205 PassRefPtr<InspectorArray> InspectorDOMAgent::toArray(const Vector<String>& data)
1206 {
1207     RefPtr<InspectorArray> result = InspectorArray::create();
1208     for (unsigned i = 0; i < data.size(); ++i)
1209         result->pushString(data[i]);
1210     return result.release();
1211 }
1212
1213 void InspectorDOMAgent::onMatchJobsTimer(Timer<InspectorDOMAgent>*)
1214 {
1215     if (!m_pendingMatchJobs.size()) {
1216         searchCanceled();
1217         return;
1218     }
1219
1220     ListHashSet<Node*> resultCollector;
1221     MatchJob* job = m_pendingMatchJobs.takeFirst();
1222     job->match(resultCollector);
1223     delete job;
1224
1225     reportNodesAsSearchResults(resultCollector);
1226
1227     m_matchJobsTimer.startOneShot(0.025);
1228 }
1229
1230 void InspectorDOMAgent::reportNodesAsSearchResults(ListHashSet<Node*>& resultCollector)
1231 {
1232     RefPtr<InspectorArray> nodeIds = InspectorArray::create();
1233     for (ListHashSet<Node*>::iterator it = resultCollector.begin(); it != resultCollector.end(); ++it) {
1234         if (m_searchResults.contains(*it))
1235             continue;
1236         m_searchResults.add(*it);
1237         nodeIds->pushNumber(static_cast<long long>(pushNodePathToFrontend(*it)));
1238     }
1239     m_frontend->addNodesToSearchResult(nodeIds.release());
1240 }
1241
1242 void InspectorDOMAgent::copyNode(long nodeId)
1243 {
1244     Node* node = nodeForId(nodeId);
1245     if (!node)
1246         return;
1247     String markup = createMarkup(node);
1248     Pasteboard::generalPasteboard()->writePlainText(markup);
1249 }
1250
1251 void InspectorDOMAgent::pushNodeByPathToFrontend(const String& path, long* nodeId)
1252 {
1253     if (Node* node = nodeForPath(path))
1254         *nodeId = pushNodePathToFrontend(node);
1255 }
1256
1257 } // namespace WebCore
1258
1259 #endif // ENABLE(INSPECTOR)