ASSERT -> {DCHECK|DCHECK_XX}, ENABLE(ASSERT) -> DCHECK_IS_ON() in dom

third_party/WebKit/Source/core/dom/Node.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 95 matching lines @@
     uint32_t m_nodeFlags;
     Member<void*> m_willbeMember[4];
     void* m_pointer;
 };
 
 static_assert(sizeof(Node) <= sizeof(SameSizeAsNode), "Node should stay small");
 
 #if !ENABLE(OILPAN)
 void* Node::operator new(size_t size)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
     return partitionAlloc(WTF::Partitions::nodePartition(), size, "blink::Node");
 }
 
 void Node::operator delete(void* ptr)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
     partitionFree(ptr);
 }
 #endif
 
 #if DUMP_NODE_STATISTICS
 using WeakNodeSet = HeapHashSet<WeakMember<Node>>;
 static WeakNodeSet& liveNodeSet()
 {
     DEFINE_STATIC_LOCAL(WeakNodeSet, set, (new WeakNodeSet));
     return set;
@@ skipping 124 matching lines @@
 #endif
 }
 
 Node::Node(TreeScope* treeScope, ConstructionType type)
     : m_nodeFlags(type)
     , m_parentOrShadowHostNode(nullptr)
     , m_treeScope(treeScope)
     , m_previous(nullptr)
     , m_next(nullptr)
 {
-    ASSERT(m_treeScope || type == CreateDocument || type == CreateShadowRoot);
+    DCHECK(m_treeScope || type == CreateDocument || type == CreateShadowRoot);
 #if !ENABLE(OILPAN)
     if (m_treeScope)
         m_treeScope->guardRef();
 #endif
 
 #if !defined(NDEBUG) || (defined(DUMP_NODE_STATISTICS) && DUMP_NODE_STATISTICS)
     trackForDebugging();
 #endif
     InstanceCounters::incrementCounter(InstanceCounters::NodeCounter);
 }
@@ skipping 19 matching lines @@
         m_next->setPreviousSibling(nullptr);
 
     if (m_treeScope)
         m_treeScope->guardDeref();
 
     if (getFlag(HasWeakReferencesFlag))
         WeakIdentifierMap<Node>::notifyObjectDestroyed(this);
 
     // clearEventTargetData() must be always done,
     // or eventTargetDataMap() may keep a raw pointer to a deleted object.
-    ASSERT(!hasEventTargetData());
+    DCHECK(!hasEventTargetData());
 #else
     // With Oilpan, the rare data finalizer also asserts for
     // this condition (we cannot directly access it here.)
     RELEASE_ASSERT(hasRareData() || !layoutObject());
 #endif
 
     InstanceCounters::decrementCounter(InstanceCounters::NodeCounter);
 }
 
 #if !ENABLE(OILPAN)
@@ skipping 24 matching lines @@
 NodeRareData& Node::ensureRareData()
 {
     if (hasRareData())
         return *rareData();
 
     if (isElementNode())
         m_data.m_rareData = ElementRareData::create(m_data.m_layoutObject);
     else
         m_data.m_rareData = NodeRareData::create(m_data.m_layoutObject);
 
-    ASSERT(m_data.m_rareData);
+    DCHECK(m_data.m_rareData);
 
     setFlag(HasRareDataFlag);
     return *rareData();
 }
 
 #if !ENABLE(OILPAN)
 void Node::clearRareData()
 {
-    ASSERT(hasRareData());
-    ASSERT(!transientMutationObserverRegistry() || transientMutationObserverRegistry()->isEmpty());
+    DCHECK(hasRareData());
+    DCHECK(!transientMutationObserverRegistry() || transientMutationObserverRegistry()->isEmpty());
 
     LayoutObject* layoutObject = m_data.m_rareData->layoutObject();
     if (isElementNode())
         delete static_cast<ElementRareData*>(m_data.m_rareData);
     else
         delete static_cast<NodeRareData*>(m_data.m_rareData);
     m_data.m_layoutObject = layoutObject;
     clearFlag(HasRareDataFlag);
 }
 #endif
@@ skipping 164 matching lines @@
 {
     document().updateLayoutTree();
     return hasEditableStyle(RichlyEditable, UserSelectAllIsAlwaysNonEditable);
 }
 
 bool Node::hasEditableStyle(EditableLevel editableLevel, UserSelectAllTreatment treatment) const
 {
     if (isPseudoElement())
         return false;
 
-    // Ideally we'd call ASSERT(!needsStyleRecalc()) here, but
+    // Ideally we'd call DCHECK(!needsStyleRecalc()) here, but
     // ContainerNode::setFocus() calls setNeedsStyleRecalc(), so the assertion
     // would fire in the middle of Document::setFocusedNode().
 
     for (const Node* node = this; node; node = node->parentNode()) {
         if ((node->isHTMLElement() || node->isDocumentNode()) && node->layoutObject()) {
             // Elements with user-select: all style are considered atomic
             // therefore non editable.
             if (nodeIsUserSelectAll(node) && treatment == UserSelectAllIsAlwaysNonEditable)
                 return false;
             switch (node->layoutObject()->style()->userModify()) {
@@ skipping 60 matching lines @@
 
 Node& Node::shadowIncludingRoot() const
 {
     if (inShadowIncludingDocument())
         return document();
     Node* root = const_cast<Node*>(this);
     while (Node* host = root->shadowHost())
         root = host;
     while (Node* ancestor = root->parentNode())
         root = ancestor;
-    ASSERT(!root->shadowHost());
+    DCHECK(!root->shadowHost());
     return *root;
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 bool Node::needsDistributionRecalc() const
 {
     return shadowIncludingRoot().childNeedsDistributionRecalc();
 }
 #endif
 
 void Node::updateDistribution()
 {
     // Extra early out to avoid spamming traces.
     if (inShadowIncludingDocument() && !document().childNeedsDistributionRecalc())
         return;
     TRACE_EVENT0("blink", "Node::updateDistribution");
     ScriptForbiddenScope forbidScript;
     Node& root = shadowIncludingRoot();
     if (root.childNeedsDistributionRecalc())
         root.recalcDistribution();
 }
 
 void Node::recalcDistribution()
 {
-    ASSERT(childNeedsDistributionRecalc());
+    DCHECK(childNeedsDistributionRecalc());
 
     if (isElementNode()) {
         if (ElementShadow* shadow = toElement(this)->shadow())
             shadow->distributeIfNeeded();
     }
 
-    ASSERT(ScriptForbiddenScope::isScriptForbidden());
+    DCHECK(ScriptForbiddenScope::isScriptForbidden());
     for (Node* child = firstChild(); child; child = child->nextSibling()) {
         if (child->childNeedsDistributionRecalc())
             child->recalcDistribution();
     }
 
     for (ShadowRoot* root = youngestShadowRoot(); root; root = root->olderShadowRoot()) {
         if (root->childNeedsDistributionRecalc())
             root->recalcDistribution();
     }
 
     clearChildNeedsDistributionRecalc();
 }
 
 void Node::setIsLink(bool isLink)
 {
     setFlag(isLink && !SVGImage::isInSVGImage(toElement(this)), IsLinkFlag);
 }
 
 void Node::setNeedsStyleInvalidation()
 {
-    ASSERT(isElementNode());
+    DCHECK(isElementNode());
     setFlag(NeedsStyleInvalidationFlag);
     markAncestorsWithChildNeedsStyleInvalidation();
 }
 
 void Node::markAncestorsWithChildNeedsStyleInvalidation()
 {
     ScriptForbiddenScope forbidScriptDuringRawIteration;
     for (Node* node = parentOrShadowHostNode(); node && !node->childNeedsStyleInvalidation(); node = node->parentOrShadowHostNode())
         node->setChildNeedsStyleInvalidation();
     document().scheduleLayoutTreeUpdateIfNeeded();
@@ skipping 19 matching lines @@
 
 void Node::markAncestorsWithChildNeedsStyleRecalc()
 {
     for (ContainerNode* p = parentOrShadowHostNode(); p && !p->childNeedsStyleRecalc(); p = p->parentOrShadowHostNode())
         p->setChildNeedsStyleRecalc();
     document().scheduleLayoutTreeUpdateIfNeeded();
 }
 
 void Node::setNeedsStyleRecalc(StyleChangeType changeType, const StyleChangeReasonForTracing& reason)
 {
-    ASSERT(changeType != NoStyleChange);
+    DCHECK(changeType != NoStyleChange);
     if (!inActiveDocument())
         return;
 
     TRACE_EVENT_INSTANT1(
         TRACE_DISABLED_BY_DEFAULT("devtools.timeline.invalidationTracking"),
         "StyleRecalcInvalidationTracking",
         TRACE_EVENT_SCOPE_THREAD,
         "data",
         InspectorStyleRecalcInvalidationTrackingEvent::data(this, reason));
 
@@ skipping 23 matching lines @@
     return inShadowIncludingDocument() && document().isActive();
 }
 
 Node* Node::focusDelegate()
 {
     return this;
 }
 
 bool Node::shouldHaveFocusAppearance() const
 {
-    ASSERT(focused());
+    DCHECK(focused());
     return true;
 }
 
 bool Node::isInert() const
 {
     const HTMLDialogElement* dialog = document().activeModalDialog();
     if (dialog && this != document() && (!canParticipateInFlatTree() || !FlatTreeTraversal::containsIncludingPseudoElement(*dialog, *this)))
         return true;
     return document().ownerElement() && document().ownerElement()->isInert();
 }
@@ skipping 107 matching lines @@
     } else if (otherDepth > thisDepth) {
         for (int i = otherDepth; i > thisDepth; --i)
             otherIterator = parent(*otherIterator);
     }
     while (thisIterator) {
         if (thisIterator == otherIterator)
             return const_cast<Node*>(thisIterator);
         thisIterator = parent(*thisIterator);
         otherIterator = parent(*otherIterator);
     }
-    ASSERT(!otherIterator);
+    DCHECK(!otherIterator);
     return nullptr;
 }
 
 void Node::reattach(const AttachContext& context)
 {
     AttachContext reattachContext(context);
     reattachContext.performingReattach = true;
 
     // We only need to detach if the node has already been through attach().
     if (getStyleChangeType() < NeedsReattachStyleChange)
         detach(reattachContext);
     attach(reattachContext);
 }
 
 void Node::attach(const AttachContext&)
 {
-    ASSERT(document().inStyleRecalc() || isDocumentNode());
-    ASSERT(!document().lifecycle().inDetach());
-    ASSERT(needsAttach());
-    ASSERT(!layoutObject() || (layoutObject()->style() && (layoutObject()->parent() || layoutObject()->isLayoutView())));
+    DCHECK(document().inStyleRecalc() || isDocumentNode());
+    DCHECK(!document().lifecycle().inDetach());
+    DCHECK(needsAttach());
+    DCHECK(!layoutObject() || (layoutObject()->style() && (layoutObject()->parent() || layoutObject()->isLayoutView())));
 
     clearNeedsStyleRecalc();
 
     if (AXObjectCache* cache = document().axObjectCache())
         cache->updateCacheAfterNodeIsAttached(this);
 }
 
 void Node::detach(const AttachContext& context)
 {
-    ASSERT(document().lifecycle().stateAllowsDetach());
+    DCHECK(document().lifecycle().stateAllowsDetach());
     DocumentLifecycle::DetachScope willDetach(document().lifecycle());
 
     if (layoutObject())
         layoutObject()->destroyAndCleanupAnonymousWrappers();
     setLayoutObject(nullptr);
     setStyleChange(NeedsReattachStyleChange);
     clearChildNeedsStyleInvalidation();
 }
 
 void Node::reattachWhitespaceSiblingsIfNeeded(Text* start)
@@ skipping 90 matching lines @@
 }
 
 ShadowRoot* Node::containingShadowRoot() const
 {
     Node& root = treeScope().rootNode();
     return root.isShadowRoot() ? toShadowRoot(&root) : nullptr;
 }
 
 Node* Node::nonBoundaryShadowTreeRootNode()
 {
-    ASSERT(!isShadowRoot());
+    DCHECK(!isShadowRoot());
     Node* root = this;
     while (root) {
         if (root->isShadowRoot())
             return root;
         Node* parent = root->parentOrShadowHostNode();
         if (parent && parent->isShadowRoot())
             return root;
         root = parent;
     }
     return nullptr;
@@ skipping 847 matching lines @@
 
 EventTargetData* Node::eventTargetData()
 {
     return hasEventTargetData() ? eventTargetDataMap().get(this) : nullptr;
 }
 
 EventTargetData& Node::ensureEventTargetData()
 {
     if (hasEventTargetData())
         return *eventTargetDataMap().get(this);
-    ASSERT(!eventTargetDataMap().contains(this));
+    DCHECK(!eventTargetDataMap().contains(this));
     setHasEventTargetData(true);
     RawPtr<EventTargetData> data = new EventTargetData;
     EventTargetData* dataPtr = data.get();
     eventTargetDataMap().set(this, data.release());
     return *dataPtr;
 }
 
 #if !ENABLE(OILPAN)
 void Node::clearEventTargetData()
 {
     eventTargetDataMap().remove(this);
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     setHasEventTargetData(false);
 #endif
 }
 #endif
 
 HeapVector<Member<MutationObserverRegistration>>* Node::mutationObserverRegistry()
 {
     if (!hasRareData())
         return nullptr;
     NodeMutationObserverData* data = rareData()->mutationObserverData();
@@ skipping 23 matching lines @@
             MutationRecordDeliveryOptions deliveryOptions = registration->deliveryOptions();
             HeapHashMap<Member<MutationObserver>, MutationRecordDeliveryOptions>::AddResult result = observers.add(&registration->observer(), deliveryOptions);
             if (!result.isNewEntry)
                 result.storedValue->value |= deliveryOptions;
         }
     }
 }
 
 void Node::getRegisteredMutationObserversOfType(HeapHashMap<Member<MutationObserver>, MutationRecordDeliveryOptions>& observers, MutationObserver::MutationType type, const QualifiedName* attributeName)
 {
-    ASSERT((type == MutationObserver::Attributes && attributeName) || !attributeName);
+    DCHECK((type == MutationObserver::Attributes && attributeName) || !attributeName);
     collectMatchingObserversForMutation(observers, mutationObserverRegistry(), *this, type, attributeName);
     collectMatchingObserversForMutation(observers, transientMutationObserverRegistry(), *this, type, attributeName);
     ScriptForbiddenScope forbidScriptDuringRawIteration;
     for (Node* node = parentNode(); node; node = node->parentNode()) {
         collectMatchingObserversForMutation(observers, node->mutationObserverRegistry(), *this, type, attributeName);
         collectMatchingObserversForMutation(observers, node->transientMutationObserverRegistry(), *this, type, attributeName);
     }
 }
 
 void Node::registerMutationObserver(MutationObserver& observer, MutationObserverOptions options, const HashSet<AtomicString>& attributeFilter)
@@ skipping 11 matching lines @@
         registry.append(MutationObserverRegistration::create(observer, this, options, attributeFilter));
         registration = registry.last().get();
     }
 
     document().addMutationObserverTypes(registration->mutationTypes());
 }
 
 void Node::unregisterMutationObserver(MutationObserverRegistration* registration)
 {
     HeapVector<Member<MutationObserverRegistration>>* registry = mutationObserverRegistry();
-    ASSERT(registry);
+    DCHECK(registry);
     if (!registry)
         return;
 
     size_t index = registry->find(registration);
-    ASSERT(index != kNotFound);
+    DCHECK_NE(index, kNotFound);
     if (index == kNotFound)
         return;
 
     // Deleting the registration may cause this node to be derefed, so we must make sure the Vector operation completes
     // before that, in case |this| is destroyed (see MutationObserverRegistration::m_registrationNodeKeepAlive).
     // FIXME: Simplify the registration/transient registration logic to make this understandable by humans.
     RawPtr<Node> protect(this);
 #if ENABLE(OILPAN)
     // The explicit dispose() is needed to have the registration
     // object unregister itself promptly.
     registration->dispose();
 #endif
     registry->remove(index);
 }
 
 void Node::registerTransientMutationObserver(MutationObserverRegistration* registration)
 {
     ensureRareData().ensureMutationObserverData().transientRegistry.add(registration);
 }
 
 void Node::unregisterTransientMutationObserver(MutationObserverRegistration* registration)
 {
     HeapHashSet<Member<MutationObserverRegistration>>* transientRegistry = transientMutationObserverRegistry();
-    ASSERT(transientRegistry);
+    DCHECK(transientRegistry);
     if (!transientRegistry)
         return;
 
-    ASSERT(transientRegistry->contains(registration));
+    DCHECK(transientRegistry->contains(registration));
     transientRegistry->remove(registration);
 }
 
 void Node::notifyMutationObserversNodeWillDetach()
 {
     if (!document().hasMutationObservers())
         return;
 
     ScriptForbiddenScope forbidScriptDuringRawIteration;
     for (Node* node = parentNode(); node; node = node->parentNode()) {
@@ skipping 30 matching lines @@
 DispatchEventResult Node::dispatchEventInternal(Event* event)
 {
     return EventDispatcher::dispatchEvent(*this, event->createMediator());
 }
 
 void Node::dispatchSubtreeModifiedEvent()
 {
     if (isInShadowTree())
         return;
 
-    ASSERT(!EventDispatchForbiddenScope::isEventDispatchForbidden());
+#if DCHECK_IS_ON()
+    DCHECK(!EventDispatchForbiddenScope::isEventDispatchForbidden());
+#endif
 
     if (!document().hasListenerType(Document::DOMSUBTREEMODIFIED_LISTENER))
         return;
 
     dispatchScopedEvent(MutationEvent::create(EventTypeNames::DOMSubtreeModified, true));
 }
 
 DispatchEventResult Node::dispatchDOMActivateEvent(int detail, RawPtr<Event> underlyingEvent)
 {
-    ASSERT(!EventDispatchForbiddenScope::isEventDispatchForbidden());
+#if DCHECK_IS_ON()
+    DCHECK(!EventDispatchForbiddenScope::isEventDispatchForbidden());
+#endif
     RawPtr<UIEvent> event = UIEvent::create(EventTypeNames::DOMActivate, true, true, document().domWindow(), detail);
     event->setUnderlyingEvent(underlyingEvent);
     dispatchScopedEvent(event);
 
     // TODO(dtapuska): Dispatching scoped events shouldn't check the return
     // type because the scoped event could get put off in the delayed queue.
     return EventTarget::dispatchEventResult(*event);
 }
 
 DispatchEventResult Node::dispatchMouseEvent(const PlatformMouseEvent& nativeEvent, const AtomicString& eventType,
@@ skipping 112 matching lines @@
 inline void TreeScope::removedLastRefToScope()
 {
     ASSERT_WITH_SECURITY_IMPLICATION(!deletionHasBegun());
     if (m_guardRefCount) {
         // If removing a child removes the last self-only ref, we don't
         // want the scope to be destructed until after
         // removeDetachedChildren returns, so we guard ourselves with an
         // extra self-only ref.
         guardRef();
         dispose();
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
         // We need to do this right now since guardDeref() can delete this.
         rootNode().m_inRemovedLastRefFunction = false;
 #endif
         guardDeref();
     } else {
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
         rootNode().m_inRemovedLastRefFunction = false;
 #endif
 #if ENABLE(SECURITY_ASSERT)
         beginDeletion();
 #endif
         delete this;
     }
 }
 
 // It's important not to inline removedLastRef, because we don't want to inline the code to
@@ skipping 15 matching lines @@
 }
 #endif
 
 unsigned Node::connectedSubframeCount() const
 {
     return hasRareData() ? rareData()->connectedSubframeCount() : 0;
 }
 
 void Node::incrementConnectedSubframeCount()
 {
-    ASSERT(isContainerNode());
+    DCHECK(isContainerNode());
     ensureRareData().incrementConnectedSubframeCount();
 }
 
 void Node::decrementConnectedSubframeCount()
 {
     rareData()->decrementConnectedSubframeCount();
 }
 
 RawPtr<StaticNodeList> Node::getDestinationInsertionPoints()
 {
     updateDistribution();
     HeapVector<Member<InsertionPoint>, 8> insertionPoints;
     collectDestinationInsertionPoints(*this, insertionPoints);
     HeapVector<Member<Node>> filteredInsertionPoints;
     for (size_t i = 0; i < insertionPoints.size(); ++i) {
         InsertionPoint* insertionPoint = insertionPoints[i];
-        ASSERT(insertionPoint->containingShadowRoot());
+        DCHECK(insertionPoint->containingShadowRoot());
         if (!insertionPoint->containingShadowRoot()->isOpenOrV0())
             break;
         filteredInsertionPoints.append(insertionPoint);
     }
     return StaticNodeList::adopt(filteredInsertionPoints);
 }
 
 HTMLSlotElement* Node::assignedSlot() const
 {
-    ASSERT(!needsDistributionRecalc());
+#if DCHECK_IS_ON()
+    DCHECK(!needsDistributionRecalc());
+#endif
     if (ElementShadow* shadow = parentElementShadow()) {
         if (shadow->isV1())
             return shadow->assignedSlotFor(*this);
     }
     return nullptr;
 }
 
 HTMLSlotElement* Node::assignedSlotForBinding()
 {
     updateDistribution();
@@ skipping 14 matching lines @@
     document().userActionElements().setActive(this, flag);
 }
 
 void Node::setHovered(bool flag)
 {
     document().userActionElements().setHovered(this, flag);
 }
 
 bool Node::isUserActionElementActive() const
 {
-    ASSERT(isUserActionElement());
+    DCHECK(isUserActionElement());
     return document().userActionElements().isActive(this);
 }
 
 bool Node::isUserActionElementInActiveChain() const
 {
-    ASSERT(isUserActionElement());
+    DCHECK(isUserActionElement());
     return document().userActionElements().isInActiveChain(this);
 }
 
 bool Node::isUserActionElementHovered() const
 {
-    ASSERT(isUserActionElement());
+    DCHECK(isUserActionElement());
     return document().userActionElements().isHovered(this);
 }
 
 bool Node::isUserActionElementFocused() const
 {
-    ASSERT(isUserActionElement());
+    DCHECK(isUserActionElement());
     return document().userActionElements().isFocused(this);
 }
 
 void Node::setCustomElementState(CustomElementState newState)
 {
     CustomElementState oldState = getCustomElementState();
 
     switch (newState) {
     case NotCustomElement:
         ASSERT_NOT_REACHED(); // Everything starts in this state
         return;
 
     case WaitingForUpgrade:
-        ASSERT(NotCustomElement == oldState);
+        DCHECK_EQ(NotCustomElement, oldState);
         break;
 
     case Upgraded:
-        ASSERT(WaitingForUpgrade == oldState);
+        DCHECK_EQ(WaitingForUpgrade, oldState);
         break;
     }
 
-    ASSERT(isHTMLElement() || isSVGElement());
+    DCHECK(isHTMLElement() || isSVGElement());
     setFlag(CustomElementFlag);
     setFlag(newState == Upgraded, CustomElementUpgradedFlag);
 
     if (oldState == NotCustomElement || newState == Upgraded)
         toElement(this)->pseudoStateChanged(CSSSelector::PseudoUnresolved);
 }
 
 DEFINE_TRACE(Node)
 {
     visitor->trace(m_parentOrShadowHostNode);
@@ skipping 29 matching lines @@
     return 0;
 }
 
 v8::Local<v8::Object> Node::wrap(v8::Isolate* isolate, v8::Local<v8::Object> creationContext)
 {
     // It's possible that no one except for the new wrapper owns this object at
     // this moment, so we have to prevent GC to collect this object until the
     // object gets associated with the wrapper.
     RawPtr<Node> protect(this);
 
-    ASSERT(!DOMDataStore::containsWrapper(this, isolate));
+    DCHECK(!DOMDataStore::containsWrapper(this, isolate));
 
     const WrapperTypeInfo* wrapperType = wrapperTypeInfo();
 
     v8::Local<v8::Object> wrapper = V8DOMWrapper::createWrapper(isolate, creationContext, wrapperType, this);
     if (UNLIKELY(wrapper.IsEmpty()))
         return wrapper;
 
     wrapperType->installConditionallyEnabledProperties(wrapper, isolate);
     return associateWithWrapper(isolate, wrapperType, wrapper);
 }
@@ skipping 25 matching lines @@
 
 void showNodePath(const blink::Node* node)
 {
     if (node)
         node->showNodePathForThis();
     else
         fprintf(stderr, "Cannot showNodePath for (nil)\n");
 }
 
 #endif