Oilpan: Remove RefPtrs to Node and its subclasses in core/inspector/ with Oilpan transition types.

Source/core/inspector/InspectorDOMAgent.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * 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
@@ skipping 173 matching lines @@
     WTF_MAKE_FAST_ALLOCATED;
 public:
     RevalidateStyleAttributeTask(InspectorDOMAgent*);
     void scheduleFor(Element*);
     void reset() { m_timer.stop(); }
     void onTimer(Timer<RevalidateStyleAttributeTask>*);
 
 private:
     InspectorDOMAgent* m_domAgent;
     Timer<RevalidateStyleAttributeTask> m_timer;
-    HashSet<RefPtr<Element> > m_elements;
+    WillBePersistentHeapHashSet<RefPtrWillBeMember<Element> > m_elements;
 };
 
 RevalidateStyleAttributeTask::RevalidateStyleAttributeTask(InspectorDOMAgent* domAgent)
     : m_domAgent(domAgent)
     , m_timer(this, &RevalidateStyleAttributeTask::onTimer)
 {
 }
 
 void RevalidateStyleAttributeTask::scheduleFor(Element* element)
 {
     m_elements.add(element);
     if (!m_timer.isActive())
         m_timer.startOneShot(0, FROM_HERE);
 }
 
 void RevalidateStyleAttributeTask::onTimer(Timer<RevalidateStyleAttributeTask>*)
 {
     // The timer is stopped on m_domAgent destruction, so this method will never be called after m_domAgent has been destroyed.
-    Vector<Element*> elements;
-    for (HashSet<RefPtr<Element> >::iterator it = m_elements.begin(), end = m_elements.end(); it != end; ++it)
+    WillBeHeapVector<RawPtrWillBeMember<Element> > elements;
+    for (WillBePersistentHeapHashSet<RefPtrWillBeMember<Element> >::iterator it = m_elements.begin(), end = m_elements.end(); it != end; ++it)
         elements.append(it->get());
     m_domAgent->styleAttributeInvalidated(elements);
 
     m_elements.clear();
 }
 
 String InspectorDOMAgent::toErrorString(ExceptionState& exceptionState)
 {
     if (exceptionState.hadException())
         return DOMException::getErrorName(exceptionState.code()) + " " + exceptionState.message();
     return "";
 }
 
 InspectorDOMAgent::InspectorDOMAgent(InspectorPageAgent* pageAgent, InjectedScriptManager* injectedScriptManager, InspectorOverlay* overlay)
     : InspectorBaseAgent<InspectorDOMAgent>("DOM")
     , m_pageAgent(pageAgent)
     , m_injectedScriptManager(injectedScriptManager)
     , m_overlay(overlay)
     , m_frontend(0)
     , m_domListener(0)
+    , m_documentNodeToIdMap(adoptPtrWillBeNoop(new NodeToIdMap()))
     , m_lastNodeId(1)
     , m_searchingForNode(NotSearching)
     , m_suppressAttributeModifiedEvent(false)
     , m_listener(0)
 {
 }
 
 InspectorDOMAgent::~InspectorDOMAgent()
 {
     reset();
@@ skipping 134 matching lines @@
     bool childrenRequested = m_childrenRequested.contains(id);
     if (childrenRequested) {
         // Unbind subtree known to client recursively.
         m_childrenRequested.remove(id);
         Node* child = innerFirstChild(node);
         while (child) {
             unbind(child, nodesMap);
             child = innerNextSibling(child);
         }
     }
-    if (nodesMap == &m_documentNodeToIdMap)
+    if (nodesMap == m_documentNodeToIdMap.get())
         m_cachedChildCount.remove(id);
 }
 
 Node* InspectorDOMAgent::assertNode(ErrorString* errorString, int nodeId)
 {
     Node* node = nodeForId(nodeId);
     if (!node) {
         *errorString = "Could not find node with given id";
         return 0;
     }
@@ skipping 113 matching lines @@
     // Backward compatibility. Mark agent as enabled when it requests document.
     enable(errorString);
 
     if (!m_document) {
         *errorString = "Document is not available";
         return;
     }
 
     discardFrontendBindings();
 
-    root = buildObjectForNode(m_document.get(), 2, &m_documentNodeToIdMap);
+    root = buildObjectForNode(m_document.get(), 2, m_documentNodeToIdMap.get());
 }
 
 void InspectorDOMAgent::pushChildNodesToFrontend(int nodeId, int depth)
 {
     Node* node = nodeForId(nodeId);
     if (!node || (!node->isElementNode() && !node->isDocumentNode() && !node->isDocumentFragment()))
         return;
 
     NodeToIdMap* nodeMap = m_idToNodesMap.get(nodeId);
 
@@ skipping 14 matching lines @@
 
     RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > children = buildArrayForContainerChildren(node, depth, nodeMap);
     m_frontend->setChildNodes(nodeId, children.release());
 }
 
 void InspectorDOMAgent::discardFrontendBindings()
 {
     if (m_history)
         m_history->reset();
     m_searchResults.clear();
-    m_documentNodeToIdMap.clear();
+    m_documentNodeToIdMap->clear();
     m_idToNode.clear();
     releaseDanglingNodes();
     m_childrenRequested.clear();
     m_cachedChildCount.clear();
     if (m_revalidateStyleAttrTask)
         m_revalidateStyleAttrTask->reset();
 }
 
 Node* InspectorDOMAgent::nodeForId(int id)
 {
     if (!id)
         return 0;
 
-    HashMap<int, Node*>::iterator it = m_idToNode.find(id);
+    WillBeHeapHashMap<int, RawPtrWillBeMember<Node> >::iterator it = m_idToNode.find(id);
     if (it != m_idToNode.end())
         return it->value;
     return 0;
 }
 
 void InspectorDOMAgent::requestChildNodes(ErrorString* errorString, int nodeId, const int* depth)
 {
     int sanitizedDepth;
 
     if (!depth)
@@ skipping 11 matching lines @@
 }
 
 void InspectorDOMAgent::querySelector(ErrorString* errorString, int nodeId, const String& selectors, int* elementId)
 {
     *elementId = 0;
     Node* node = assertNode(errorString, nodeId);
     if (!node || !node->isContainerNode())
         return;
 
     TrackExceptionState exceptionState;
-    RefPtr<Element> element = toContainerNode(node)->querySelector(AtomicString(selectors), exceptionState);
+    RefPtrWillBeRawPtr<Element> element = toContainerNode(node)->querySelector(AtomicString(selectors), exceptionState);
     if (exceptionState.hadException()) {
         *errorString = "DOM Error while querying";
         return;
     }
 
     if (element)
         *elementId = pushNodePathToFrontend(element.get());
 }
 
 void InspectorDOMAgent::querySelectorAll(ErrorString* errorString, int nodeId, const String& selectors, RefPtr<TypeBuilder::Array<int> >& result)
@@ skipping 14 matching lines @@
     for (unsigned i = 0; i < nodes->length(); ++i)
         result->addItem(pushNodePathToFrontend(nodes->item(i)));
 }
 
 int InspectorDOMAgent::pushNodePathToFrontend(Node* nodeToPush)
 {
     ASSERT(nodeToPush);  // Invalid input
 
     if (!m_document)
         return 0;
-    if (!m_documentNodeToIdMap.contains(m_document))
+    // FIXME: Oilpan: .get will be unnecessary if m_document is a Member<>.
+    if (!m_documentNodeToIdMap->contains(m_document.get()))
         return 0;
 
     // Return id in case the node is known.
-    int result = m_documentNodeToIdMap.get(nodeToPush);
+    int result = m_documentNodeToIdMap->get(nodeToPush);
     if (result)
         return result;
 
     Node* node = nodeToPush;
     Vector<Node*> path;
     NodeToIdMap* danglingMap = 0;
 
     while (true) {
         Node* parent = innerParentNode(node);
         if (!parent) {
             // Node being pushed is detached -> push subtree root.
-            OwnPtr<NodeToIdMap> newMap = adoptPtr(new NodeToIdMap);
+            OwnPtrWillBeRawPtr<NodeToIdMap> newMap = adoptPtrWillBeNoop(new NodeToIdMap);
             danglingMap = newMap.get();
             m_danglingNodeToIdMaps.append(newMap.release());
             RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > children = TypeBuilder::Array<TypeBuilder::DOM::Node>::create();
             children->addItem(buildObjectForNode(node, 0, danglingMap));
             m_frontend->setChildNodes(0, children);
             break;
         } else {
             path.append(parent);
-            if (m_documentNodeToIdMap.get(parent))
+            if (m_documentNodeToIdMap->get(parent))
                 break;
-            else
-                node = parent;
+            node = parent;
         }
     }
 
-    NodeToIdMap* map = danglingMap ? danglingMap : &m_documentNodeToIdMap;
+    NodeToIdMap* map = danglingMap ? danglingMap : m_documentNodeToIdMap.get();
     for (int i = path.size() - 1; i >= 0; --i) {
         int nodeId = map->get(path.at(i));
         ASSERT(nodeId);
         pushChildNodesToFrontend(nodeId);
     }
     return map->get(nodeToPush);
 }
 
 int InspectorDOMAgent::boundNodeId(Node* node)
 {
-    return m_documentNodeToIdMap.get(node);
+    return m_documentNodeToIdMap->get(node);
 }
 
 void InspectorDOMAgent::setAttributeValue(ErrorString* errorString, int elementId, const String& name, const String& value)
 {
     Element* element = assertEditableElement(errorString, elementId);
     if (!element)
         return;
 
     m_domEditor->setAttribute(element, name, value, errorString);
 }
@@ skipping 340 matching lines @@
             if (exceptionState.hadException() || !nodeList)
                 continue;
 
             unsigned size = nodeList->length();
             for (unsigned i = 0; i < size; ++i)
                 resultCollector.add(nodeList->item(i));
         }
     }
 
     *searchId = IdentifiersFactory::createIdentifier();
-    Vector<RefPtr<Node> >* resultsIt = &m_searchResults.add(*searchId, Vector<RefPtr<Node> >()).storedValue->value;
+    WillBeHeapVector<RefPtrWillBeMember<Node> >* resultsIt = &m_searchResults.add(*searchId, WillBeHeapVector<RefPtrWillBeMember<Node> >()).storedValue->value;

[haraken, 2014/06/06 07:17:04]

Doesn't nullptr work?

[tkent, 2014/06/06 07:59:45]

It's not a pointer.

 
     for (ListHashSet<Node*>::iterator it = resultCollector.begin(); it != resultCollector.end(); ++it)
         resultsIt->append(*it);
 
     *resultCount = resultsIt->size();
 }
 
 void InspectorDOMAgent::getSearchResults(ErrorString* errorString, const String& searchId, int fromIndex, int toIndex, RefPtr<TypeBuilder::Array<int> >& nodeIds)
 {
     SearchResults::iterator it = m_searchResults.find(searchId);
@@ skipping 518 matching lines @@
         Attr* attribute = toAttr(node);
         value->setName(attribute->name());
         value->setValue(attribute->value());
     } else if (node->isShadowRoot()) {
         value->setShadowRootType(shadowRootType(toShadowRoot(node)));
     }
 
     if (node->isContainerNode()) {
         int nodeCount = innerChildNodeCount(node);
         value->setChildNodeCount(nodeCount);
-        if (nodesMap == &m_documentNodeToIdMap)
+        if (nodesMap == m_documentNodeToIdMap)
             m_cachedChildCount.set(id, nodeCount);
         if (forcePushChildren && !depth)
             depth = 1;
         RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > children = buildArrayForContainerChildren(node, depth, nodesMap);
         if (children->length() > 0 || depth) // Push children along with shadow in any case.
             value->setChildren(children.release());
     }
 
     return value.release();
 }
@@ skipping 154 matching lines @@
     if (enabled())
         m_frontend->documentUpdated();
 }
 
 void InspectorDOMAgent::invalidateFrameOwnerElement(LocalFrame* frame)
 {
     Element* frameOwner = frame->document()->ownerElement();
     if (!frameOwner)
         return;
 
-    int frameOwnerId = m_documentNodeToIdMap.get(frameOwner);
+    int frameOwnerId = m_documentNodeToIdMap->get(frameOwner);
     if (!frameOwnerId)
         return;
 
     // Re-add frame owner element together with its new children.
-    int parentId = m_documentNodeToIdMap.get(innerParentNode(frameOwner));
+    int parentId = m_documentNodeToIdMap->get(innerParentNode(frameOwner));
     m_frontend->childNodeRemoved(parentId, frameOwnerId);
-    unbind(frameOwner, &m_documentNodeToIdMap);
+    unbind(frameOwner, m_documentNodeToIdMap.get());
 
-    RefPtr<TypeBuilder::DOM::Node> value = buildObjectForNode(frameOwner, 0, &m_documentNodeToIdMap);
+    RefPtr<TypeBuilder::DOM::Node> value = buildObjectForNode(frameOwner, 0, m_documentNodeToIdMap.get());
     Node* previousSibling = innerPreviousSibling(frameOwner);
-    int prevId = previousSibling ? m_documentNodeToIdMap.get(previousSibling) : 0;
+    int prevId = previousSibling ? m_documentNodeToIdMap->get(previousSibling) : 0;
     m_frontend->childNodeInserted(parentId, prevId, value.release());
 }
 
 void InspectorDOMAgent::didCommitLoad(LocalFrame* frame, DocumentLoader* loader)
 {
     // FIXME: If "frame" is always guarenteed to be in the same Page as loader->frame()
     // then all we need to check here is loader->frame()->isMainFrame()
     // and we don't need "frame" at all.
     LocalFrame* mainFrame = frame->page()->mainFrame();
     if (loader->frame() != mainFrame) {
         invalidateFrameOwnerElement(loader->frame());
         return;
     }
 
     setDocument(mainFrame->document());
 }
 
 void InspectorDOMAgent::didInsertDOMNode(Node* node)
 {
     if (isWhitespace(node))
         return;
 
     // We could be attaching existing subtree. Forget the bindings.
-    unbind(node, &m_documentNodeToIdMap);
+    unbind(node, m_documentNodeToIdMap.get());
 
     ContainerNode* parent = node->parentNode();
     if (!parent)
         return;
-    int parentId = m_documentNodeToIdMap.get(parent);
+    int parentId = m_documentNodeToIdMap->get(parent);
     // Return if parent is not mapped yet.
     if (!parentId)
         return;
 
     if (!m_childrenRequested.contains(parentId)) {
         // No children are mapped yet -> only notify on changes of child count.
         int count = m_cachedChildCount.get(parentId) + 1;
         m_cachedChildCount.set(parentId, count);
         m_frontend->childNodeCountUpdated(parentId, count);
     } else {
         // Children have been requested -> return value of a new child.
         Node* prevSibling = innerPreviousSibling(node);
-        int prevId = prevSibling ? m_documentNodeToIdMap.get(prevSibling) : 0;
-        RefPtr<TypeBuilder::DOM::Node> value = buildObjectForNode(node, 0, &m_documentNodeToIdMap);
+        int prevId = prevSibling ? m_documentNodeToIdMap->get(prevSibling) : 0;
+        RefPtr<TypeBuilder::DOM::Node> value = buildObjectForNode(node, 0, m_documentNodeToIdMap.get());
         m_frontend->childNodeInserted(parentId, prevId, value.release());
     }
 }
 
 void InspectorDOMAgent::willRemoveDOMNode(Node* node)
 {
     if (isWhitespace(node))
         return;
 
     ContainerNode* parent = node->parentNode();
 
     // If parent is not mapped yet -> ignore the event.
-    if (!m_documentNodeToIdMap.contains(parent))
+    if (!m_documentNodeToIdMap->contains(parent))
         return;
 
-    int parentId = m_documentNodeToIdMap.get(parent);
+    int parentId = m_documentNodeToIdMap->get(parent);
 
     if (!m_childrenRequested.contains(parentId)) {
         // No children are mapped yet -> only notify on changes of child count.
         int count = m_cachedChildCount.get(parentId) - 1;
         m_cachedChildCount.set(parentId, count);
         m_frontend->childNodeCountUpdated(parentId, count);
     } else {
-        m_frontend->childNodeRemoved(parentId, m_documentNodeToIdMap.get(node));
+        m_frontend->childNodeRemoved(parentId, m_documentNodeToIdMap->get(node));
     }
-    unbind(node, &m_documentNodeToIdMap);
+    unbind(node, m_documentNodeToIdMap.get());
 }
 
 void InspectorDOMAgent::willModifyDOMAttr(Element*, const AtomicString& oldValue, const AtomicString& newValue)
 {
     m_suppressAttributeModifiedEvent = (oldValue == newValue);
 }
 
 void InspectorDOMAgent::didModifyDOMAttr(Element* element, const AtomicString& name, const AtomicString& value)
 {
     bool shouldSuppressEvent = m_suppressAttributeModifiedEvent;
@@ skipping 18 matching lines @@
     // If node is not mapped yet -> ignore the event.
     if (!id)
         return;
 
     if (m_domListener)
         m_domListener->didModifyDOMAttr(element);
 
     m_frontend->attributeRemoved(id, name);
 }
 
-void InspectorDOMAgent::styleAttributeInvalidated(const Vector<Element*>& elements)
+void InspectorDOMAgent::styleAttributeInvalidated(const WillBeHeapVector<RawPtrWillBeMember<Element> >& elements)
 {
     RefPtr<TypeBuilder::Array<int> > nodeIds = TypeBuilder::Array<int>::create();
     for (unsigned i = 0, size = elements.size(); i < size; ++i) {
         Element* element = elements.at(i);
         int id = boundNodeId(element);
         // If node is not mapped yet -> ignore the event.
         if (!id)
             continue;
 
         if (m_domListener)
             m_domListener->didModifyDOMAttr(element);
         nodeIds->addItem(id);
     }
     m_frontend->inlineStyleInvalidated(nodeIds.release());
 }
 
 void InspectorDOMAgent::characterDataModified(CharacterData* characterData)
 {
-    int id = m_documentNodeToIdMap.get(characterData);
+    int id = m_documentNodeToIdMap->get(characterData);
     if (!id) {
         // Push text node if it is being created.
         didInsertDOMNode(characterData);
         return;
     }
     m_frontend->characterDataModified(id, characterData->data());
 }
 
 void InspectorDOMAgent::didInvalidateStyleAttr(Node* node)
 {
-    int id = m_documentNodeToIdMap.get(node);
+    int id = m_documentNodeToIdMap->get(node);
     // If node is not mapped yet -> ignore the event.
     if (!id)
         return;
 
     if (!m_revalidateStyleAttrTask)
         m_revalidateStyleAttrTask = adoptPtr(new RevalidateStyleAttributeTask(this));
     m_revalidateStyleAttrTask->scheduleFor(toElement(node));
 }
 
 void InspectorDOMAgent::didPushShadowRoot(Element* host, ShadowRoot* root)
 {
     if (!host->ownerDocument())
         return;
 
-    int hostId = m_documentNodeToIdMap.get(host);
+    int hostId = m_documentNodeToIdMap->get(host);
     if (!hostId)
         return;
 
     pushChildNodesToFrontend(hostId, 1);
-    m_frontend->shadowRootPushed(hostId, buildObjectForNode(root, 0, &m_documentNodeToIdMap));
+    m_frontend->shadowRootPushed(hostId, buildObjectForNode(root, 0, m_documentNodeToIdMap.get()));
 }
 
 void InspectorDOMAgent::willPopShadowRoot(Element* host, ShadowRoot* root)
 {
     if (!host->ownerDocument())
         return;
 
-    int hostId = m_documentNodeToIdMap.get(host);
-    int rootId = m_documentNodeToIdMap.get(root);
+    int hostId = m_documentNodeToIdMap->get(host);
+    int rootId = m_documentNodeToIdMap->get(root);
     if (hostId && rootId)
         m_frontend->shadowRootPopped(hostId, rootId);
 }
 
 void InspectorDOMAgent::frameDocumentUpdated(LocalFrame* frame)
 {
     Document* document = frame->document();
     if (!document)
         return;
 
     Page* page = frame->page();
     ASSERT(page);
     if (frame != page->mainFrame())
         return;
 
     // Only update the main frame document, nested frame document updates are not required
     // (will be handled by invalidateFrameOwnerElement()).
     setDocument(document);
 }
 
 void InspectorDOMAgent::pseudoElementCreated(PseudoElement* pseudoElement)
 {
     Element* parent = pseudoElement->parentOrShadowHostElement();
     if (!parent)
         return;
-    int parentId = m_documentNodeToIdMap.get(parent);
+    int parentId = m_documentNodeToIdMap->get(parent);
     if (!parentId)
         return;
 
     pushChildNodesToFrontend(parentId, 1);
-    m_frontend->pseudoElementAdded(parentId, buildObjectForNode(pseudoElement, 0, &m_documentNodeToIdMap));
+    m_frontend->pseudoElementAdded(parentId, buildObjectForNode(pseudoElement, 0, m_documentNodeToIdMap.get()));
 }
 
 void InspectorDOMAgent::pseudoElementDestroyed(PseudoElement* pseudoElement)
 {
-    int pseudoElementId = m_documentNodeToIdMap.get(pseudoElement);
+    int pseudoElementId = m_documentNodeToIdMap->get(pseudoElement);
     if (!pseudoElementId)
         return;
 
     // If a PseudoElement is bound, its parent element must be bound, too.
     Element* parent = pseudoElement->parentOrShadowHostElement();
     ASSERT(parent);
-    int parentId = m_documentNodeToIdMap.get(parent);
+    int parentId = m_documentNodeToIdMap->get(parent);
     ASSERT(parentId);
 
-    unbind(pseudoElement, &m_documentNodeToIdMap);
+    unbind(pseudoElement, m_documentNodeToIdMap.get());
     m_frontend->pseudoElementRemoved(parentId, pseudoElementId);
 }
 
 static ShadowRoot* shadowRootForNode(Node* node, const String& type)
 {
     if (!node->isElementNode())
         return 0;
     if (type == "a")
         return toElement(node)->shadowRoot();
     if (type == "u")
@@ skipping 90 matching lines @@
 
     InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(ScriptState::forMainWorld(frame));
     if (injectedScript.isEmpty())
         return nullptr;
 
     return injectedScript.wrapNode(node, objectGroup);
 }
 
 bool InspectorDOMAgent::pushDocumentUponHandlelessOperation(ErrorString* errorString)
 {
-    if (!m_documentNodeToIdMap.contains(m_document)) {
+    // FIXME: Oilpan: .get will be unnecessary if m_document is a Member<>.
+    if (!m_documentNodeToIdMap->contains(m_document.get())) {
         RefPtr<TypeBuilder::DOM::Node> root;
         getDocument(errorString, root);
         return errorString->isEmpty();
     }
     return true;
 }
 
 } // namespace WebCore