Fix template angle bracket syntax in inspector

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 176 matching lines @@
     explicit InspectorRevalidateDOMTask(InspectorDOMAgent*);
     void scheduleStyleAttrRevalidationFor(Element*);
     void scheduleContentDistributionRevalidationFor(Element*);
     void reset() { m_timer.stop(); }
     void onTimer(Timer<InspectorRevalidateDOMTask>*);
     void trace(Visitor*);
 
 private:
     RawPtrWillBeMember<InspectorDOMAgent> m_domAgent;
     Timer<InspectorRevalidateDOMTask> m_timer;
-    WillBeHeapHashSet<RefPtrWillBeMember<Element> > m_styleAttrInvalidatedElements;
-    WillBeHeapHashSet<RefPtrWillBeMember<Element> > m_contentDistributionInvalidatedElements;
+    WillBeHeapHashSet<RefPtrWillBeMember<Element>> m_styleAttrInvalidatedElements;
+    WillBeHeapHashSet<RefPtrWillBeMember<Element>> m_contentDistributionInvalidatedElements;
 };
 
 InspectorRevalidateDOMTask::InspectorRevalidateDOMTask(InspectorDOMAgent* domAgent)
     : m_domAgent(domAgent)
     , m_timer(this, &InspectorRevalidateDOMTask::onTimer)
 {
 }
 
 void InspectorRevalidateDOMTask::scheduleStyleAttrRevalidationFor(Element* element)
 {
     m_styleAttrInvalidatedElements.add(element);
     if (!m_timer.isActive())
         m_timer.startOneShot(0, FROM_HERE);
 }
 
 void InspectorRevalidateDOMTask::scheduleContentDistributionRevalidationFor(Element* element)
 {
     m_contentDistributionInvalidatedElements.add(element);
     if (!m_timer.isActive())
         m_timer.startOneShot(0, FROM_HERE);
 }
 
 void InspectorRevalidateDOMTask::onTimer(Timer<InspectorRevalidateDOMTask>*)
 {
     // The timer is stopped on m_domAgent destruction, so this method will never be called after m_domAgent has been destroyed.
-    WillBeHeapVector<RawPtrWillBeMember<Element> > elements;
+    WillBeHeapVector<RawPtrWillBeMember<Element>> elements;
     for (auto& attribute : m_styleAttrInvalidatedElements)
         elements.append(attribute.get());
     m_domAgent->styleAttributeInvalidated(elements);
 
     m_styleAttrInvalidatedElements.clear();
 
     elements.clear();
     for (const RefPtrWillBeMember<Element>& it : m_contentDistributionInvalidatedElements)
         elements.append(it.get());
     m_domAgent->contentDistributionInvalidated(elements);
@@ skipping 68 matching lines @@
     reset();
 }
 
 void InspectorDOMAgent::restore()
 {
     if (!enabled())
         return;
     innerEnable();
 }
 
-WillBeHeapVector<RawPtrWillBeMember<Document> > InspectorDOMAgent::documents()
+WillBeHeapVector<RawPtrWillBeMember<Document>> InspectorDOMAgent::documents()
 {
-    WillBeHeapVector<RawPtrWillBeMember<Document> > result;
+    WillBeHeapVector<RawPtrWillBeMember<Document>> result;
     for (Frame* frame = m_document->frame(); frame; frame = frame->tree().traverseNext()) {
         if (!frame->isLocalFrame())
             continue;
         Document* document = toLocalFrame(frame)->document();
         if (!document)
             continue;
         result.append(document);
     }
     return result;
 }
@@ skipping 268 matching lines @@
 
         for (node = innerFirstChild(node); node; node = innerNextSibling(node)) {
             int childNodeId = nodeMap->get(node);
             ASSERT(childNodeId);
             pushChildNodesToFrontend(childNodeId, depth);
         }
 
         return;
     }
 
-    RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > children = buildArrayForContainerChildren(node, depth, nodeMap);
+    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_idToNode.clear();
     m_idToNodesMap.clear();
     releaseDanglingNodes();
     m_childrenRequested.clear();
     m_distributedNodesRequested.clear();
     m_cachedChildCount.clear();
     if (m_revalidateTask)
         m_revalidateTask->reset();
 }
 
 Node* InspectorDOMAgent::nodeForId(int id)
 {
     if (!id)
         return nullptr;
 
-    WillBeHeapHashMap<int, RawPtrWillBeMember<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 nullptr;
 }
 
 void InspectorDOMAgent::requestChildNodes(ErrorString* errorString, int nodeId, const int* depth)
 {
     int sanitizedDepth;
 
     if (!depth)
         sanitizedDepth = 1;
     else if (*depth == -1)
         sanitizedDepth = INT_MAX;
     else if (*depth > 0)
         sanitizedDepth = *depth;
     else {
         *errorString = "Please provide a positive integer as a depth or -1 for entire subtree";
         return;
     }
 
     pushChildNodesToFrontend(nodeId, sanitizedDepth);
 }
 
-void InspectorDOMAgent::requestShadowHostDistributedNodes(ErrorString* errorString, int nodeId, RefPtr<TypeBuilder::Array<TypeBuilder::DOM::InsertionPointDistribution> >& insertionPointDistributions)
+void InspectorDOMAgent::requestShadowHostDistributedNodes(ErrorString* errorString, int nodeId, RefPtr<TypeBuilder::Array<TypeBuilder::DOM::InsertionPointDistribution>>& insertionPointDistributions)
 {
     Node* shadowHost = assertNode(errorString, nodeId);
     if (!shadowHost)
         return;
 
     ASSERT(!shadowHost->document().childNeedsDistributionRecalc());
 
     NodeToIdMap* nodeMap = m_idToNodesMap.get(nodeId);
     ASSERT(nodeMap);
 
     m_distributedNodesRequested.add(nodeId);
 
     insertionPointDistributions = TypeBuilder::Array<TypeBuilder::DOM::InsertionPointDistribution>::create();
     for (ShadowRoot* root = shadowHost->youngestShadowRoot(); root; root = root->olderShadowRoot()) {
-        const WillBeHeapVector<RefPtrWillBeMember<InsertionPoint> >& insertionPoints = root->descendantInsertionPoints();
+        const WillBeHeapVector<RefPtrWillBeMember<InsertionPoint>>& insertionPoints = root->descendantInsertionPoints();
         for (const auto& it : insertionPoints) {
             InsertionPoint* insertionPoint = it.get();
             int insertionPointId = pushNodePathToFrontend(insertionPoint, nodeMap);
             ASSERT(insertionPointId);
 
-            RefPtr<TypeBuilder::Array<TypeBuilder::DOM::DistributedNode> > distributedNodes = TypeBuilder::Array<TypeBuilder::DOM::DistributedNode>::create();
+            RefPtr<TypeBuilder::Array<TypeBuilder::DOM::DistributedNode>> distributedNodes = TypeBuilder::Array<TypeBuilder::DOM::DistributedNode>::create();
             for (size_t i = 0; i < insertionPoint->size(); ++i) {
                 Node* distributedNode = insertionPoint->at(i);
                 if (isWhitespace(distributedNode))
                     continue;
 
                 int distributedNodeId = pushNodePathToFrontend(distributedNode, nodeMap);
                 ASSERT(distributedNodeId);
 
                 RefPtr<TypeBuilder::DOM::DistributedNode> distributedNodeObject = TypeBuilder::DOM::DistributedNode::create()
                     .setNodeId(distributedNodeId);
 
-                RefPtr<TypeBuilder::Array<int> > destinationInsertionPointIds = TypeBuilder::Array<int>::create();
+                RefPtr<TypeBuilder::Array<int>> destinationInsertionPointIds = TypeBuilder::Array<int>::create();
                 WillBeHeapVector<RawPtrWillBeMember<InsertionPoint>, 8> destinationInsertionPoints;
                 collectDestinationInsertionPoints(*distributedNode, destinationInsertionPoints);
                 // If this node has only one destination insertion point (often), then we already know it and don't need any additional information.
                 if (destinationInsertionPoints.size() != 1) {
                     for (size_t j = 0; j < destinationInsertionPoints.size(); ++j) {
                         int destinationInsertionPointId = pushNodePathToFrontend(destinationInsertionPoints.at(j), nodeMap);
                         ASSERT(destinationInsertionPointId);
                         destinationInsertionPointIds->addItem(destinationInsertionPointId);
                     }
                     distributedNodeObject->setDestinationInsertionPointIds(destinationInsertionPointIds);
@@ skipping 22 matching lines @@
     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)
+void InspectorDOMAgent::querySelectorAll(ErrorString* errorString, int nodeId, const String& selectors, RefPtr<TypeBuilder::Array<int>>& result)
 {
     Node* node = assertNode(errorString, nodeId);
     if (!node || !node->isContainerNode())
         return;
 
     TrackExceptionState exceptionState;
     RefPtrWillBeRawPtr<StaticElementList> elements = toContainerNode(node)->querySelectorAll(AtomicString(selectors), exceptionState);
     if (exceptionState.hadException()) {
         *errorString = "DOM Error while querying";
         return;
@@ skipping 13 matching lines @@
         return 0;
     if (!m_documentNodeToIdMap->contains(m_document))
         return 0;
 
     // Return id in case the node is known.
     int result = nodeMap->get(nodeToPush);
     if (result)
         return result;
 
     Node* node = nodeToPush;
-    WillBeHeapVector<RawPtrWillBeMember<Node> > path;
+    WillBeHeapVector<RawPtrWillBeMember<Node>> path;
 
     while (true) {
         Node* parent = innerParentNode(node);
         if (!parent)
             return 0;
         path.append(parent);
         if (nodeMap->get(parent))
             break;
         node = parent;
     }
@@ skipping 16 matching lines @@
         return nodeId;
 
     Node* node = nodeToPush;
     while (Node* parent = innerParentNode(node))
         node = parent;
 
     // Node being pushed is detached -> push subtree root.
     OwnPtrWillBeRawPtr<NodeToIdMap> newMap = adoptPtrWillBeNoop(new NodeToIdMap);
     NodeToIdMap* danglingMap = newMap.get();
     m_danglingNodeToIdMaps.append(newMap.release());
-    RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > children = TypeBuilder::Array<TypeBuilder::DOM::Node>::create();
+    RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node>> children = TypeBuilder::Array<TypeBuilder::DOM::Node>::create();
     children->addItem(buildObjectForNode(node, 0, danglingMap));
     m_frontend->setChildNodes(0, children);
 
     return pushNodePathToFrontend(nodeToPush, danglingMap);
 }
 
 int InspectorDOMAgent::boundNodeId(Node* node)
 {
     return m_documentNodeToIdMap->get(node);
 }
@@ skipping 161 matching lines @@
         return;
 
     if (node->nodeType() != Node::TEXT_NODE) {
         *errorString = "Can only set value of text nodes";
         return;
     }
 
     m_domEditor->replaceWholeText(toText(node), value, errorString);
 }
 
-void InspectorDOMAgent::getEventListenersForNode(ErrorString* errorString, int nodeId, const String* objectGroup, RefPtr<TypeBuilder::Array<TypeBuilder::DOM::EventListener> >& listenersArray)
+void InspectorDOMAgent::getEventListenersForNode(ErrorString* errorString, int nodeId, const String* objectGroup, RefPtr<TypeBuilder::Array<TypeBuilder::DOM::EventListener>>& listenersArray)
 {
     listenersArray = TypeBuilder::Array<TypeBuilder::DOM::EventListener>::create();
     Node* node = assertNode(errorString, nodeId);
     if (!node)
         return;
     Vector<EventListenerInfo> eventInformation;
     getEventListeners(node, eventInformation, true);
 
     // Get Capturing Listeners (in this order)
     size_t eventInformationLength = eventInformation.size();
@@ skipping 113 matching lines @@
     String attributeQuery = whitespaceTrimmedQuery;
     if (startTagFound)
         tagNameQuery = tagNameQuery.right(tagNameQuery.length() - 1);
     if (endTagFound)
         tagNameQuery = tagNameQuery.left(tagNameQuery.length() - 1);
     if (startQuoteFound)
         attributeQuery = attributeQuery.right(attributeQuery.length() - 1);
     if (endQuoteFound)
         attributeQuery = attributeQuery.left(attributeQuery.length() - 1);
 
-    WillBeHeapVector<RawPtrWillBeMember<Document> > docs = documents();
-    WillBeHeapListHashSet<RawPtrWillBeMember<Node> > resultCollector;
+    WillBeHeapVector<RawPtrWillBeMember<Document>> docs = documents();
+    WillBeHeapListHashSet<RawPtrWillBeMember<Node>> resultCollector;
 
     for (Document* document : docs) {
         Node* documentElement = document->documentElement();
         Node* node = documentElement;
         if (!node)
             continue;
 
         // Manual plain text search.
         for (; node; node = nextNodeWithShadowDOMInMind(*node, documentElement, includeUserAgentShadowDOM)) {
             switch (node->nodeType()) {
@@ skipping 64 matching lines @@
             if (exceptionState.hadException() || !elementList)
                 continue;
 
             unsigned size = elementList->length();
             for (unsigned i = 0; i < size; ++i)
                 resultCollector.add(elementList->item(i));
         }
     }
 
     *searchId = IdentifiersFactory::createIdentifier();
-    WillBeHeapVector<RefPtrWillBeMember<Node> >* resultsIt = &m_searchResults.add(*searchId, WillBeHeapVector<RefPtrWillBeMember<Node> >()).storedValue->value;
+    WillBeHeapVector<RefPtrWillBeMember<Node>>* resultsIt = &m_searchResults.add(*searchId, WillBeHeapVector<RefPtrWillBeMember<Node>>()).storedValue->value;
 
     for (auto& result : resultCollector)
         resultsIt->append(result);
 
     *resultCount = resultsIt->size();
 }
 
-void InspectorDOMAgent::getSearchResults(ErrorString* errorString, const String& searchId, int fromIndex, int toIndex, RefPtr<TypeBuilder::Array<int> >& nodeIds)
+void InspectorDOMAgent::getSearchResults(ErrorString* errorString, const String& searchId, int fromIndex, int toIndex, RefPtr<TypeBuilder::Array<int>>& nodeIds)
 {
     SearchResults::iterator it = m_searchResults.find(searchId);
     if (it == m_searchResults.end()) {
         *errorString = "No search session with given id found";
         return;
     }
 
     int size = it->value.size();
     if (fromIndex < 0 || toIndex > size || fromIndex >= toIndex) {
         *errorString = "Invalid search result range";
@@ skipping 372 matching lines @@
         return;
     }
     RefPtr<TypeBuilder::Runtime::RemoteObject> object = resolveNode(node, objectGroupName);
     if (!object) {
         *errorString = "Node with given id does not belong to the document";
         return;
     }
     result = object;
 }
 
-void InspectorDOMAgent::getAttributes(ErrorString* errorString, int nodeId, RefPtr<TypeBuilder::Array<String> >& result)
+void InspectorDOMAgent::getAttributes(ErrorString* errorString, int nodeId, RefPtr<TypeBuilder::Array<String>>& result)
 {
     Element* element = assertElement(errorString, nodeId);
     if (!element)
         return;
 
     result = buildArrayForElementAttributes(element);
 }
 
 void InspectorDOMAgent::requestNode(ErrorString*, const String& objectId, int* nodeId)
 {
@@ skipping 69 matching lines @@
             HTMLFrameOwnerElement* frameOwner = toHTMLFrameOwnerElement(node);
             LocalFrame* frame = (frameOwner->contentFrame() && frameOwner->contentFrame()->isLocalFrame()) ? toLocalFrame(frameOwner->contentFrame()) : nullptr;
             if (frame)
                 value->setFrameId(m_pageAgent->frameId(frame));
             if (Document* doc = frameOwner->contentDocument())
                 value->setContentDocument(buildObjectForNode(doc, 0, nodesMap));
         }
 
         ElementShadow* shadow = element->shadow();
         if (shadow) {
-            RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > shadowRoots = TypeBuilder::Array<TypeBuilder::DOM::Node>::create();
+            RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node>> shadowRoots = TypeBuilder::Array<TypeBuilder::DOM::Node>::create();
             for (ShadowRoot* root = shadow->youngestShadowRoot(); root; root = root->olderShadowRoot())
                 shadowRoots->addItem(buildObjectForNode(root, 0, nodesMap));
             value->setShadowRoots(shadowRoots);
             forcePushChildren = true;
         }
 
         if (isHTMLLinkElement(*element)) {
             HTMLLinkElement& linkElement = toHTMLLinkElement(*element);
             if (linkElement.isImport() && linkElement.import() && innerParentNode(linkElement.import()) == linkElement)
                 value->setImportedDocument(buildObjectForNode(linkElement.import(), 0, nodesMap));
             forcePushChildren = true;
         }
 
         if (isHTMLTemplateElement(*element)) {
             value->setTemplateContent(buildObjectForNode(toHTMLTemplateElement(*element).content(), 0, nodesMap));
             forcePushChildren = true;
         }
 
         switch (element->pseudoId()) {
         case BEFORE:
             value->setPseudoType(TypeBuilder::DOM::PseudoType::Before);
             break;
         case AFTER:
             value->setPseudoType(TypeBuilder::DOM::PseudoType::After);
             break;
         default: {
-            RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > pseudoElements = buildArrayForPseudoElements(element, nodesMap);
+            RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node>> pseudoElements = buildArrayForPseudoElements(element, nodesMap);
             if (pseudoElements) {
                 value->setPseudoElements(pseudoElements.release());
                 forcePushChildren = true;
             }
             break;
         }
         }
     } else if (node->isDocumentNode()) {
         Document* document = toDocument(node);
         value->setDocumentURL(documentURLString(document));
@@ skipping 11 matching lines @@
         value->setShadowRootType(shadowRootType(toShadowRoot(node)));
     }
 
     if (node->isContainerNode()) {
         int nodeCount = innerChildNodeCount(node);
         value->setChildNodeCount(nodeCount);
         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);
+        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();
 }
 
-PassRefPtr<TypeBuilder::Array<String> > InspectorDOMAgent::buildArrayForElementAttributes(Element* element)
+PassRefPtr<TypeBuilder::Array<String>> InspectorDOMAgent::buildArrayForElementAttributes(Element* element)
 {
-    RefPtr<TypeBuilder::Array<String> > attributesValue = TypeBuilder::Array<String>::create();
+    RefPtr<TypeBuilder::Array<String>> attributesValue = TypeBuilder::Array<String>::create();
     // Go through all attributes and serialize them.
     AttributeCollection attributes = element->attributes();
     for (auto& attribute : attributes) {
         // Add attribute pair
         attributesValue->addItem(attribute.name().toString());
         attributesValue->addItem(attribute.value());
     }
     return attributesValue.release();
 }
 
-PassRefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > InspectorDOMAgent::buildArrayForContainerChildren(Node* container, int depth, NodeToIdMap* nodesMap)
+PassRefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node>> InspectorDOMAgent::buildArrayForContainerChildren(Node* container, int depth, NodeToIdMap* nodesMap)
 {
-    RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > children = TypeBuilder::Array<TypeBuilder::DOM::Node>::create();
+    RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node>> children = TypeBuilder::Array<TypeBuilder::DOM::Node>::create();
     if (depth == 0) {
         // Special-case the only text child - pretend that container's children have been requested.
         Node* firstChild = container->firstChild();
         if (firstChild && firstChild->nodeType() == Node::TEXT_NODE && !firstChild->nextSibling()) {
             children->addItem(buildObjectForNode(firstChild, 0, nodesMap));
             m_childrenRequested.add(bind(container, nodesMap));
         }
         return children.release();
     }
 
@@ skipping 44 matching lines @@
                     }
                 }
             }
         }
     }
     if (!sourceName.isEmpty())
         value->setSourceName(sourceName);
     return value.release();
 }
 
-PassRefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > InspectorDOMAgent::buildArrayForPseudoElements(Element* element, NodeToIdMap* nodesMap)
+PassRefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node>> InspectorDOMAgent::buildArrayForPseudoElements(Element* element, NodeToIdMap* nodesMap)
 {
     if (!element->pseudoElement(BEFORE) && !element->pseudoElement(AFTER))
         return nullptr;
 
-    RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > pseudoElements = TypeBuilder::Array<TypeBuilder::DOM::Node>::create();
+    RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node>> pseudoElements = TypeBuilder::Array<TypeBuilder::DOM::Node>::create();
     if (element->pseudoElement(BEFORE))
         pseudoElements->addItem(buildObjectForNode(element->pseudoElement(BEFORE), 0, nodesMap));
     if (element->pseudoElement(AFTER))
         pseudoElements->addItem(buildObjectForNode(element->pseudoElement(AFTER), 0, nodesMap));
     return pseudoElements.release();
 }
 
 Node* InspectorDOMAgent::innerFirstChild(Node* node)
 {
     node = node->firstChild();
@@ skipping 177 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.toString());
 }
 
-void InspectorDOMAgent::styleAttributeInvalidated(const WillBeHeapVector<RawPtrWillBeMember<Element> >& elements)
+void InspectorDOMAgent::styleAttributeInvalidated(const WillBeHeapVector<RawPtrWillBeMember<Element>>& elements)
 {
-    RefPtr<TypeBuilder::Array<int> > nodeIds = TypeBuilder::Array<int>::create();
+    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::contentDistributionInvalidated(const WillBeHeapVector<RawPtrWillBeMember<Element> >& elements)
+void InspectorDOMAgent::contentDistributionInvalidated(const WillBeHeapVector<RawPtrWillBeMember<Element>>& elements)
 {
-    RefPtr<TypeBuilder::Array<int> > nodeIds = TypeBuilder::Array<int>::create();
+    RefPtr<TypeBuilder::Array<int>> nodeIds = TypeBuilder::Array<int>::create();
     for (const auto& it : elements) {
         Element* element = it.get();
         int id = boundNodeId(element);
         if (!id)
             continue;
         nodeIds->addItem(id);
     }
     m_frontend->shadowHostDistributionInvalidated(nodeIds.release());
 }
 
@@ skipping 154 matching lines @@
 }
 
 void InspectorDOMAgent::pushNodeByPathToFrontend(ErrorString* errorString, const String& path, int* nodeId)
 {
     if (Node* node = nodeForPath(path))
         *nodeId = pushNodePathToFrontend(node);
     else
         *errorString = "No node with given path found";
 }
 
-void InspectorDOMAgent::pushNodesByBackendIdsToFrontend(ErrorString* errorString, const RefPtr<JSONArray>& backendNodeIds, RefPtr<TypeBuilder::Array<int> >& result)
+void InspectorDOMAgent::pushNodesByBackendIdsToFrontend(ErrorString* errorString, const RefPtr<JSONArray>& backendNodeIds, RefPtr<TypeBuilder::Array<int>>& result)
 {
     result = TypeBuilder::Array<int>::create();
     for (const auto& backendNode : *backendNodeIds) {
         int backendNodeId;
 
         if (!(backendNode)->asNumber(&backendNodeId)) {
             *errorString = "Invalid argument type";
             return;
         }
 
@@ skipping 59 matching lines @@
     visitor->trace(m_revalidateTask);
     visitor->trace(m_searchResults);
 #endif
     visitor->trace(m_history);
     visitor->trace(m_domEditor);
     visitor->trace(m_listener);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink