JSValueRef.cpp

@@JSStringRef JSValueToStringCopy(JSContextRef ctx, JSValueRef value, JSValueRef*

    
    RefPtr<OpaqueJSString> stringRef(OpaqueJSString::create(jsValue.toString(exec)->value(exec)));

    if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)

425 stringRef.c~~lear()~~;

425 stringRef = nullptr;

    return stringRef.release().leakRef();

}

Source/JavaScriptCore/ChangeLog

2015-07-02  Chris Dumez  <cdumez@apple.com>

        Drop RefPtr::clear() method

        https://bugs.webkit.org/show_bug.cgi?id=146556

        Reviewed by NOBODY (OOPS!).

        * API/JSValueRef.cpp:

        (JSValueToStringCopy):

        * bytecode/CallLinkInfo.cpp:

        (JSC::CallLinkInfo::clearStub):

        * bytecode/StructureStubInfo.h:

        (JSC::StructureStubInfo::reset):

        * dfg/DFGGraph.h:

        (JSC::DFG::Graph::killBlock):

        * dfg/DFGOperations.cpp:

        * inspector/ConsoleMessage.cpp:

        (Inspector::ConsoleMessage::clear):

        * inspector/JSGlobalObjectInspectorController.cpp:

        (Inspector::JSGlobalObjectInspectorController::disconnectFrontend):

        * inspector/agents/InspectorAgent.cpp:

        (Inspector::InspectorAgent::willDestroyFrontendAndBackend):

        * inspector/agents/InspectorConsoleAgent.cpp:

        (Inspector::InspectorConsoleAgent::willDestroyFrontendAndBackend):

        * inspector/agents/InspectorDebuggerAgent.cpp:

        (Inspector::InspectorDebuggerAgent::willDestroyFrontendAndBackend):

        * inspector/agents/JSGlobalObjectRuntimeAgent.cpp:

        (Inspector::JSGlobalObjectRuntimeAgent::willDestroyFrontendAndBackend):

        * runtime/Executable.cpp:

        (JSC::ExecutableBase::clearCode):

        (JSC::EvalExecutable::clearCode):

        (JSC::ProgramExecutable::clearCode):

        (JSC::FunctionExecutable::clearCode):

        * runtime/JSLock.cpp:

        (JSC::JSLockHolder::~JSLockHolder):

        * runtime/Structure.cpp:

        (JSC::Structure::pin):

2015-07-03  Yusuke Suzuki  <utatane.tea@gmail.com>

        Relax builtin JS restriction about try-catch

Source/JavaScriptCore/bytecode/CallLinkInfo.cpp

@@void CallLinkInfo::clearStub()

        return;

    m_stub->clearCallNodesFor(this);

46 m_stub.c~~lear()~~;

46 m_stub = nullptr;

}

void CallLinkInfo::unlink(RepatchBuffer& repatchBuffer)

Source/JavaScriptCore/bytecode/StructureStubInfo.h

@@struct StructureStubInfo {

    {

        deref();

        accessType = access_unset;

152 stubRoutine.c~~lear()~~;

153 watchpoints.c~~lear()~~;

152 stubRoutine = nullptr;

153 watchpoints = nullptr;

    }

    void deref();

Source/JavaScriptCore/debugger/Debugger.cpp

@@public:

    {

        if (m_debugger.m_currentDebuggerCallFrame) {

            m_debugger.m_currentDebuggerCallFrame->invalidate();

120 m_debugger.m_currentDebuggerCallFrame = 0;

120 m_debugger.m_currentDebuggerCallFrame = nullptr;

        }

    }

Source/JavaScriptCore/dfg/DFGGraph.h

@@public:

    
    void killBlock(BlockIndex blockIndex)

    {

446 m_blocks[blockIndex].c~~lear()~~;

446 m_blocks[blockIndex] = nullptr;

    }

    void killBlock(BasicBlock* basicBlock)

Source/JavaScriptCore/dfg/DFGOperations.cpp

@@char* JIT_OPERATION triggerOSREntryNow(

        
        // OSR entry failed. Oh no! This implies that we need to retry. We retry

        // without exponential backoff and we only do this for the entry code block.

1450 jitCode->osrEntryBlock.c~~lear()~~;

1450 jitCode->osrEntryBlock = nullptr;

        jitCode->osrEntryRetry = 0;

        return 0;

    }

Source/JavaScriptCore/inspector/ConsoleMessage.cpp

@@void ConsoleMessage::clear()

        m_message = ASCIILiteral("<message collected>");

    if (m_arguments)

276 m_arguments.c~~lear()~~;

276 m_arguments = nullptr;

}

JSC::ExecState* ConsoleMessage::scriptState() const

Source/JavaScriptCore/inspector/JSGlobalObjectInspectorController.cpp

@@void JSGlobalObjectInspectorController::disconnectFrontend(DisconnectReason reas

    m_agents.willDestroyFrontendAndBackend(reason);

    m_backendDispatcher->clearFrontend();

134 m_backendDispatcher.c~~lear()~~;

134 m_backendDispatcher = nullptr;

    m_frontendChannel = nullptr;

    m_isAutomaticInspection = false;

Source/JavaScriptCore/inspector/agents/InspectorAgent.cpp

@@void InspectorAgent::didCreateFrontendAndBackend(FrontendChannel* frontendChanne

void InspectorAgent::willDestroyFrontendAndBackend(DisconnectReason)

{

    m_frontendDispatcher = nullptr;

60 m_backendDispatcher.c~~lear()~~;

60 m_backendDispatcher = nullptr;

    m_pendingEvaluateTestCommands.clear();

Source/JavaScriptCore/inspector/agents/InspectorConsoleAgent.cpp

@@void InspectorConsoleAgent::didCreateFrontendAndBackend(FrontendChannel* fronten

void InspectorConsoleAgent::willDestroyFrontendAndBackend(DisconnectReason)

{

    m_frontendDispatcher = nullptr;

67 m_backendDispatcher.c~~lear()~~;

67 m_backendDispatcher = nullptr;

    String errorString;

    disable(errorString);

Source/JavaScriptCore/inspector/agents/InspectorDebuggerAgent.cpp

@@void InspectorDebuggerAgent::didCreateFrontendAndBackend(FrontendChannel* fronte

void InspectorDebuggerAgent::willDestroyFrontendAndBackend(DisconnectReason reason)

{

    m_frontendDispatcher = nullptr;

80 m_backendDispatcher.c~~lear()~~;

80 m_backendDispatcher = nullptr;

    bool skipRecompile = reason == DisconnectReason::InspectedTargetDestroyed;

    disable(skipRecompile);

Source/JavaScriptCore/inspector/agents/JSGlobalObjectRuntimeAgent.cpp

@@void JSGlobalObjectRuntimeAgent::didCreateFrontendAndBackend(FrontendChannel* fr

void JSGlobalObjectRuntimeAgent::willDestroyFrontendAndBackend(DisconnectReason reason)

{

    m_frontendDispatcher = nullptr;

52 m_backendDispatcher.c~~lear()~~;

52 m_backendDispatcher = nullptr;

    InspectorRuntimeAgent::willDestroyFrontendAndBackend(reason);

}

Source/JavaScriptCore/parser/Parser.cpp

@@template <class TreeBuilder> TreeExpression Parser<LexerType>::parseVarDeclarati

    JSToken lastIdentToken; 

    do {

        lastIdent = 0;

494 lastPattern = 0;

494 lastPattern = TreeDestructuringPattern(0);

        JSTokenLocation location(tokenLocation());

        next();

        TreeExpression node = 0;

@@template <class TreeBuilder> TreeStatement Parser<LexerType>::parseForStatement(

            declsEnd = lastTokenEndPosition();

            if (pattern && (match(INTOKEN) || (match(IDENT) && *m_token.m_data.ident == m_vm->propertyNames->of)))

                goto enumerationLoop;

897 pattern = 0;

897 pattern = TreeDestructuringPattern(0);

            restoreSavePoint(savePoint);

        }

        m_allowsIn = false;

Source/JavaScriptCore/runtime/Executable.cpp

@@void ExecutableBase::destroy(JSCell* cell)

void ExecutableBase::clearCode()

{

#if ENABLE(JIT)

55 m_jitCodeForCall.c~~lear()~~;

56 m_jitCodeForConstruct.c~~lear()~~;

55 m_jitCodeForCall = nullptr;

56 m_jitCodeForConstruct = nullptr;

    m_jitCodeForCallWithArityCheck = MacroAssemblerCodePtr();

    m_jitCodeForConstructWithArityCheck = MacroAssemblerCodePtr();

    m_jitCodeForCallWithArityCheckAndPreserveRegs = MacroAssemblerCodePtr();

@@void EvalExecutable::unlinkCalls()

void EvalExecutable::clearCode()

{

467 m_evalCodeBlock.c~~lear()~~;

467 m_evalCodeBlock = nullptr;

    m_unlinkedEvalCodeBlock.clear();

    Base::clearCode();

}

@@void ProgramExecutable::visitChildren(JSCell* cell, SlotVisitor& visitor)

void ProgramExecutable::clearCode()

{

546 m_programCodeBlock.c~~lear()~~;

546 m_programCodeBlock = nullptr;

    m_unlinkedProgramCodeBlock.clear();

    Base::clearCode();

}

@@void FunctionExecutable::clearUnlinkedCodeForRecompilation()

void FunctionExecutable::clearCode()

{

590 m_codeBlockForCall.c~~lear()~~;

591 m_codeBlockForConstruct.c~~lear()~~;

590 m_codeBlockForCall = nullptr;

591 m_codeBlockForConstruct = nullptr;

    Base::clearCode();

}

Source/JavaScriptCore/runtime/JSLock.cpp

@@void JSLockHolder::init()

JSLockHolder::~JSLockHolder()

{

    RefPtr<JSLock> apiLock(&m_vm->apiLock());

76 m_vm.c~~lear()~~;

76 m_vm = nullptr;

    apiLock->unlock();

}

Source/JavaScriptCore/runtime/Structure.cpp

@@void Structure::pin()

    ASSERT(propertyTable());

    setIsPinnedPropertyTable(true);

    clearPreviousID();

740 m_nameInPrevious.c~~lear()~~;

740 m_nameInPrevious = nullptr;

}

void Structure::allocateRareData(VM& vm)

Source/WTF/ChangeLog

2015-07-02  Chris Dumez  <cdumez@apple.com>

        Drop RefPtr::clear() method

        https://bugs.webkit.org/show_bug.cgi?id=146556

        Reviewed by NOBODY (OOPS!).

        * wtf/RefPtr.h:

        (WTF::RefPtr::release): Deleted.

        (WTF::RefPtr<T>::leakRef): Deleted.

2015-07-01  Alex Christensen  <achristensen@webkit.org>

        Re-enable WebGL on WinCairo

Source/WTF/wtf/RefPtr.h

@@public:

    
    RefPtr& operator=(const RefPtr&);

    RefPtr& operator=(T*);

80 RefPtr& operator=(std::nullptr_t);

    RefPtr& operator=(const PassRefPtr<T>&);

    template<typename U> RefPtr& operator=(const RefPtr<U>&);

    template<typename U> RefPtr& operator=(const PassRefPtr<U>&);

@@template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(T* optr)

    return *this;

}

template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(std::nullptr_t)

{

    derefIfNotNull(std::exchange(m_ptr, nullptr));

    return *this;

}

template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(const PassRefPtr<T>& o)

{

    RefPtr ptr = o;

Source/WTF/wtf/text/StringBuilder.h

@@public:

    {

        m_length = 0;

        m_string = String();

267 m_buffer = 0;

267 m_buffer = nullptr;

        m_bufferCharacters8 = 0;

        m_is8Bit = true;

    }

Source/WebCore/ChangeLog

2015-07-02  Chris Dumez  <cdumez@apple.com>

        Drop RefPtr::clear() method

        https://bugs.webkit.org/show_bug.cgi?id=146556

        Reviewed by NOBODY (OOPS!).

        * Modules/indexeddb/IDBCursor.cpp:

        (WebCore::IDBCursor::close):

        * Modules/indexeddb/IDBDatabaseBackend.cpp:

        (WebCore::IDBDatabaseBackend::transactionFinished):

        * Modules/indexeddb/IDBObjectStore.cpp:

        * Modules/indexeddb/IDBOpenDBRequest.cpp:

        (WebCore::IDBOpenDBRequest::dispatchEvent):

        * Modules/indexeddb/IDBRequest.cpp:

        (WebCore::IDBRequest::abort):

        (WebCore::IDBRequest::setPendingCursor):

        (WebCore::IDBRequest::onError):

        (WebCore::IDBRequest::onSuccessInternal):

        (WebCore::IDBRequest::transactionDidFinishAndDispatch):

        * Modules/indexeddb/IDBTransaction.cpp:

        (WebCore::IDBTransaction::OpenCursorNotifier::cursorFinished):

        * Modules/mediasource/MediaSource.cpp:

        (WebCore::MediaSource::setReadyState):

        (WebCore::MediaSource::stop):

        * Modules/mediastream/RTCSessionDescriptionRequestImpl.cpp:

        (WebCore::RTCSessionDescriptionRequestImpl::clear):

        * Modules/mediastream/RTCStatsRequestImpl.cpp:

        (WebCore::RTCStatsRequestImpl::clear):

        * Modules/mediastream/RTCVoidRequestImpl.cpp:

        (WebCore::RTCVoidRequestImpl::clear):

        * Modules/webaudio/AudioContext.cpp:

        (WebCore::AudioContext::clear):

        * Modules/webdatabase/SQLTransactionBackend.cpp:

        (WebCore::SQLTransactionBackend::releaseOriginLockIfNeeded):

        * Modules/websockets/WorkerThreadableWebSocketChannel.cpp:

        (WebCore::WorkerThreadableWebSocketChannel::disconnect):

        * bindings/js/WebCoreJSClientData.h:

        (WebCore::WebCoreJSClientData::~WebCoreJSClientData):

        * bindings/js/WorkerScriptController.cpp:

        (WebCore::WorkerScriptController::~WorkerScriptController):

        * contentextensions/ContentExtensionParser.cpp:

        (WebCore::ContentExtensions::parseRuleList):

        * css/CSSParser.cpp:

        (WebCore::CSSParser::parseFillPosition):

        (WebCore::CSSParser::parse2ValuesFillPosition):

        (WebCore::CSSParser::popRuleData):

        (WebCore::CSSParser::markRuleBodyStart):

        * dom/Document.cpp:

        (WebCore::Document::detachParser):

        (WebCore::Document::clearScriptedAnimationController):

        (WebCore::Document::updateHoverActiveState):

        * dom/DocumentMarker.h:

        (WebCore::DocumentMarker::clearDetails):

        * dom/Element.cpp:

        (WebCore::Element::cloneAttributesFromElement):

        * dom/NodeIterator.cpp:

        (WebCore::NodeIterator::NodePointer::clear):

        (WebCore::NodeIterator::detach):

        * dom/Position.h:

        (WebCore::Position::clear):

        * dom/RangeBoundaryPoint.h:

        (WebCore::RangeBoundaryPoint::clear):

        * dom/SpaceSplitString.h:

        (WebCore::SpaceSplitString::clear):

        * dom/StyledElement.cpp:

        (WebCore::StyledElement::setInlineStyleFromString):

        (WebCore::StyledElement::styleAttributeChanged):

        * editing/AlternativeTextController.cpp:

        (WebCore::AlternativeTextController::startAlternativeTextUITimer):

        (WebCore::AlternativeTextController::stopAlternativeTextUITimer):

        (WebCore::AlternativeTextController::applyPendingCorrection):

        (WebCore::AlternativeTextController::timerFired):

        (WebCore::AlternativeTextController::handleAlternativeTextUIResult):

        * editing/EditingStyle.cpp:

        (WebCore::EditingStyle::clear):

        * editing/Editor.cpp:

        (WebCore::Editor::clearLastEditCommand):

        * editing/FrameSelection.cpp:

        (WebCore::FrameSelection::prepareForDestruction):

        * editing/FrameSelection.h:

        (WebCore::FrameSelection::clearTypingStyle):

        * editing/SpellChecker.cpp:

        (WebCore::SpellChecker::didCheck):

        * html/BaseChooserOnlyDateAndTimeInputType.cpp:

        (WebCore::BaseChooserOnlyDateAndTimeInputType::didEndChooser):

        * html/FileInputType.cpp:

        (WebCore::FileInputType::setValue):

        * html/HTMLCanvasElement.cpp:

        (WebCore::HTMLCanvasElement::clearPresentationCopy):

        (WebCore::HTMLCanvasElement::clearCopiedImage):

        * html/HTMLPlugInElement.cpp:

        (WebCore::HTMLPlugInElement::willDetachRenderers):

        (WebCore::HTMLPlugInElement::resetInstance):

        * html/TextFieldInputType.cpp:

        (WebCore::TextFieldInputType::updatePlaceholderText):

        * html/canvas/WebGLRenderingContextBase.cpp:

        (WebCore::WebGLRenderingContextBase::destroyGraphicsContext3D):

        * inspector/InspectorApplicationCacheAgent.cpp:

        (WebCore::InspectorApplicationCacheAgent::willDestroyFrontendAndBackend):

        * inspector/InspectorCSSAgent.cpp:

        (WebCore::InspectorCSSAgent::willDestroyFrontendAndBackend):

        * inspector/InspectorController.cpp:

        (WebCore::InspectorController::disconnectFrontend):

        * inspector/InspectorDOMAgent.cpp:

        (WebCore::InspectorDOMAgent::willDestroyFrontendAndBackend):

        * inspector/InspectorDOMDebuggerAgent.cpp:

        (WebCore::InspectorDOMDebuggerAgent::willDestroyFrontendAndBackend):

        * inspector/InspectorDOMStorageAgent.cpp:

        (WebCore::InspectorDOMStorageAgent::willDestroyFrontendAndBackend):

        * inspector/InspectorDatabaseAgent.cpp:

        (WebCore::InspectorDatabaseAgent::willDestroyFrontendAndBackend):

        * inspector/InspectorIndexedDBAgent.cpp:

        (WebCore::InspectorIndexedDBAgent::willDestroyFrontendAndBackend):

        * inspector/InspectorLayerTreeAgent.cpp:

        (WebCore::InspectorLayerTreeAgent::willDestroyFrontendAndBackend):

        * inspector/InspectorOverlay.cpp:

        (WebCore::InspectorOverlay::hideHighlight):

        (WebCore::InspectorOverlay::highlightNodeList):

        (WebCore::InspectorOverlay::highlightNode):

        * inspector/InspectorPageAgent.cpp:

        (WebCore::InspectorPageAgent::willDestroyFrontendAndBackend):

        (WebCore::InspectorPageAgent::disable):

        * inspector/InspectorReplayAgent.cpp:

        (WebCore::InspectorReplayAgent::willDestroyFrontendAndBackend):

        * inspector/InspectorResourceAgent.cpp:

        (WebCore::InspectorResourceAgent::willDestroyFrontendAndBackend):

        * inspector/InspectorStyleSheet.cpp:

        (WebCore::InspectorStyleSheetForInlineStyle::didModifyElementAttribute):

        (WebCore::InspectorStyleSheetForInlineStyle::setStyleText):

        (WebCore::InspectorStyleSheetForInlineStyle::ensureParsedDataReady):

        * inspector/InspectorTimelineAgent.cpp:

        (WebCore::InspectorTimelineAgent::willDestroyFrontendAndBackend):

        * inspector/InspectorWorkerAgent.cpp:

        (WebCore::InspectorWorkerAgent::willDestroyFrontendAndBackend):

        * inspector/PageRuntimeAgent.cpp:

        (WebCore::PageRuntimeAgent::willDestroyFrontendAndBackend):

        * inspector/WebInjectedScriptManager.cpp:

        (WebCore::WebInjectedScriptManager::disconnect):

        * inspector/WorkerInspectorController.cpp:

        (WebCore::WorkerInspectorController::disconnectFrontend):

        * inspector/WorkerRuntimeAgent.cpp:

        (WebCore::WorkerRuntimeAgent::willDestroyFrontendAndBackend):

        * loader/FrameLoader.cpp:

        (WebCore::FrameLoader::didBeginDocument):

        * loader/cache/CachedCSSStyleSheet.cpp:

        (WebCore::CachedCSSStyleSheet::destroyDecodedData):

        (WebCore::CachedCSSStyleSheet::restoreParsedStyleSheet):

        * loader/cache/CachedImage.cpp:

        (WebCore::CachedImage::clearImage):

        * loader/cache/CachedRawResource.cpp:

        (WebCore::CachedRawResource::clear):

        * loader/cache/CachedResource.cpp:

        (WebCore::CachedResource::error):

        * loader/icon/IconRecord.cpp:

        (WebCore::IconRecord::setImageData):

        * page/EventHandler.cpp:

        (WebCore::EventHandler::clear):

        (WebCore::EventHandler::handleTouchEvent):

        * page/Page.cpp:

        (WebCore::Page::refreshPlugins):

        * platform/audio/mac/CARingBuffer.cpp:

        (WebCore::CARingBuffer::deallocate):

        * platform/graphics/Font.cpp:

        (WebCore::Font::mathData):

        * platform/graphics/FontCache.cpp:

        (WebCore::FontCache::getVerticalData):

        * platform/graphics/GraphicsContext.cpp:

        (WebCore::GraphicsContext::setStrokeColor):

        (WebCore::GraphicsContext::setFillColor):

        (WebCore::GraphicsContext::setStrokePattern):

        (WebCore::GraphicsContext::setFillPattern):

        (WebCore::GraphicsContext::setStrokeGradient):

        (WebCore::GraphicsContext::setFillGradient):

        * platform/graphics/cairo/BackingStoreBackendCairoX11.cpp:

        (WebCore::BackingStoreBackendCairoX11::~BackingStoreBackendCairoX11):

        * platform/graphics/cairo/BitmapImageCairo.cpp:

        (WebCore::FrameData::clear):

        * platform/graphics/filters/FilterEffect.cpp:

        (WebCore::FilterEffect::clearResult):

        (WebCore::FilterEffect::transformResultColorSpace):

        * platform/graphics/gstreamer/ImageGStreamerCairo.cpp:

        (ImageGStreamer::~ImageGStreamer):

        * platform/graphics/texmap/BitmapTextureGL.cpp:

        (WebCore::BitmapTextureGL::applyFilters):

        * platform/graphics/texmap/TextureMapperGL.cpp:

        (WebCore::TextureMapperGL::bindDefaultSurface):

        * platform/graphics/texmap/TextureMapperLayer.cpp:

        (WebCore::TextureMapperLayer::paintWithIntermediateSurface):

        * platform/graphics/texmap/TextureMapperTiledBackingStore.cpp:

        (WebCore::TextureMapperTiledBackingStore::updateContentsFromImageIfNeeded):

        * platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp:

        (WebCore::CoordinatedGraphicsLayer::releaseImageBackingIfNeeded):

        * platform/graphics/texmap/coordinated/CoordinatedImageBacking.cpp:

        (WebCore::CoordinatedImageBacking::releaseSurfaceIfNeeded):

        * platform/gtk/GamepadsGtk.cpp:

        (WebCore::GamepadsGtk::unregisterDevice):

        * rendering/InlineFlowBox.cpp:

        (WebCore::InlineFlowBox::computeOverflow):

        * rendering/RenderBox.cpp:

        (WebCore::RenderBox::clearOverflow):

        * rendering/RenderBoxRegionInfo.h:

        (WebCore::RenderBoxRegionInfo::clearOverflow):

        * rendering/style/FillLayer.h:

        (WebCore::FillLayer::clearMaskImage):

        (WebCore::FillLayer::clearImage):

        * svg/SVGTRefElement.cpp:

        (WebCore::SVGTRefTargetEventListener::detach):

        * testing/Internals.cpp:

        (WebCore::Internals::closeDummyInspectorFrontend):

        * workers/WorkerEventQueue.cpp:

        (WebCore::WorkerEventQueue::EventDispatcher::dispatch):

        (WebCore::WorkerEventQueue::EventDispatcher::cancel):

        * xml/XMLHttpRequest.cpp:

        (WebCore::XMLHttpRequest::responseBlob):

        (WebCore::XMLHttpRequest::responseArrayBuffer):

        (WebCore::XMLHttpRequest::clearResponseBuffers):

        * xml/XSLTProcessor.cpp:

        (WebCore::XSLTProcessor::reset):

2015-07-03  Kyounga Ra  <kyounga@alticast.com>

        Memory leak for a protected Element having pending events in ImageLoader.

Source/WebCore/Modules/indexeddb/IDBCursor.cpp

@@void IDBCursor::close()

    m_transactionNotifier.cursorFinished();

    if (m_request) {

        m_request->finishCursor();

262 m_request.c~~lear()~~;

262 m_request = nullptr;

    }

}

Source/WebCore/Modules/indexeddb/IDBDatabaseBackend.cpp

@@void IDBDatabaseBackend::transactionFinished(IDBTransactionBackend* rawTransacti

    m_transactions.remove(transaction->id());

    if (transaction->mode() == IndexedDB::TransactionMode::VersionChange) {

        ASSERT(transaction.get() == m_runningVersionChangeTransaction.get());

336 m_runningVersionChangeTransaction.c~~lear()~~;

336 m_runningVersionChangeTransaction = nullptr;

    }

}

Source/WebCore/Modules/indexeddb/IDBObjectStore.cpp

@@private:

            // Now that we are done indexing, tell the backend to go

            // back to processing tasks of type NormalTask.

            m_databaseBackend->setIndexesReady(m_transactionId, m_objectStoreId, indexIds);

340 m_databaseBackend.c~~lear()~~;

340 m_databaseBackend = nullptr;

        }

    }

Source/WebCore/Modules/indexeddb/IDBOpenDBRequest.cpp

@@bool IDBOpenDBRequest::dispatchEvent(PassRefPtr<Event> event)

    // If the connection closed between onUpgradeNeeded and the delivery of the "success" event,

    // an "error" event should be fired instead.

    if (event->type() == eventNames().successEvent && m_result->type() == IDBAny::IDBDatabaseType && m_result->idbDatabase()->isClosePending()) {

145 m_result.c~~lear()~~;

145 m_result = nullptr;

        onError(IDBDatabaseError::create(IDBDatabaseException::AbortError, "The connection was closed."));

        return false;

    }

Source/WebCore/Modules/indexeddb/IDBRequest.cpp

@@void IDBRequest::abort()

    m_enqueuedEvents.clear();

    m_errorCode = 0;

173 m_error.c~~lear()~~;

173 m_error = nullptr;

174174 m_errorMessage = String();

175 m_result.c~~lear()~~;

175 m_result = nullptr;

    onError(IDBDatabaseError::create(IDBDatabaseException::AbortError));

    m_requestAborted = true;

}

@@void IDBRequest::setPendingCursor(PassRefPtr<IDBCursor> cursor)

    ASSERT(cursor == getResultCursor());

    m_pendingCursor = cursor;

197 m_result.c~~lear()~~;

197 m_result = nullptr;

198198 m_readyState = PENDING;

199199 m_errorCode = 0;

200 m_error.c~~lear()~~;

200 m_error = nullptr;

    m_errorMessage = String();

    m_transaction->registerRequest(this);

}

@@void IDBRequest::onError(PassRefPtr<IDBDatabaseError> error)

    m_errorCode = error->code();

    m_errorMessage = error->message();

    m_error = DOMError::create(IDBDatabaseException::getErrorName(error->idbCode()));

259 m_pendingCursor.c~~lear()~~;

259 m_pendingCursor = nullptr;

    enqueueEvent(Event::create(eventNames().errorEvent, true, true));

}

@@void IDBRequest::onSuccessInternal(const Deprecated::ScriptValue& value)

    m_result = IDBAny::create(value);

    if (m_pendingCursor) {

        m_pendingCursor->close();

407 m_pendingCursor.c~~lear()~~;

407 m_pendingCursor = nullptr;

    }

    enqueueEvent(createSuccessEvent());

}

@@void IDBRequest::transactionDidFinishAndDispatch()

    ASSERT(m_transaction->isVersionChange());

    ASSERT(m_readyState == DONE);

    ASSERT(scriptExecutionContext());

556 m_transaction.c~~lear()~~;

556 m_transaction = nullptr;

    m_readyState = PENDING;

}

Source/WebCore/Modules/indexeddb/IDBTransaction.cpp

@@void IDBTransaction::OpenCursorNotifier::cursorFinished()

    if (m_cursor) {

        m_transaction->unregisterOpenCursor(m_cursor);

        m_cursor = nullptr;

243 m_transaction.c~~lear()~~;

243 m_transaction = nullptr;

    }

}

Source/WebCore/Modules/mediasource/MediaSource.cpp

@@void MediaSource::setReadyState(const AtomicString& state)

    LOG(MediaSource, "MediaSource::setReadyState(%p) : %s -> %s", this, oldState.string().ascii().data(), state.string().ascii().data());

    if (state == closedKeyword()) {

397 m_private.c~~lear()~~;

397 m_private = nullptr;

        m_mediaElement = nullptr;

        m_duration = MediaTime::invalidTime();

    }

@@void MediaSource::stop()

    m_asyncEventQueue.close();

    if (!isClosed())

        setReadyState(closedKeyword());

814 m_private.c~~lear()~~;

814 m_private = nullptr;

}

bool MediaSource::canSuspendForPageCache() const

Source/WebCore/Modules/mediastream/RTCSessionDescriptionRequestImpl.cpp

@@bool RTCSessionDescriptionRequestImpl::canSuspendForPageCache() const

void RTCSessionDescriptionRequestImpl::clear()

{

100 m_successCallback.c~~lear()~~;

101 m_errorCallback.c~~lear()~~;

100 m_successCallback = nullptr;

101 m_errorCallback = nullptr;

}

} // namespace WebCore

Source/WebCore/Modules/mediastream/RTCStatsRequestImpl.cpp

@@bool RTCStatsRequestImpl::canSuspendForPageCache() const

void RTCStatsRequestImpl::clear()

{

107 m_successCallback.c~~lear()~~;

107 m_successCallback = nullptr;

}

Source/WebCore/Modules/mediastream/RTCVoidRequestImpl.cpp

@@bool RTCVoidRequestImpl::canSuspendForPageCache() const

void RTCVoidRequestImpl::clear()

{

97 m_successCallback.c~~lear()~~;

98 m_errorCallback.c~~lear()~~;

97 m_successCallback = nullptr;

98 m_errorCallback = nullptr;

}

} // namespace WebCore

Source/WebCore/Modules/webaudio/AudioContext.cpp

@@void AudioContext::clear()

{

    // We have to release our reference to the destination node before the context will ever be deleted since the destination node holds a reference to the context.

    if (m_destinationNode)

234 m_destinationNode.c~~lear()~~;

234 m_destinationNode = nullptr;

    // Audio thread is dead. Nobody will schedule node deletion action. Let's do it ourselves.

    do {

Source/WebCore/Modules/webdatabase/SQLTransactionBackend.cpp

@@void SQLTransactionBackend::releaseOriginLockIfNeeded()

{

    if (m_originLock) {

        m_originLock->unlock();

848 m_originLock.c~~lear()~~;

848 m_originLock = nullptr;

    }

}

Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.cpp

@@void WorkerThreadableWebSocketChannel::fail(const String& reason)

void WorkerThreadableWebSocketChannel::disconnect()

{

    m_bridge->disconnect();

129 m_bridge.c~~lear()~~;

129 m_bridge = nullptr;

}

void WorkerThreadableWebSocketChannel::suspend()

Source/WebCore/bindings/js/ScriptController.cpp

@@ScriptController::~ScriptController()

    if (m_cacheableBindingRootObject) {

        JSLockHolder lock(JSDOMWindowBase::commonVM());

        m_cacheableBindingRootObject->invalidate();

105 m_cacheableBindingRootObject = 0;

105 m_cacheableBindingRootObject = nullptr;

    }

    // It's likely that destroying m_windowShells will create a lot of garbage.

@@void ScriptController::clearScriptObjects()

    if (m_bindingRootObject) {

        m_bindingRootObject->invalidate();

492 m_bindingRootObject = 0;

492 m_bindingRootObject = nullptr;

    }

#if ENABLE(NETSCAPE_PLUGIN_API)

@@void ScriptController::clearScriptObjects()

        // script object properly.

        // This shouldn't cause any problems for plugins since they should have already been stopped and destroyed at this point.

        _NPN_DeallocateObject(m_windowScriptNPObject);

501 m_windowScriptNPObject = 0;

501 m_windowScriptNPObject = nullptr;

    }

#endif

}

Source/WebCore/bindings/js/WebCoreJSClientData.h

@@public:

        ASSERT(m_worldSet.contains(m_normalWorld.get()));

        ASSERT(m_worldSet.size() == 1);

        ASSERT(m_normalWorld->hasOneRef());

47 m_normalWorld.c~~lear()~~;

47 m_normalWorld = nullptr;

        ASSERT(m_worldSet.isEmpty());

    }

Source/WebCore/bindings/js/WorkerScriptController.cpp

@@WorkerScriptController::~WorkerScriptController()

{

    JSLockHolder lock(vm());

    m_workerGlobalScopeWrapper.clear();

65 m_vm.c~~lear()~~;

65 m_vm = nullptr;

}

void WorkerScriptController::initScript()

Source/WebCore/bridge/runtime_object.cpp

@@void RuntimeObject::invalidate()

    ASSERT(m_instance);

    if (m_instance)

        m_instance->willInvalidateRuntimeObject();

62 m_instance = 0;

62 m_instance = nullptr;

}

EncodedJSValue RuntimeObject::fallbackObjectGetter(ExecState* exec, JSObject* slotBase, EncodedJSValue, PropertyName propertyName)

Source/WebCore/contentextensions/ContentExtensionParser.cpp

@@std::error_code parseRuleList(const String& rules, Vector<ContentExtensionRule>&

    ExecState* exec = globalObject->globalExec();

    auto error = loadEncodedRules(*exec, rules, ruleList);

280 vm.c~~lear()~~;

280 vm = nullptr;

    if (error)

        return error;

Source/WebCore/css/CSSParser.cpp

@@void CSSParser::parseFillPosition(CSSParserValueList& valueList, RefPtr<CSSValue

    if (value2)

        valueList.next();

    else {

4505 value1.c~~lear()~~;

4505 value1 = nullptr;

        return;

    }

    RefPtr<CSSPrimitiveValue> parsedValue1 = downcast<CSSPrimitiveValue>(value1.get());

    RefPtr<CSSPrimitiveValue> parsedValue2 = downcast<CSSPrimitiveValue>(value2.get());

4512 value1.c~~lear()~~;

4513 value2.c~~lear()~~;

4512 value1 = nullptr;

4513 value2 = nullptr;

    // Per CSS3 syntax, <position> can't have 'center' as its second keyword as we have more arguments to follow.

    if (parsedValue2->getValueID() == CSSValueCenter)

@@void CSSParser::parse2ValuesFillPosition(CSSParserValueList& valueList, RefPtr<C

            valueList.next();

        else {

            if (!inShorthand()) {

4552 value1.c~~lear()~~;

4552 value1 = nullptr;

@@struct ShadowParseContext {

        }

        // Now reset for the next shadow value.

7590 x = 0;

7591 y = 0;

7590 x = nullptr;

7591 y = nullptr;

        blur = nullptr;

        spread = nullptr;

        style = nullptr;

@@PassRefPtr<CSSRuleSourceData> CSSParser::popRuleData()

        return nullptr;

    ASSERT(!m_currentRuleDataStack->isEmpty());

12187 m_currentRuleData.c~~lear()~~;

12187 m_currentRuleData = nullptr;

    RefPtr<CSSRuleSourceData> data = m_currentRuleDataStack->last();

    m_currentRuleDataStack->removeLast();

    return data.release();

@@void CSSParser::markRuleBodyStart()

{

    if (!isExtractingSourceData())

        return;

12608 m_currentRuleData.c~~lear()~~;

12608 m_currentRuleData = nullptr;

    unsigned offset = tokenStartOffset();

    if (tokenStartChar() == '{')

        ++offset; // Skip the rule body opening brace.

Source/WebCore/css/CSSValuePool.cpp

@@void CSSValuePool::drain()

    m_fontFamilyValueCache.clear();

    for (int i = 0; i < numCSSValueKeywords; ++i)

156 m_identifierValueCache[i] = 0;

156 m_identifierValueCache[i] = nullptr;

157157

158158 for (int i = 0; i < maximumCacheableIntegerValue; ++i) {

        m_pixelValueCache[i] = 0;

        m_percentValueCache[i] = 0;

        m_numberValueCache[i] = 0;

        m_pixelValueCache[i] = nullptr;

        m_percentValueCache[i] = nullptr;

        m_numberValueCache[i] = nullptr;

    }

}

Source/WebCore/css/StyleProperties.cpp

@@String StyleProperties::getLayeredShorthandValue(const StylePropertyShorthand& s

                    // Color only belongs in the last layer.

                    if (shorthand.properties()[j] == CSSPropertyBackgroundColor) {

                        if (i != numLayers - 1)

400 value = 0;

400 value = nullptr;

401401 } else if (i) // Other singletons only belong in the first layer.

402 value = 0;

402 value = nullptr;

                }

            }

Source/WebCore/dom/Document.cpp

@@void Document::detachParser()

    if (!m_parser)

        return;

    m_parser->detach();

2427 m_parser.c~~lear()~~;

2427 m_parser = nullptr;

}

void Document::cancelParsing()

@@void Document::clearScriptedAnimationController()

    // FIXME: consider using ActiveDOMObject.

    if (m_scriptedAnimationController)

        m_scriptedAnimationController->clearDocumentPointer();

5885 m_scriptedAnimationController.c~~lear()~~;

5885 m_scriptedAnimationController = nullptr;

}

#endif

@@void Document::updateHoverActiveState(const HitTestRequest& request, Element* in

            curr->setActive(false);

            m_userActionElements.setInActiveChain(curr, false);

        }

6303 m_activeElement.c~~lear()~~;

6303 m_activeElement = nullptr;

    } else {

        Element* newActiveElement = innerElementInDocument;

        if (!oldActiveElement && newActiveElement && request.active() && !request.touchMove()) {

Source/WebCore/dom/DocumentMarker.h

@@public:

    DocumentMarkerDetails* details() const;

    void setActiveMatch(bool);

134 void clearDetails() { m_details.c~~lear()~~; }

134 void clearDetails() { m_details = nullptr; }

    // Offset modifications are done by DocumentMarkerController.

    // Other classes should not call following setters.

Source/WebCore/dom/DocumentStyleSheetCollection.cpp

@@CSSStyleSheet* DocumentStyleSheetCollection::pageUserSheet()

void DocumentStyleSheetCollection::clearPageUserSheet()

{

    if (m_pageUserSheet) {

107 m_pageUserSheet = 0;

107 m_pageUserSheet = nullptr;

        m_document.styleResolverChanged(DeferRecalcStyle);

    }

}

Source/WebCore/dom/Element.cpp

@@void Element::cloneAttributesFromElement(const Element& other)

    other.synchronizeAllAttributes();

    if (!other.m_elementData) {

3210 m_elementData.c~~lear()~~;

3210 m_elementData = nullptr;

        return;

    }

Source/WebCore/dom/MutationObserverRegistration.cpp

@@void MutationObserverRegistration::clearTransientRegistrations()

    m_transientRegistrationNodes = nullptr;

    ASSERT(m_registrationNodeKeepAlive);

92 m_registrationNodeKeepAlive = 0; // Balanced in observeSubtreeNodeWillDetach.

92 m_registrationNodeKeepAlive = nullptr; // Balanced in observeSubtreeNodeWillDetach.

}

void MutationObserverRegistration::unregisterAndDelete(MutationObserverRegistration* registry)

Source/WebCore/dom/NodeIterator.cpp

@@NodeIterator::NodePointer::NodePointer(PassRefPtr<Node> n, bool b)

void NodeIterator::NodePointer::clear()

{

48 node.c~~lear()~~;

48 node = nullptr;

}

bool NodeIterator::NodePointer::moveToNext(Node* root)

@@void NodeIterator::detach()

{

    root()->document().detachNodeIterator(this);

    m_detached = true;

154 m_referenceNode.node.c~~lear()~~;

154 m_referenceNode.node = nullptr;

}

void NodeIterator::nodeWillBeRemoved(Node& removedNode)

Source/WebCore/dom/Position.h

@@public:

    AnchorType anchorType() const { return static_cast<AnchorType>(m_anchorType); }

95 void clear() { m_anchorNode.c~~lear()~~; m_offset = 0; m_anchorType = PositionIsOffsetInAnchor; m_isLegacyEditingPosition = false; }

95 void clear() { m_anchorNode = nullptr; m_offset = 0; m_anchorType = PositionIsOffsetInAnchor; m_isLegacyEditingPosition = false; }

    // These are always DOM compliant values.  Editing positions like [img, 0] (aka [img, before])

    // will return img->parentNode() and img->computeNodeIndex() from these functions.

Source/WebCore/dom/ProcessingInstruction.cpp

@@void ProcessingInstruction::removedFrom(ContainerNode& insertionPoint)

    if (m_sheet) {

        ASSERT(m_sheet->ownerNode() == this);

        m_sheet->clearOwnerNode();

284 m_sheet = 0;

284 m_sheet = nullptr;

    }

    // If we're in document teardown, then we don't need to do any notification of our sheet's removal.

Source/WebCore/dom/RangeBoundaryPoint.h

@@inline int RangeBoundaryPoint::offset() const

inline void RangeBoundaryPoint::clear()

{

115 m_containerNode.c~~lear()~~;

115 m_containerNode = nullptr;

116116 m_offsetInContainer = 0;

117 m_childBeforeBoundary = 0;

117 m_childBeforeBoundary = nullptr;

}

inline void RangeBoundaryPoint::set(PassRefPtr<Node> container, int offset, Node* childBefore)

@@inline void RangeBoundaryPoint::setToStartOfNode(PassRefPtr<Node> container)

    ASSERT(container);

    m_containerNode = container;

    m_offsetInContainer = 0;

152 m_childBeforeBoundary = 0;

152 m_childBeforeBoundary = nullptr;

}

inline void RangeBoundaryPoint::setToEndOfNode(PassRefPtr<Node> container)

@@inline void RangeBoundaryPoint::setToEndOfNode(PassRefPtr<Node> container)

    m_containerNode = container;

    if (m_containerNode->offsetInCharacters()) {

        m_offsetInContainer = m_containerNode->maxCharacterOffset();

161 m_childBeforeBoundary = 0;

161 m_childBeforeBoundary = nullptr;

    } else {

        m_childBeforeBoundary = m_containerNode->lastChild();

        m_offsetInContainer = m_childBeforeBoundary ? invalidOffset : 0;

Source/WebCore/dom/SpaceSplitString.h

@@public:

    bool operator!=(const SpaceSplitString& other) const { return m_data != other.m_data; }

    void set(const AtomicString&, bool shouldFoldCase);

108 void clear() { m_data.c~~lear()~~; }

108 void clear() { m_data = nullptr; }

    bool contains(const AtomicString& string) const { return m_data && m_data->contains(string); }

    bool containsAll(const SpaceSplitString& names) const { return !names.m_data || (m_data && m_data->containsAll(*names.m_data)); }

Source/WebCore/dom/StyledElement.cpp

@@inline void StyledElement::setInlineStyleFromString(const AtomicString& newStyle

    // We reconstruct the property set instead of mutating if there is no CSSOM wrapper.

    // This makes wrapperless property sets immutable and so cacheable.

    if (inlineStyle && !is<MutableStyleProperties>(*inlineStyle))

188 inlineStyle.c~~lear()~~;

188 inlineStyle = nullptr;

    if (!inlineStyle)

        inlineStyle = CSSParser::parseInlineStyleDeclaration(newStyleString, this);

@@void StyledElement::styleAttributeChanged(const AtomicString& newStyleString, At

    if (newStyleString.isNull()) {

        if (PropertySetCSSStyleDeclaration* cssomWrapper = inlineStyleCSSOMWrapper())

            cssomWrapper->clearParentElement();

205 ensureUniqueElementData().m_inlineStyle.c~~lear()~~;

205 ensureUniqueElementData().m_inlineStyle = nullptr;

    } else if (reason == ModifiedByCloning || document().contentSecurityPolicy()->allowInlineStyle(document().url(), startLineNumber))

        setInlineStyleFromString(newStyleString);

Source/WebCore/dom/default/PlatformMessagePortChannel.cpp

@@void PlatformMessagePortChannel::closeInternal()

{

    MutexLocker lock(m_mutex);

    // Disentangle ourselves from the other end. We still maintain a reference to our incoming queue, since previously-existing messages should still be delivered.

    m_remotePort = 0;

    m_entangledChannel = 0;

    m_outgoingQueue = 0;

    m_remotePort = nullptr;

    m_entangledChannel = nullptr;

    m_outgoingQueue = nullptr;

}

} // namespace WebCore

Source/WebCore/editing/AlternativeTextController.cpp

@@void AlternativeTextController::startAlternativeTextUITimer(AlternativeTextType

    // If type is PanelTypeReversion, then the new range has been set. So we shouldn't clear it.

    if (type == AlternativeTextTypeCorrection)

150 m_alternativeTextInfo.rangeWithAlternative.c~~lear()~~;

150 m_alternativeTextInfo.rangeWithAlternative = nullptr;

    m_alternativeTextInfo.type = type;

    m_timer.startOneShot(correctionPanelTimerInterval);

}

@@void AlternativeTextController::startAlternativeTextUITimer(AlternativeTextType

void AlternativeTextController::stopAlternativeTextUITimer()

{

    m_timer.stop();

158 m_alternativeTextInfo.rangeWithAlternative.c~~lear()~~;

158 m_alternativeTextInfo.rangeWithAlternative = nullptr;

}

void AlternativeTextController::stopPendingCorrection(const VisibleSelection& oldSelection)

@@void AlternativeTextController::applyPendingCorrection(const VisibleSelection& s

    if (doApplyCorrection)

        handleAlternativeTextUIResult(dismissSoon(ReasonForDismissingAlternativeTextAccepted)); 

    else

186 m_alternativeTextInfo.rangeWithAlternative.c~~lear()~~;

186 m_alternativeTextInfo.rangeWithAlternative = nullptr;

}

bool AlternativeTextController::hasPendingCorrection() const

@@void AlternativeTextController::timerFired()

        Vector<String> suggestions;

        textChecker()->getGuessesForWord(m_alternativeTextInfo.originalText, paragraphText, suggestions);

        if (suggestions.isEmpty()) {

362 m_alternativeTextInfo.rangeWithAlternative.c~~lear()~~;

362 m_alternativeTextInfo.rangeWithAlternative = nullptr;

            break;

        }

        String topSuggestion = suggestions.first();

@@void AlternativeTextController::handleAlternativeTextUIResult(const String& resu

        break;

    }

425 m_alternativeTextInfo.rangeWithAlternative.c~~lear()~~;

425 m_alternativeTextInfo.rangeWithAlternative = nullptr;

}

bool AlternativeTextController::isAutomaticSpellingCorrectionEnabled()

Source/WebCore/editing/ApplyBlockElementCommand.cpp

@@void ApplyBlockElementCommand::formatSelection(const VisiblePosition& startOfSel

        // Don't put the next paragraph in the blockquote we just created for this paragraph unless 

        // the next paragraph is in the same cell.

        if (enclosingCell && enclosingCell != enclosingNodeOfType(endOfNextParagraph.deepEquivalent(), &isTableCell))

146 blockquoteForNextIndent = 0;

146 blockquoteForNextIndent = nullptr;

        // indentIntoBlockquote could move more than one paragraph if the paragraph

        // is in a list item or a table. As a result, endAfterSelection could refer to a position

Source/WebCore/editing/DeleteSelectionCommand.cpp

@@void DeleteSelectionCommand::saveTypingStyleState()

    if (enclosingNodeOfType(m_selectionToDelete.start(), isMailBlockquote))

        m_deleteIntoBlockquoteStyle = EditingStyle::create(m_selectionToDelete.end());

    else

305 m_deleteIntoBlockquoteStyle = 0;

305 m_deleteIntoBlockquoteStyle = nullptr;

}

bool DeleteSelectionCommand::handleSpecialCaseBRDelete()

@@void DeleteSelectionCommand::calculateTypingStyleAfterDelete()

    // If we deleted into a blockquote, but are now no longer in a blockquote, use the alternate typing style

    if (m_deleteIntoBlockquoteStyle && !enclosingNodeOfType(m_endingPosition, isMailBlockquote, CanCrossEditingBoundary))

        m_typingStyle = m_deleteIntoBlockquoteStyle;

731 m_deleteIntoBlockquoteStyle = 0;

731 m_deleteIntoBlockquoteStyle = nullptr;

    m_typingStyle->prepareToApplyAt(m_endingPosition);

    if (m_typingStyle->isEmpty())

735 m_typingStyle = 0;

735 m_typingStyle = nullptr;

    // This is where we've deleted all traces of a style but not a whole paragraph (that's handled above).

    // In this case if we start typing, the new characters should have the same style as the just deleted ones,

    // but, if we change the selection, come back and start typing that style should be lost.  Also see 

Source/WebCore/editing/EditingStyle.cpp

@@void EditingStyle::overrideTypingStyleAt(const EditingStyle& style, const Positi

void EditingStyle::clear()

{

641 m_mutableStyle.c~~lear()~~;

641 m_mutableStyle = nullptr;

    m_shouldUseFixedDefaultFontSize = false;

    m_fontSizeDelta = NoFontDelta;

    setUnderlineChange(TextDecorationChange::None);

Source/WebCore/editing/Editor.cpp

@@void Editor::removeFormattingAndStyle()

void Editor::clearLastEditCommand() 

{

831 m_lastEditCommand.c~~lear()~~;

831 m_lastEditCommand = nullptr;

}

#if PLATFORM(IOS)

// If the selection is adjusted from UIKit without closing the typing, the typing command may

@@void Editor::unappliedEditing(PassRefPtr<EditCommandComposition> cmd)

    m_alternativeTextController->respondToUnappliedEditing(cmd.get());

1069 m_lastEditCommand = 0;

1069 m_lastEditCommand = nullptr;

    if (client())

        client()->registerRedoStep(cmd);

    respondToChangedContents(newSelection);

@@void Editor::reappliedEditing(PassRefPtr<EditCommandComposition> cmd)

    

    updateEditorUINowIfScheduled();

1087 m_lastEditCommand = 0;

1087 m_lastEditCommand = nullptr;

    if (client())

        client()->registerUndoStep(cmd);

    respondToChangedContents(newSelection);

@@void Editor::setComposition(const String& text, SetCompositionMode mode)

    if (text.isEmpty() && mode != CancelComposition)

        TypingCommand::deleteSelection(document(), 0);

1730 m_compositionNode = 0;

1730 m_compositionNode = nullptr;

    m_customCompositionUnderlines.clear();

    insertTextForConfirmedComposition(text);

@@void Editor::setComposition(const String& text, const Vector<CompositionUnderlin

    if (text.isEmpty())

        TypingCommand::deleteSelection(document(), TypingCommand::PreventSpellChecking);

1805 m_compositionNode = 0;

1805 m_compositionNode = nullptr;

    m_customCompositionUnderlines.clear();

    if (!text.isEmpty()) {

Source/WebCore/editing/FrameSelection.cpp

@@void FrameSelection::prepareForDestruction()

        view->clearSelection();

    setSelectionWithoutUpdatingAppearance(VisibleSelection(), defaultSetSelectionOptions(), AlignCursorOnScrollIfNeeded, CharacterGranularity);

1362 m_previousCaretNode.c~~lear()~~;

1362 m_previousCaretNode = nullptr;

}

void FrameSelection::setStart(const VisiblePosition &pos, EUserTriggered trigger)

Source/WebCore/editing/FrameSelection.h

@@inline EditingStyle* FrameSelection::typingStyle() const

inline void FrameSelection::clearTypingStyle()

{

362 m_typingStyle.c~~lear()~~;

362 m_typingStyle = nullptr;

}

inline void FrameSelection::setTypingStyle(PassRefPtr<EditingStyle> style)

Source/WebCore/editing/IndentOutdentCommand.cpp

@@void IndentOutdentCommand::formatSelection(const VisiblePosition& startOfSelecti

void IndentOutdentCommand::formatRange(const Position& start, const Position& end, const Position&, RefPtr<Element>& blockquoteForNextIndent)

{

    if (tryIndentingAsListItem(start, end))

235 blockquoteForNextIndent = 0;

235 blockquoteForNextIndent = nullptr;

    else

        indentIntoBlockquote(start, end, blockquoteForNextIndent);

}

Source/WebCore/editing/ReplaceSelectionCommand.cpp

@@inline void ReplaceSelectionCommand::InsertedNodes::willRemoveNodePreservingChil

inline void ReplaceSelectionCommand::InsertedNodes::willRemoveNode(Node* node)

{

    if (m_firstNodeInserted == node && m_lastNodeInserted == node) {

357 m_firstNodeInserted = 0;

358 m_lastNodeInserted = 0;

357 m_firstNodeInserted = nullptr;

358 m_lastNodeInserted = nullptr;

    } else if (m_firstNodeInserted == node)

        m_firstNodeInserted = NodeTraversal::nextSkippingChildren(*m_firstNodeInserted);

    else if (m_lastNodeInserted == node)

Source/WebCore/editing/SpellChecker.cpp

@@void SpellChecker::didCheck(int sequence, const Vector<TextCheckingResult>& resu

    if (m_lastProcessedSequence < sequence)

        m_lastProcessedSequence = sequence;

217 m_processingRequest.c~~lear()~~;

217 m_processingRequest = nullptr;

    if (!m_requestQueue.isEmpty())

        m_timerToProcessQueuedRequest.startOneShot(0);

}

Source/WebCore/editing/TextCheckingHelper.cpp

@@void TextCheckingParagraph::expandRangeToNextEnd()

void TextCheckingParagraph::invalidateParagraphRangeValues()

{

    m_checkingStart = m_checkingEnd = -1;

149 m_offsetAsRange = 0;

149 m_offsetAsRange = nullptr;

    m_text = String();

}

Source/WebCore/fileapi/FileReader.cpp

@@void FileReader::readInternal(Blob* blob, FileReaderLoader::ReadType type, Excep

    m_blob = blob;

    m_readType = type;

    m_state = LOADING;

143 m_error = 0;

143 m_error = nullptr;

    m_loader = std::make_unique<FileReaderLoader>(m_readType, this);

    m_loader->setEncoding(m_encoding);

Source/WebCore/fileapi/FileReaderLoader.cpp

@@void FileReaderLoader::terminate()

void FileReaderLoader::cleanup()

{

124 m_loader = 0;

124 m_loader = nullptr;

    // If we get any error, we do not need to keep a buffer around.

    if (m_errorCode) {

128 m_rawData = 0;

128 m_rawData = nullptr;

        m_stringResult = "";

    }

}

Source/WebCore/history/HistoryItem.cpp

@@void HistoryItem::reset()

    m_itemSequenceNumber = generateSequenceNumber();

199 m_stateObject = 0;

199 m_stateObject = nullptr;

200200 m_documentSequenceNumber = generateSequenceNumber();

201201

202 m_formData = 0;

202 m_formData = nullptr;

    m_formContentType = String();

    clearChildren();

@@void HistoryItem::setFormInfoFromRequest(const ResourceRequest& request)

        m_formData = request.httpBody();

        m_formContentType = request.httpContentType();

    } else {

527 m_formData = 0;

527 m_formData = nullptr;

        m_formContentType = String();

    }

}

Source/WebCore/html/BaseChooserOnlyDateAndTimeInputType.cpp

@@void BaseChooserOnlyDateAndTimeInputType::didChooseValue(const String& value)

void BaseChooserOnlyDateAndTimeInputType::didEndChooser()

{

101 m_dateTimeChooser.c~~lear()~~;

101 m_dateTimeChooser = nullptr;

}

void BaseChooserOnlyDateAndTimeInputType::closeDateTimeChooser()

Source/WebCore/html/FTPDirectoryDocument.cpp

@@void FTPDirectoryDocumentParser::finish()

        m_carryOver = String();

    }

414 m_tableElement = 0;

414 m_tableElement = nullptr;

    fastFree(m_buffer);

    HTMLDocumentParser::finish();

Source/WebCore/html/FileInputType.cpp

@@void FileInputType::setValue(const String&, bool, TextFieldEventBehavior)

{

    // FIXME: Should we clear the file list, or replace it with a new empty one here? This is observable from JavaScript through custom properties.

    m_fileList->clear();

253 m_icon.c~~lear()~~;

253 m_icon = nullptr;

    element().setNeedsStyleRecalc();

}

Source/WebCore/html/HTMLCanvasElement.cpp

@@void HTMLCanvasElement::makePresentationCopy()

void HTMLCanvasElement::clearPresentationCopy()

{

426 m_presentedImage.c~~lear()~~;

426 m_presentedImage = nullptr;

}

void HTMLCanvasElement::setSurfaceSize(const IntSize& size)

@@void HTMLCanvasElement::clearImageBuffer() const

void HTMLCanvasElement::clearCopiedImage()

{

647 m_copiedImage.c~~lear()~~;

647 m_copiedImage = nullptr;

    m_didClearImageBuffer = false;

}

Source/WebCore/html/HTMLLinkElement.cpp

@@void HTMLLinkElement::clearSheet()

    ASSERT(m_sheet);

    ASSERT(m_sheet->ownerNode() == this);

    m_sheet->clearOwnerNode();

267 m_sheet = 0;

267 m_sheet = nullptr;

}

Node::InsertionNotificationRequest HTMLLinkElement::insertedInto(ContainerNode& insertionPoint)

Source/WebCore/html/HTMLMediaElement.cpp

@@HTMLMediaElement::~HTMLMediaElement()

    if (m_mediaController) {

        m_mediaController->removeMediaElement(this);

460 m_mediaController = 0;

460 m_mediaController = nullptr;

    }

#if ENABLE(MEDIA_SOURCE)

@@void HTMLMediaElement::prepareForLoad()

    // 1 - Abort any already-running instance of the resource selection algorithm for this element.

    m_loadState = WaitingForSource;

945 m_currentSourceNode = 0;

945 m_currentSourceNode = nullptr;

    // 2 - If there are any tasks from the media element's media element event task source in 

    // one of the task queues, then remove those tasks.

@@void HTMLMediaElement::prepareForLoad()

    setPlaybackRate(defaultPlaybackRate());

    // 6 - Set the error attribute to null and the autoplaying flag to true.

1009 m_error = 0;

1009 m_error = nullptr;

    m_autoplaying = true;

    // 7 - Invoke the media element's resource selection algorithm.

@@void HTMLMediaElement::selectMediaResource()

        if (auto firstSource = childrenOfType<HTMLSourceElement>(*this).first()) {

            mode = children;

            m_nextChildNodeToConsider = firstSource;

1104 m_currentSourceNode = 0;

1104 m_currentSourceNode = nullptr;

        } else {

            // Otherwise the media element has neither a src attribute nor a source element 

            // child: set the networkState to NETWORK_EMPTY, and abort these steps; the 

@@void HTMLMediaElement::loadResource(const URL& initialURL, ContentType& contentT

        else {

            // Forget our reference to the MediaSource, so we leave it alone

            // while processing remainder of load failure.

1280 m_mediaSource = 0;

1280 m_mediaSource = nullptr;

            mediaLoadingFailed(MediaPlayer::FormatError);

        }

    } else

@@void HTMLMediaElement::noneSupported()

    stopPeriodicTimers();

    m_loadState = WaitingForSource;

1803 m_currentSourceNode = 0;

1803 m_currentSourceNode = nullptr;

    // 4.8.10.5 

    // 6 - Reaching this step indicates that the media resource failed to load or that the given 

@@void HTMLMediaElement::closeMediaSource()

        return;

    m_mediaSource->close();

2942 m_mediaSource = 0;

2942 m_mediaSource = nullptr;

}

#endif

@@check_again:

        m_currentSourceNode = source;

        m_nextChildNodeToConsider = source->nextSibling();

    } else {

4115 m_currentSourceNode = 0;

4116 m_nextChildNodeToConsider = 0;

4115 m_currentSourceNode = nullptr;

4116 m_nextChildNodeToConsider = nullptr;

    }

#if !LOG_DISABLED

@@void HTMLMediaElement::sourceWasRemoved(HTMLSourceElement* source)

        // Clear the current source node pointer, but don't change the movie as the spec says:

        // 4.8.8 - Dynamically modifying a source element and its attribute when the element is already 

        // inserted in a video or audio element will have no effect.

4196 m_currentSourceNode = 0;

4196 m_currentSourceNode = nullptr;

        LOG(Media, "HTMLMediaElement::sourceRemoved(%p) - m_currentSourceNode set to 0", this);

    }

}

@@void HTMLMediaElement::userCancelledLoad()

    setShouldDelayLoadEvent(false);

    // 6 - Abort the overall resource selection algorithm.

4798 m_currentSourceNode = 0;

4798 m_currentSourceNode = nullptr;

    // Reset m_readyState since m_player is gone.

    m_readyState = HAVE_NOTHING;

@@void HTMLMediaElement::clearMediaPlayer(int flags)

#if USE(PLATFORM_TEXT_TRACK_MENU)

    if (platformTextTrackMenu()) {

4815 m_platformMenu->setClient(0);

4816 m_platformMenu = 0;

4815 m_platformMenu->setClient(nullptr);

4816 m_platformMenu = nullptr;

    }

#endif

Source/WebCore/html/HTMLPlugInElement.cpp

@@bool HTMLPlugInElement::willRespondToMouseClickEvents()

void HTMLPlugInElement::willDetachRenderers()

{

107 m_instance.c~~lear()~~;

107 m_instance = nullptr;

    if (m_isCapturingMouseEvents) {

        if (Frame* frame = document().frame())

@@void HTMLPlugInElement::willDetachRenderers()

void HTMLPlugInElement::resetInstance()

{

125 m_instance.c~~lear()~~;

125 m_instance = nullptr;

}

PassRefPtr<JSC::Bindings::Instance> HTMLPlugInElement::getInstance()

Source/WebCore/html/HTMLTableElement.cpp

@@void HTMLTableElement::parseAttribute(const QualifiedName& name, const AtomicStr

        HTMLElement::parseAttribute(name, value);

    if (bordersBefore != cellBorders() || oldPadding != m_padding) {

405 m_sharedCellStyle = 0;

405 m_sharedCellStyle = nullptr;

        bool cellChanged = false;

        for (Node* child = firstChild(); child; child = child->nextSibling())

            cellChanged |= setTableCellsChanged(child);

Source/WebCore/html/PluginDocument.cpp

@@void PluginDocument::setPluginElement(PassRefPtr<HTMLPlugInElement> element)

void PluginDocument::detachFromPluginElement()

{

    // Release the plugin Element so that we don't have a circular reference.

171 m_pluginElement = 0;

172 frame()->loader().client().redirectDataToPlugin(0);

171 m_pluginElement = nullptr;

172 frame()->loader().client().redirectDataToPlugin(nullptr);

}

void PluginDocument::cancelManualPluginLoad()

Source/WebCore/html/TextFieldInputType.cpp

@@void TextFieldInputType::updatePlaceholderText()

    if (placeholderText.isEmpty()) {

        if (m_placeholder) {

            m_placeholder->parentNode()->removeChild(m_placeholder.get(), ASSERT_NO_EXCEPTION);

465 m_placeholder.c~~lear()~~;

465 m_placeholder = nullptr;

        }

        return;

    }

Source/WebCore/html/ValidationMessage.cpp

@@void ValidationMessage::deleteBubbleTree()

{

    ASSERT(!validationMessageClient());

    if (m_bubble) {

238 m_messageHeading = 0;

239 m_messageBody = 0;

238 m_messageHeading = nullptr;

239 m_messageBody = nullptr;

240240 m_element->userAgentShadowRoot()->removeChild(m_bubble.get(), ASSERT_NO_EXCEPTION);

241 m_bubble = 0;

241 m_bubble = nullptr;

    }

    m_message = String();

}

Source/WebCore/html/canvas/WebGLProgram.cpp

@@void WebGLProgram::deleteObjectImpl(GraphicsContext3D* context3d, Platform3DObje

    context3d->deleteProgram(obj);

    if (m_vertexShader) {

        m_vertexShader->onDetached(context3d);

61 m_vertexShader = 0;

61 m_vertexShader = nullptr;

    }

    if (m_fragmentShader) {

        m_fragmentShader->onDetached(context3d);

65 m_fragmentShader = 0;

65 m_fragmentShader = nullptr;

    }

}

@@bool WebGLProgram::detachShader(WebGLShader* shader)

    case GraphicsContext3D::VERTEX_SHADER:

        if (m_vertexShader != shader)

            return false;

151 m_vertexShader = 0;

151 m_vertexShader = nullptr;

        return true;

    case GraphicsContext3D::FRAGMENT_SHADER:

        if (m_fragmentShader != shader)

            return false;

156 m_fragmentShader = 0;

156 m_fragmentShader = nullptr;

        return true;

    default:

        return false;

Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp

@@void WebGLRenderingContextBase::initializeNewContext()

    m_unpackFlipY = false;

    m_unpackPremultiplyAlpha = false;

    m_unpackColorspaceConversion = GraphicsContext3D::BROWSER_DEFAULT_WEBGL;

    m_boundArrayBuffer = 0;

    m_currentProgram = 0;

    m_framebufferBinding = 0;

    m_renderbufferBinding = 0;

    m_boundArrayBuffer = nullptr;

    m_currentProgram = nullptr;

    m_framebufferBinding = nullptr;

    m_renderbufferBinding = nullptr;

    m_depthMask = true;

    m_stencilEnabled = false;

    m_stencilMask = 0xFFFFFFFF;

@@void WebGLRenderingContextBase::destroyGraphicsContext3D()

    if (m_context) {

        m_context->setContextLostCallback(nullptr);

        m_context->setErrorMessageCallback(nullptr);

626 m_context.c~~lear()~~;

626 m_context = nullptr;

    }

}

@@void WebGLRenderingContextBase::deleteBuffer(WebGLBuffer* buffer)

    if (!deleteObject(buffer))

        return;

    if (m_boundArrayBuffer == buffer)

1482 m_boundArrayBuffer = 0;

1482 m_boundArrayBuffer = nullptr;

    m_boundVertexArrayObject->unbindBuffer(buffer);

}

@@void WebGLRenderingContextBase::deleteFramebuffer(WebGLFramebuffer* framebuffer)

    if (!deleteObject(framebuffer))

        return;

    if (framebuffer == m_framebufferBinding) {

1492 m_framebufferBinding = 0;

1492 m_framebufferBinding = nullptr;

        m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0);

    }

}

@@void WebGLRenderingContextBase::deleteRenderbuffer(WebGLRenderbuffer* renderbuff

    if (!deleteObject(renderbuffer))

        return;

    if (renderbuffer == m_renderbufferBinding)

1509 m_renderbufferBinding = 0;

1509 m_renderbufferBinding = nullptr;

    if (m_framebufferBinding)

        m_framebufferBinding->removeAttachmentFromBoundFramebuffer(renderbuffer);

}

Source/WebCore/html/canvas/WebGLVertexArrayObjectBase.cpp

@@void WebGLVertexArrayObjectBase::unbindBuffer(PassRefPtr<WebGLBuffer> buffer)

{

    if (m_boundElementArrayBuffer == buffer) {

        m_boundElementArrayBuffer->onDetached(context()->graphicsContext3D());

79 m_boundElementArrayBuffer = 0;

79 m_boundElementArrayBuffer = nullptr;

    }

    for (size_t i = 0; i < m_vertexAttribState.size(); ++i) {

@@void WebGLVertexArrayObjectBase::unbindBuffer(PassRefPtr<WebGLBuffer> buffer)

                state.originalStride = 0;

                state.offset = 0;

            } else

98 state.bufferBinding = 0;

98 state.bufferBinding = nullptr;

Source/WebCore/html/track/TextTrack.cpp

@@TextTrackCueList* TextTrack::cues()

    // http://www.whatwg.org/specs/web-apps/current-work/#dom-texttrack-cues

    if (m_mode != disabledKeyword())

        return ensureTextTrackCueList();

248 return 0;

248 return nullptr;

}

void TextTrack::removeAllCues()

@@void TextTrack::removeAllCues()

        m_client->textTrackRemoveCues(this, m_cues.get());

    for (size_t i = 0; i < m_cues->length(); ++i)

260 m_cues->item(i)->setTrack(0);

260 m_cues->item(i)->setTrack(nullptr);

261261

262 m_cues = 0;

262 m_cues = nullptr;

}

TextTrackCueList* TextTrack::activeCues() const

@@TextTrackCueList* TextTrack::activeCues() const

    // http://www.whatwg.org/specs/web-apps/current-work/#dom-texttrack-activecues

    if (m_cues && m_mode != disabledKeyword())

        return m_cues->activeCues();

275 return 0;

275 return nullptr;

}

void TextTrack::addCue(PassRefPtr<TextTrackCue> prpCue, ExceptionCode& ec)

Source/WebCore/html/track/VTTCue.cpp

@@void VTTCue::setText(const String& text)

    willChange();

    // Clear the document fragment but don't bother to create it again just yet as we can do that

    // when it is requested.

485 m_webVTTNodeTree = 0;

485 m_webVTTNodeTree = nullptr;

    m_content = text;

    didChange();

}

Source/WebCore/inspector/InspectorApplicationCacheAgent.cpp

@@void InspectorApplicationCacheAgent::didCreateFrontendAndBackend(FrontendChannel

void InspectorApplicationCacheAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)

{

    m_frontendDispatcher = nullptr;

61 m_backendDispatcher.c~~lear()~~;

61 m_backendDispatcher = nullptr;

    m_instrumentingAgents->setInspectorApplicationCacheAgent(nullptr);

}

Source/WebCore/inspector/InspectorCSSAgent.cpp

@@void InspectorCSSAgent::didCreateFrontendAndBackend(Inspector::FrontendChannel*

void InspectorCSSAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)

{

    m_frontendDispatcher = nullptr;

363 m_backendDispatcher.c~~lear()~~;

363 m_backendDispatcher = nullptr;

    resetNonPersistentData();

}

Source/WebCore/inspector/InspectorController.cpp

@@void InspectorController::disconnectFrontend(DisconnectReason reason)

    m_agents.willDestroyFrontendAndBackend(reason);

    m_backendDispatcher->clearFrontend();

266 m_backendDispatcher.c~~lear()~~;

266 m_backendDispatcher = nullptr;

    m_frontendChannel = nullptr;

    m_isAutomaticInspection = false;

Source/WebCore/inspector/InspectorDOMAgent.cpp

@@void InspectorDOMAgent::didCreateFrontendAndBackend(Inspector::FrontendChannel*

void InspectorDOMAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)

{

    m_frontendDispatcher = nullptr;

241 m_backendDispatcher.c~~lear()~~;

241 m_backendDispatcher = nullptr;

    m_history.reset();

    m_domEditor.reset();

@@void InspectorDOMAgent::reset()

    discardBindings();

    if (m_revalidateStyleAttrTask)

        m_revalidateStyleAttrTask->reset();

275 m_document = 0;

275 m_document = nullptr;

}

void InspectorDOMAgent::setDOMListener(DOMListener* listener)

Source/WebCore/inspector/InspectorDOMDebuggerAgent.cpp

@@void InspectorDOMDebuggerAgent::didCreateFrontendAndBackend(Inspector::FrontendC

void InspectorDOMDebuggerAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)

{

112 m_backendDispatcher.c~~lear()~~;

112 m_backendDispatcher = nullptr;

    disable();

}

Source/WebCore/inspector/InspectorDOMStorageAgent.cpp

@@void InspectorDOMStorageAgent::didCreateFrontendAndBackend(Inspector::FrontendCh

void InspectorDOMStorageAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)

{

    m_frontendDispatcher = nullptr;

79 m_backendDispatcher.c~~lear()~~;

79 m_backendDispatcher = nullptr;

    ErrorString unused;

    disable(unused);

Source/WebCore/inspector/InspectorDatabaseAgent.cpp

@@void InspectorDatabaseAgent::didCreateFrontendAndBackend(Inspector::FrontendChan

void InspectorDatabaseAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)

{

    m_frontendDispatcher = nullptr;

234 m_backendDispatcher.c~~lear()~~;

234 m_backendDispatcher = nullptr;

    ErrorString unused;

    disable(unused);

Source/WebCore/inspector/InspectorIndexedDBAgent.cpp

@@void InspectorIndexedDBAgent::didCreateFrontendAndBackend(Inspector::FrontendCha

void InspectorIndexedDBAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)

{

585 m_backendDispatcher.c~~lear()~~;

585 m_backendDispatcher = nullptr;

    ErrorString unused;

    disable(unused);

Source/WebCore/inspector/InspectorLayerTreeAgent.cpp

@@void InspectorLayerTreeAgent::didCreateFrontendAndBackend(Inspector::FrontendCha

void InspectorLayerTreeAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)

{

    m_frontendDispatcher = nullptr;

68 m_backendDispatcher.c~~lear()~~;

68 m_backendDispatcher = nullptr;

    ErrorString unused;

    disable(unused);

Source/WebCore/inspector/InspectorOverlay.cpp

@@void InspectorOverlay::setPausedInDebuggerMessage(const String* message)

void InspectorOverlay::hideHighlight()

{

    m_highlightNode.clear();

    m_highlightNodeList.clear();

    m_highlightQuad.reset();

    m_highlightNode = nullptr;

    m_highlightNodeList = nullptr;

    m_highlightQuad = nullptr;

    update();

}

@@void InspectorOverlay::highlightNodeList(PassRefPtr<NodeList> nodes, const Highl

{

    m_nodeHighlightConfig = highlightConfig;

    m_highlightNodeList = nodes;

256 m_highlightNode.c~~lear()~~;

256 m_highlightNode = nullptr;

    update();

}

@@void InspectorOverlay::highlightNode(Node* node, const HighlightConfig& highligh

{

    m_nodeHighlightConfig = highlightConfig;

    m_highlightNode = node;

264 m_highlightNodeList.c~~lear()~~;

264 m_highlightNodeList = nullptr;

    update();

}

Source/WebCore/inspector/InspectorPageAgent.cpp

@@void InspectorPageAgent::didCreateFrontendAndBackend(Inspector::FrontendChannel*

void InspectorPageAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)

{

    m_frontendDispatcher = nullptr;

351 m_backendDispatcher.c~~lear()~~;

351 m_backendDispatcher = nullptr;

    ErrorString unused;

    disable(unused);

@@void InspectorPageAgent::enable(ErrorString&)

void InspectorPageAgent::disable(ErrorString&)

{

    m_enabled = false;

377 m_scriptsToEvaluateOnLoad.c~~lear()~~;

377 m_scriptsToEvaluateOnLoad = nullptr;

    m_instrumentingAgents->setInspectorPageAgent(nullptr);

    ErrorString unused;

Source/WebCore/inspector/InspectorReplayAgent.cpp

@@void InspectorReplayAgent::didCreateFrontendAndBackend(Inspector::FrontendChanne

void InspectorReplayAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)

{

    m_frontendDispatcher = nullptr;

196 m_backendDispatcher.c~~lear()~~;

196 m_backendDispatcher = nullptr;

    m_instrumentingAgents->setInspectorReplayAgent(nullptr);

Source/WebCore/inspector/InspectorResourceAgent.cpp

@@void InspectorResourceAgent::didCreateFrontendAndBackend(Inspector::FrontendChan

void InspectorResourceAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)

{

    m_frontendDispatcher = nullptr;

184 m_backendDispatcher.c~~lear()~~;

184 m_backendDispatcher = nullptr;

    ErrorString unused;

    disable(unused);

Source/WebCore/inspector/InspectorStyleSheet.cpp

@@void InspectorStyleSheetForInlineStyle::didModifyElementAttribute()

    m_isStyleTextValid = false;

    if (m_element->isStyledElement() && m_element->style() != m_inspectorStyle->cssStyle())

        m_inspectorStyle = InspectorStyle::create(InspectorCSSId(id(), 0), inlineStyle(), this);

1264 m_ruleSourceData.c~~lear()~~;

1264 m_ruleSourceData = nullptr;

}

bool InspectorStyleSheetForInlineStyle::getText(String* result) const

@@bool InspectorStyleSheetForInlineStyle::setStyleText(CSSStyleDeclaration* style,

    m_styleText = text;

    m_isStyleTextValid = true;

1288 m_ruleSourceData.c~~lear()~~;

1288 m_ruleSourceData = nullptr;

    return !ec;

}

@@bool InspectorStyleSheetForInlineStyle::ensureParsedDataReady()

    // The "style" property value can get changed indirectly, e.g. via element.style.borderWidth = "2px".

    const String& currentStyleText = elementStyleText();

    if (m_styleText != currentStyleText) {

1307 m_ruleSourceData.c~~lear()~~;

1307 m_ruleSourceData = nullptr;

        m_styleText = currentStyleText;

        m_isStyleTextValid = true;

    }

Source/WebCore/inspector/InspectorTimelineAgent.cpp

@@void InspectorTimelineAgent::didCreateFrontendAndBackend(Inspector::FrontendChan

void InspectorTimelineAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason reason)

{

    m_frontendDispatcher = nullptr;

106 m_backendDispatcher.c~~lear()~~;

106 m_backendDispatcher = nullptr;

    m_instrumentingAgents->setPersistentInspectorTimelineAgent(nullptr);

Source/WebCore/inspector/InspectorWorkerAgent.cpp

@@void InspectorWorkerAgent::willDestroyFrontendAndBackend(Inspector::DisconnectRe

    disable(unused);

    m_frontendDispatcher = nullptr;

130 m_backendDispatcher.c~~lear()~~;

130 m_backendDispatcher = nullptr;

}

void InspectorWorkerAgent::enable(ErrorString&)

Source/WebCore/inspector/PageRuntimeAgent.cpp

@@void PageRuntimeAgent::didCreateFrontendAndBackend(Inspector::FrontendChannel* f

void PageRuntimeAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason reason)

{

    m_frontendDispatcher = nullptr;

72 m_backendDispatcher.c~~lear()~~;

72 m_backendDispatcher = nullptr;

    String unused;

    disable(unused);

Source/WebCore/inspector/WebInjectedScriptManager.cpp

@@void WebInjectedScriptManager::disconnect()

    InjectedScriptManager::disconnect();

    m_commandLineAPIHost->disconnect();

47 m_commandLineAPIHost.c~~lear()~~;

47 m_commandLineAPIHost = nullptr;

}

void WebInjectedScriptManager::didCreateInjectedScript(InjectedScript injectedScript)

Source/WebCore/inspector/WorkerInspectorController.cpp

@@void WorkerInspectorController::disconnectFrontend(Inspector::DisconnectReason r

    m_agents.willDestroyFrontendAndBackend(reason);

    m_backendDispatcher->clearFrontend();

129 m_backendDispatcher.c~~lear()~~;

129 m_backendDispatcher = nullptr;

    m_frontendChannel = nullptr;

}

Source/WebCore/inspector/WorkerRuntimeAgent.cpp

@@void WorkerRuntimeAgent::didCreateFrontendAndBackend(Inspector::FrontendChannel*

void WorkerRuntimeAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason reason)

{

63 m_backendDispatcher.c~~lear()~~;

63 m_backendDispatcher = nullptr;

    InspectorRuntimeAgent::willDestroyFrontendAndBackend(reason);

}

Source/WebCore/loader/DocumentLoader.cpp

@@void DocumentLoader::getIconLoadDecisionForIconURL(const String& urlString)

void DocumentLoader::continueIconLoadWithDecision(IconLoadDecision decision)

{

    ASSERT(m_iconLoadDecisionCallback);

1527 m_iconLoadDecisionCallback = 0;

1527 m_iconLoadDecisionCallback = nullptr;

    if (m_frame)

        m_frame->loader().icon().continueLoadWithDecision(decision);

}

Source/WebCore/loader/DocumentThreadableLoader.cpp

@@PassRefPtr<DocumentThreadableLoader> DocumentThreadableLoader::create(Document&

{

    RefPtr<DocumentThreadableLoader> loader = adoptRef(new DocumentThreadableLoader(document, client, LoadAsynchronously, request, options));

    if (!loader->m_resource)

67 loader = 0;

67 loader = nullptr;

    return loader.release();

}

Source/WebCore/loader/DocumentWriter.cpp

@@void DocumentWriter::replaceDocument(const String& source, Document* ownerDocume

void DocumentWriter::clear()

{

93 m_decoder = 0;

93 m_decoder = nullptr;

    m_hasReceivedSomeData = false;

    if (!m_encodingWasChosenByUser)

        m_encoding = String();

@@void DocumentWriter::end()

    if (!m_parser)

        return;

    m_parser->finish();

248 m_parser = 0;

248 m_parser = nullptr;

}

void DocumentWriter::setEncoding(const String& name, bool userChosen)

Source/WebCore/loader/FrameLoader.cpp

@@void FrameLoader::didBeginDocument(bool dispatch)

    if (m_pendingStateObject) {

        m_frame.document()->statePopped(m_pendingStateObject.get());

695 m_pendingStateObject.c~~lear()~~;

695 m_pendingStateObject = nullptr;

    }

    if (dispatch)

@@void FrameLoader::checkCompleted()

    // OK, completed.

    m_isComplete = true;

821 m_requestedHistoryItem = 0;

821 m_requestedHistoryItem = nullptr;

    m_frame.document()->setReadyState(Document::Complete);

#if PLATFORM(IOS)

@@void FrameLoader::setupForReplace()

    m_client.revertToProvisionalState(m_documentLoader.get());

    setState(FrameStateProvisional);

    m_provisionalDocumentLoader = m_documentLoader;

1140 m_documentLoader = 0;

1140 m_documentLoader = nullptr;

    detachChildren();

}

Source/WebCore/loader/ProgressTracker.cpp

@@void ProgressTracker::reset()

    m_lastNotifiedProgressTime = std::chrono::steady_clock::time_point();

    m_finalProgressChangedSent = false;

    m_numProgressTrackedFrames = 0;

116 m_originatingProgressFrame = 0;

116 m_originatingProgressFrame = nullptr;

    m_heartbeatsWithNoProgress = 0;

    m_totalBytesReceivedBeforePreviousHeartbeat = 0;

Source/WebCore/loader/ResourceLoader.cpp

@@void ResourceLoader::releaseResources()

    // has been deallocated and also to avoid reentering this method.

    Ref<ResourceLoader> protect(*this);

93 m_frame = 0;

94 m_documentLoader = 0;

93 m_frame = nullptr;

94 m_documentLoader = nullptr;

    
    // We need to set reachedTerminalState to true before we release

    // the resources to prevent a double dealloc of WebView <rdar://problem/4372628>

@@void ResourceLoader::releaseResources()

        // Clear out the ResourceHandle's client so that it doesn't try to call

        // us back after we release it, unless it has been replaced by someone else.

        if (m_handle->client() == this)

107 m_handle->setClient(0);

108 m_handle = 0;

107 m_handle->setClient(nullptr);

108 m_handle = nullptr;

109109 }

110110

111 m_resourceData = 0;

111 m_resourceData = nullptr;

    m_deferredRequest = ResourceRequest();

}

@@void ResourceLoader::setDefersLoading(bool defers)

FrameLoader* ResourceLoader::frameLoader() const

{

    if (!m_frame)

228 return 0;

228 return nullptr;

    return &m_frame->loader();

}

@@void ResourceLoader::setDataBufferingPolicy(DataBufferingPolicy dataBufferingPol

    // Reset any already buffered data

    if (dataBufferingPolicy == DoNotBufferData)

247 m_resourceData = 0;

247 m_resourceData = nullptr;

}

void ResourceLoader::willSwitchToSubstituteResource()

@@void ResourceLoader::cancel(const ResourceError& error)

        m_documentLoader->cancelPendingSubstituteLoad(this);

        if (m_handle) {

            m_handle->cancel();

533 m_handle = 0;

533 m_handle = nullptr;

        }

        cleanupForError(nonNullError);

    }

Source/WebCore/loader/appcache/ApplicationCacheGroup.cpp

@@void ApplicationCacheGroup::stopLoading()

        m_manifestHandle->setClient(0);

        m_manifestHandle->cancel();

330 m_manifestHandle = 0;

330 m_manifestHandle = nullptr;

    }

    if (m_currentHandle) {

@@void ApplicationCacheGroup::stopLoading()

        m_currentHandle->setClient(0);

        m_currentHandle->cancel();

341 m_currentHandle = 0;

341 m_currentHandle = nullptr;

    }    

    // FIXME: Resetting just a tiny part of the state in this function is confusing. Callers have to take care of a lot more.

345 m_cacheBeingUpdated = 0;

345 m_cacheBeingUpdated = nullptr;

    m_pendingEntries.clear();

}    

@@void ApplicationCacheGroup::didReceiveResponse(ResourceHandle* handle, const Res

            m_cacheBeingUpdated->addResource(ApplicationCacheResource::create(url, newestCachedResource->response(), type, newestCachedResource->data(), newestCachedResource->path()));

            m_pendingEntries.remove(m_currentHandle->firstRequest().url());

            m_currentHandle->cancel();

524 m_currentHandle = 0;

524 m_currentHandle = nullptr;

            // Load the next resource, if any.

            startLoadingEntry();

            return;

@@void ApplicationCacheGroup::didReceiveResponse(ResourceHandle* handle, const Res

        } else if (response.httpStatusCode() == 404 || response.httpStatusCode() == 410) {

            // Skip this resource. It is dropped from the cache.

            m_currentHandle->cancel();

541 m_currentHandle = 0;

541 m_currentHandle = nullptr;

            m_pendingEntries.remove(url);

            // Load the next resource, if any.

            startLoadingEntry();

@@void ApplicationCacheGroup::didReceiveResponse(ResourceHandle* handle, const Res

            m_cacheBeingUpdated->addResource(ApplicationCacheResource::create(url, newestCachedResource->response(), type, newestCachedResource->data(), newestCachedResource->path()));

            m_pendingEntries.remove(m_currentHandle->firstRequest().url());

            m_currentHandle->cancel();

554 m_currentHandle = 0;

554 m_currentHandle = nullptr;

            // Load the next resource, if any.

            startLoadingEntry();

        }

@@void ApplicationCacheGroup::didFinishLoading(ResourceHandle* handle, double fini

    ASSERT(m_cacheBeingUpdated);

    m_cacheBeingUpdated->addResource(m_currentResource.release());

598 m_currentHandle = 0;

598 m_currentHandle = nullptr;

    // While downloading check to see if we have exceeded the available quota.

    // We can stop immediately if we have already previously failed

@@void ApplicationCacheGroup::didFinishLoading(ResourceHandle* handle, double fini

    // of the quota being reached and decided not to increase it then.

    // FIXME: Should we break earlier and prevent redownloading on later page loads?

    if (m_originQuotaExceededPreviously && m_availableSpaceInQuota < m_cacheBeingUpdated->estimatedSizeInStorage()) {

606 m_currentResource = 0;

606 m_currentResource = nullptr;

        m_frame->document()->addConsoleMessage(MessageSource::AppCache, MessageLevel::Error, ASCIILiteral("Application Cache update failed, because size quota was exceeded."));

        cacheUpdateFailed();

        return;

@@void ApplicationCacheGroup::didFail(ResourceHandle* handle, const ResourceError&

        url.removeFragmentIdentifier();

    ASSERT(!m_currentResource || !m_pendingEntries.contains(url));

634 m_currentResource = 0;

634 m_currentResource = nullptr;

    m_pendingEntries.remove(url);

    if ((type & ApplicationCacheResource::Explicit) || (type & ApplicationCacheResource::Fallback)) {

@@void ApplicationCacheGroup::didFinishLoadingManifest()

        return;

    }

698 m_manifestHandle = 0;

698 m_manifestHandle = nullptr;

    // Check if the manifest was not modified.

    if (isUpgradeAttempt) {

@@void ApplicationCacheGroup::didFinishLoadingManifest()

            (newestManifest->data()->size() == m_manifestResource->data()->size() && !memcmp(newestManifest->data()->data(), m_manifestResource->data()->data(), newestManifest->data()->size()))) {

            m_completionType = NoUpdate;

709 m_manifestResource = 0;

709 m_manifestResource = nullptr;

            deliverDelayedMainResources();

            return;

@@void ApplicationCacheGroup::didReachOriginQuota(int64_t totalSpaceNeeded)

void ApplicationCacheGroup::cacheUpdateFailed()

{

    stopLoading();

785 m_manifestResource = 0;

785 m_manifestResource = nullptr;

    // Wait for master resource loads to finish.

    m_completionType = Failure;

@@void ApplicationCacheGroup::manifestNotFound()

    stopLoading();

    ASSERT(m_pendingEntries.isEmpty());

810 m_manifestResource = 0;

810 m_manifestResource = nullptr;

    while (!m_pendingMasterResourceLoaders.isEmpty()) {

        HashSet<DocumentLoader*>::iterator it = m_pendingMasterResourceLoaders.begin();

Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp

@@void CachedCSSStyleSheet::destroyDecodedData()

        return;

    m_parsedStyleSheetCache->removedFromMemoryCache();

141 m_parsedStyleSheetCache.c~~lear()~~;

141 m_parsedStyleSheetCache = nullptr;

    setDecodedSize(0);

}

@@void CachedCSSStyleSheet::destroyDecodedData()

PassRefPtr<StyleSheetContents> CachedCSSStyleSheet::restoreParsedStyleSheet(const CSSParserContext& context, CachePolicy cachePolicy)

{

    if (!m_parsedStyleSheetCache)

149 return 0;

149 return nullptr;

150150 if (!m_parsedStyleSheetCache->subresourcesAllowReuse(cachePolicy)) {

151151 m_parsedStyleSheetCache->removedFromMemoryCache();

152 m_parsedStyleSheetCache.c~~lear()~~;

153 return 0;

152 m_parsedStyleSheetCache = nullptr;

153 return nullptr;

    }

    ASSERT(m_parsedStyleSheetCache->isCacheable());

@@PassRefPtr<StyleSheetContents> CachedCSSStyleSheet::restoreParsedStyleSheet(cons

    // Contexts must be identical so we know we would get the same exact result if we parsed again.

    if (m_parsedStyleSheetCache->parserContext() != context)

161 return 0;

161 return nullptr;

    didAccessDecodedData(monotonicallyIncreasingTime());

Source/WebCore/loader/cache/CachedImage.cpp

@@inline void CachedImage::clearImage()

    // If our Image has an observer, it's always us so we need to clear the back pointer

    // before dropping our reference.

    if (m_image)

368 m_image->setImageObserver(0);

369 m_image.c~~lear()~~;

368 m_image->setImageObserver(nullptr);

369 m_image = nullptr;

}

void CachedImage::addIncrementalDataBuffer(SharedBuffer& data)

@@void CachedImage::destroyDecodedData()

{

    bool canDeleteImage = !m_image || (m_image->hasOneRef() && m_image->isBitmapImage());

    if (canDeleteImage && !isLoading() && !hasClients()) {

461 m_image = 0;

461 m_image = nullptr;

        setDecodedSize(0);

    } else if (m_image && !errorOccurred())

        m_image->destroyDecodedData();

Source/WebCore/loader/cache/CachedRawResource.cpp

@@bool CachedRawResource::canReuse(const ResourceRequest& newRequest) const

void CachedRawResource::clear()

{

271 m_data.c~~lear()~~;

271 m_data = nullptr;

    setEncodedSize(0);

    if (m_loader)

        m_loader->clearResourceData();

Source/WebCore/loader/cache/CachedResource.cpp

@@void CachedResource::error(CachedResource::Status status)

{

    setStatus(status);

    ASSERT(errorOccurred());

320 m_data.c~~lear()~~;

320 m_data = nullptr;

    setLoading(false);

    checkNotify();

Source/WebCore/loader/icon/IconRecord.cpp

@@void IconRecord::setImageData(PassRefPtr<SharedBuffer> data)

    // Copy the provided data into the buffer of the new Image object.

    if (!m_image->setData(data, true)) {

        LOG(IconDatabase, "Manual image data for iconURL '%s' FAILED - it was probably invalid image data", m_iconURL.ascii().data());

74 m_image.c~~lear()~~;

74 m_image = nullptr;

    }

    m_dataSet = true;

Source/WebCore/page/EventHandler.cpp

@@void EventHandler::clear()

    m_mousePositionIsUnknown = true;

    m_lastKnownMousePosition = IntPoint();

    m_lastKnownMouseGlobalPosition = IntPoint();

488 m_mousePressNode = 0;

488 m_mousePressNode = nullptr;

    m_mousePressed = false;

    m_capturesDragging = false;

    m_capturingMouseEventsElement = nullptr;

@@void EventHandler::clear()

#endif

#if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)

    m_originatingTouchPointTargets.clear();

497 m_originatingTouchPointDocument.c~~lear()~~;

497 m_originatingTouchPointDocument = nullptr;

    m_originatingTouchPointTargetKey = 0;

#endif

    m_maxMouseMovedDuration = 0;

@@bool EventHandler::handleTouchEvent(const PlatformTouchEvent& event)

    }

    m_touchPressed = touches->length() > 0;

    if (allTouchReleased)

3997 m_originatingTouchPointDocument.c~~lear()~~;

3997 m_originatingTouchPointDocument = nullptr;

    // Now iterate the changedTouches list and m_targets within it, sending events to the targets as required.

    bool swallowedEvent = false;

Source/WebCore/page/Page.cpp

@@void Page::refreshPlugins(bool reload)

    Vector<Ref<Frame>> framesNeedingReload;

    for (auto& page : *allPages) {

519 page->m_pluginData.c~~lear()~~;

519 page->m_pluginData = nullptr;

        if (!reload)

            continue;

Source/WebCore/platform/audio/mac/CARingBuffer.cpp

@@void CARingBuffer::allocate(uint32_t channelCount, size_t bytesPerFrame, size_t

void CARingBuffer::deallocate()

{

    if (m_buffers)

89 m_buffers.c~~lear()~~;

89 m_buffers = nullptr;

    m_channelCount = 0;

    m_capacityBytes = 0;

Source/WebCore/platform/graphics/Font.cpp

@@const OpenTypeMathData* Font::mathData() const

    if (!m_mathData) {

        m_mathData = OpenTypeMathData::create(m_platformData);

        if (!m_mathData->hasMathData())

366 m_mathData.c~~lear()~~;

366 m_mathData = nullptr;

    }

    return m_mathData.get();

}

Source/WebCore/platform/graphics/FontCache.cpp

@@PassRefPtr<OpenTypeVerticalData> FontCache::getVerticalData(const FontFileKey& k

    RefPtr<OpenTypeVerticalData> verticalData = OpenTypeVerticalData::create(platformData);

    if (!verticalData->isOpenType())

323 verticalData.c~~lear()~~;

323 verticalData = nullptr;

    fontVerticalDataCache.set(key, verticalData);

    return verticalData;

}

Source/WebCore/platform/graphics/GraphicsContext.cpp

@@void GraphicsContext::setStrokeColor(const Color& color, ColorSpace colorSpace)

{

    m_state.strokeColor = color;

    m_state.strokeColorSpace = colorSpace;

181 m_state.strokeGradient.c~~lear()~~;

182 m_state.strokePattern.c~~lear()~~;

181 m_state.strokeGradient = nullptr;

182 m_state.strokePattern = nullptr;

    setPlatformStrokeColor(color, colorSpace);

}

@@void GraphicsContext::setFillColor(const Color& color, ColorSpace colorSpace)

{

    m_state.fillColor = color;

    m_state.fillColorSpace = colorSpace;

248 m_state.fillGradient.c~~lear()~~;

249 m_state.fillPattern.c~~lear()~~;

248 m_state.fillGradient = nullptr;

249 m_state.fillPattern = nullptr;

    setPlatformFillColor(color, colorSpace);

}

@@void GraphicsContext::setAntialiasedFontDilationEnabled(bool antialiasedFontDila

void GraphicsContext::setStrokePattern(Ref<Pattern>&& pattern)

{

272 m_state.strokeGradient.c~~lear()~~;

272 m_state.strokeGradient = nullptr;

    m_state.strokePattern = WTF::move(pattern);

}

void GraphicsContext::setFillPattern(Ref<Pattern>&& pattern)

{

278 m_state.fillGradient.c~~lear()~~;

278 m_state.fillGradient = nullptr;

    m_state.fillPattern = WTF::move(pattern);

}

void GraphicsContext::setStrokeGradient(Ref<Gradient>&& gradient)

{

    m_state.strokeGradient = WTF::move(gradient);

285 m_state.strokePattern.c~~lear()~~;

285 m_state.strokePattern = nullptr;

}

void GraphicsContext::setFillGradient(Ref<Gradient>&& gradient)

{

    m_state.fillGradient = WTF::move(gradient);

291 m_state.fillPattern.c~~lear()~~;

291 m_state.fillPattern = nullptr;

}

void GraphicsContext::beginTransparencyLayer(float opacity)

Source/WebCore/platform/graphics/MediaPlayer.cpp

@@bool MediaPlayer::load(const URL& url, const ContentType& contentType, const Str

    m_contentMIMETypeWasInferredFromExtension = false;

#if ENABLE(MEDIA_SOURCE)

317 m_mediaSource = 0;

317 m_mediaSource = nullptr;

318318#endif

319319#if ENABLE(MEDIA_STREAM)

320 m_mediaStream = 0;

320 m_mediaStream = nullptr;

#endif

    // If the MIME type is missing or is not meaningful, try to figure it out from the URL.

Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp

@@void GraphicsLayerCA::updateContentsImage()

    } else {

        // No image.

        // m_contentsLayer will be removed via updateSublayerList.

2211 m_contentsLayer = 0;

2211 m_contentsLayer = nullptr;

    }

}

Source/WebCore/platform/graphics/cairo/BackingStoreBackendCairoX11.cpp

@@BackingStoreBackendCairoX11::BackingStoreBackendCairoX11(unsigned long rootWindo

BackingStoreBackendCairoX11::~BackingStoreBackendCairoX11()

{

    // The pixmap needs to exist when the surface is destroyed, so begin by clearing it.

46 m_surface.c~~lear()~~;

46 m_surface = nullptr;

}

void BackingStoreBackendCairoX11::scroll(const IntRect& scrollRect, const IntSize& scrollOffset)

Source/WebCore/platform/graphics/cairo/BitmapImageCairo.cpp

@@bool FrameData::clear(bool clearMetadata)

        m_haveMetadata = false;

    if (m_frame) {

162 m_frame.c~~lear()~~;

162 m_frame = nullptr;

        return true;

    }

    return false;

Source/WebCore/platform/graphics/filters/FilterEffect.cpp

@@void FilterEffect::clearResult()

    if (m_imageBufferResult)

        m_imageBufferResult.reset();

    if (m_unmultipliedImageResult)

248 m_unmultipliedImageResult.c~~lear()~~;

248 m_unmultipliedImageResult = nullptr;

249249 if (m_premultipliedImageResult)

250 m_premultipliedImageResult.c~~lear()~~;

250 m_premultipliedImageResult = nullptr;

251251#if ENABLE(OPENCL)

252252 if (m_openCLImageResult)

253 m_openCLImageResult.c~~lear()~~;

253 m_openCLImageResult = nullptr;

#endif

}

@@void FilterEffect::transformResultColorSpace(ColorSpace dstColorSpace)

#if ENABLE(OPENCL)

    if (openCLImage()) {

        if (m_imageBufferResult)

543 m_imageBufferResult.c~~lear()~~;

543 m_imageBufferResult = nullptr;

        FilterContextOpenCL* context = FilterContextOpenCL::context();

        ASSERT(context);

        context->openCLTransformColorSpace(m_openCLImageResult, absolutePaintRect(), m_resultColorSpace, dstColorSpace);

@@void FilterEffect::transformResultColorSpace(ColorSpace dstColorSpace)

    m_resultColorSpace = dstColorSpace;

    if (m_unmultipliedImageResult)

561 m_unmultipliedImageResult.c~~lear()~~;

561 m_unmultipliedImageResult = nullptr;

562562 if (m_premultipliedImageResult)

563 m_premultipliedImageResult.c~~lear()~~;

563 m_premultipliedImageResult = nullptr;

#endif

}

Source/WebCore/platform/graphics/gstreamer/ImageGStreamerCairo.cpp

@@ImageGStreamer::ImageGStreamer(GstSample* sample)

ImageGStreamer::~ImageGStreamer()

{

    if (m_image)

        m_image.clear();

    m_image = 0;

74 m_image = nullptr;

    // We keep the buffer memory mapped until the image is destroyed because the internal

    // cairo_surface_t was created using cairo_image_surface_create_for_data().

Source/WebCore/platform/graphics/texmap/BitmapTextureGL.cpp

@@PassRefPtr<BitmapTexture> BitmapTextureGL::applyFilters(TextureMapper* textureMa

            texmapGL->drawFiltered(*resultSurface.get(), spareSurface.get(), *filter, j);

            if (!j && filter->type() == FilterOperation::DROP_SHADOW) {

                spareSurface = resultSurface;

281 resultSurface.c~~lear()~~;

281 resultSurface = nullptr;

            }

            std::swap(resultSurface, intermediateSurface);

        }

Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp

@@void TextureMapperGL::bindDefaultSurface()

    data().projectionMatrix = createProjectionMatrix(viewportSize, data().PaintFlags & PaintingMirrored);

    m_context3D->viewport(data().viewport[0], data().viewport[1], viewportSize.width(), viewportSize.height());

    m_clipStack.apply(m_context3D.get());

694 data().currentSurface.c~~lear()~~;

694 data().currentSurface = nullptr;

}

void TextureMapperGL::bindSurface(BitmapTexture *surface)

Source/WebCore/platform/graphics/texmap/TextureMapperLayer.cpp

@@void TextureMapperLayer::paintWithIntermediateSurface(const TextureMapperPaintOp

    if (replicaSurface && options.opacity == 1) {

        commitSurface(options, replicaSurface, rect, 1);

411 replicaSurface.c~~lear()~~;

411 replicaSurface = nullptr;

    }

    mainSurface = paintIntoSurface(paintOptions, rect.size());

Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.cpp

@@void TextureMapperTiledBackingStore::updateContentsFromImageIfNeeded(TextureMapp

        return;

    updateContents(textureMapper, m_image.get(), m_image->size(), enclosingIntRect(m_image->rect()), BitmapTexture::UpdateCannotModifyOriginalImageData);

42 m_image.c~~lear()~~;

42 m_image = nullptr;

}

TransformationMatrix TextureMapperTiledBackingStore::adjustedTransformForRect(const FloatRect& targetRect)

Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp

@@void CoordinatedGraphicsLayer::releaseImageBackingIfNeeded()

    ASSERT(m_coordinator);

    m_coordinatedImageBacking->removeHost(this);

823 m_coordinatedImageBacking.c~~lear()~~;

823 m_coordinatedImageBacking = nullptr;

    m_layerState.imageID = InvalidCoordinatedImageBackingID;

    m_layerState.imageChanged = true;

}

Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedImageBacking.cpp

@@void CoordinatedImageBacking::releaseSurfaceIfNeeded()

{

    // We must keep m_surface until UI Process reads m_surface.

    // If m_surface exists, it was created in the previous update.

144 m_surface.c~~lear()~~;

144 m_surface = nullptr;

}

static const double clearContentsTimerInterval = 3;

Source/WebCore/platform/gtk/GamepadsGtk.cpp

@@void GamepadsGtk::unregisterDevice(String deviceFile)

    size_t index = m_slots.find(gamepadDevice);

    ASSERT(index != notFound);

158 m_slots[index].c~~lear()~~;

158 m_slots[index] = nullptr;

}

void GamepadsGtk::updateGamepadList(GamepadList* into)

Source/WebCore/platform/ios/PlatformSpeechSynthesizerIOS.mm

@@- (void)speechSynthesizer:(AVSpeechSynthesizer *)synthesizer didFinishSpeechUtte

    
    // Clear the m_utterance variable in case finish speaking kicks off a new speaking job immediately.

    RefPtr<WebCore::PlatformSpeechSynthesisUtterance> platformUtterance = m_utterance;

182 m_utterance = 0;

182 m_utterance = nullptr;

    
    m_synthesizerObject->client()->didFinishSpeaking(platformUtterance);

}

@@- (void)speechSynthesizer:(AVSpeechSynthesizer *)synthesizer didCancelSpeechUtte

    
    // Clear the m_utterance variable in case finish speaking kicks off a new speaking job immediately.

    RefPtr<WebCore::PlatformSpeechSynthesisUtterance> platformUtterance = m_utterance;

216 m_utterance = 0;

216 m_utterance = nullptr;

    
    m_synthesizerObject->client()->didFinishSpeaking(platformUtterance);

}

Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.cpp

@@void PlatformSpeechSynthesizerMock::speakingFinished()

{

    ASSERT(m_utterance.get());

    RefPtr<PlatformSpeechSynthesisUtterance> protect(m_utterance);

48 m_utterance = 0;

48 m_utterance = nullptr;

    
    client()->didFinishSpeaking(protect);

}

@@void PlatformSpeechSynthesizerMock::cancel()

    
    m_speakingFinishedTimer.stop();

    client()->speakingErrorOccurred(m_utterance);

81 m_utterance = 0;

81 m_utterance = nullptr;

}

void PlatformSpeechSynthesizerMock::pause()

Source/WebCore/platform/network/cf/ResourceRequestCFNet.cpp

@@void ResourceRequest::doUpdateResourceRequest()

void ResourceRequest::doUpdateResourceHTTPBody()

{

    if (!m_cfRequest) {

298 m_httpBody = 0;

298 m_httpBody = nullptr;

        return;

    }

Source/WebCore/rendering/InlineFlowBox.cpp

@@void InlineFlowBox::computeOverflow(LayoutUnit lineTop, LayoutUnit lineBottom, G

        return;

    if (m_overflow)

957 m_overflow.c~~lear()~~;

957 m_overflow = nullptr;

    // Visual overflow just includes overflow for stuff we need to repaint ourselves.  Self-painting layers are ignored.

    // Layout overflow is used to determine scrolling extent, so it still includes child layers and also factors in

Source/WebCore/rendering/RenderBox.cpp

@@void RenderBox::addVisualOverflow(const LayoutRect& rect)

void RenderBox::clearOverflow()

{

4500 m_overflow.c~~lear()~~;

4500 m_overflow = nullptr;

    RenderFlowThread* flowThread = flowThreadContainingBlock();

    if (flowThread)

        flowThread->clearRegionsOverflow(this);

Source/WebCore/rendering/RenderBoxRegionInfo.h

@@public:

    void clearOverflow()

    {

        if (m_overflow)

56 m_overflow.c~~lear()~~;

56 m_overflow = nullptr;

    }

private:

Source/WebCore/rendering/RenderCounter.cpp

@@static bool findPlaceForCounter(RenderElement& counterOwner, const AtomicString&

    // towards the begining of the document for counters with the same identifier as the one

    // we are trying to find a place for. This is the next renderer to be checked.

    RenderElement* currentRenderer = previousInPreOrder(counterOwner);

189 previousSibling = 0;

190 RefPtr<CounterNode> previousSiblingProtector ~~= 0~~;

189 previousSibling = nullptr;

190 RefPtr<CounterNode> previousSiblingProtector;

    while (currentRenderer) {

        CounterNode* currentCounter = makeCounterNode(*currentRenderer, identifier, false);

@@static bool findPlaceForCounter(RenderElement& counterOwner, const AtomicString&

                            // hence we are the next sibling of that counter if that reset is not a root or

                            // we are a root node if that reset is a root.

                            parent = currentCounter->parent();

206 previousSibling = parent ? currentCounter : 0;

206 previousSibling = parent ? currentCounter : nullptr;

                            return parent;

                        }

                        // We are not a reset node or the previous reset must be on an ancestor of our owner renderer

@@static bool findPlaceForCounter(RenderElement& counterOwner, const AtomicString&

                        // In these cases the identified previousSibling will be invalid as its parent is different from

                        // our identified parent.

                        if (previousSiblingProtector->parent() != currentCounter)

216 previousSiblingProtector = 0;

216 previousSiblingProtector = nullptr;

                        previousSibling = previousSiblingProtector.get();

                        return true;

Source/WebCore/rendering/RenderMenuList.cpp

@@RenderMenuList::~RenderMenuList()

#if !PLATFORM(IOS)

    if (m_popup)

        m_popup->disconnectClient();

91 m_popup = 0;

91 m_popup = nullptr;

#endif

}

Source/WebCore/rendering/RenderSearchField.cpp

@@RenderSearchField::~RenderSearchField()

{

    if (m_searchPopup) {

        m_searchPopup->popupMenu()->disconnectClient();

65 m_searchPopup = 0;

65 m_searchPopup = nullptr;

    }

}

Source/WebCore/rendering/style/FillLayer.h

@@public:

    void setSize(FillSize f) { m_sizeType = f.type; m_sizeLength = f.size; }

    void setMaskSourceType(EMaskSourceType m) { m_maskSourceType = m; m_maskSourceTypeSet = true; }

124 void clearMaskImage() { m_maskImageOperation.c~~lear()~~; }

125 void clearImage() { m_image.c~~lear()~~; m_imageSet = false; }

124 void clearMaskImage() { m_maskImageOperation = nullptr; }

125 void clearImage() { m_image = nullptr; m_imageSet = false; }

    void clearXPosition() { m_xPosSet = false; m_backgroundOriginSet = false; }

    void clearYPosition() { m_yPosSet = false; m_backgroundOriginSet = false; }

Source/WebCore/rendering/style/RenderStyle.cpp

@@void RenderStyle::setQuotes(PassRefPtr<QuotesData> q)

void RenderStyle::clearCursorList()

{

    if (rareInheritedData->cursorData)

953 rareInheritedData.access()->cursorData = 0;

953 rareInheritedData.access()->cursorData = nullptr;

}

void RenderStyle::clearContent()

Source/WebCore/svg/SVGTRefElement.cpp

@@void SVGTRefTargetEventListener::detach()

    m_target->removeEventListener(eventNames().DOMSubtreeModifiedEvent, this, false);

    m_target->removeEventListener(eventNames().DOMNodeRemovedFromDocumentEvent, this, false);

107 m_target.c~~lear()~~;

107 m_target = nullptr;

}

bool SVGTRefTargetEventListener::operator==(const EventListener& listener)

Source/WebCore/testing/Internals.cpp

@@void Internals::closeDummyInspectorFrontend()

    m_frontendChannel = nullptr;

    m_frontendWindow->close(m_frontendWindow->scriptExecutionContext());

1726 m_frontendWindow.c~~lear()~~;

1726 m_frontendWindow = nullptr;

}

void Internals::setJavaScriptProfilingEnabled(bool enabled, ExceptionCode& ec)

Source/WebCore/workers/WorkerEventQueue.cpp

@@public:

            return;

        m_eventQueue.m_eventDispatcherMap.remove(m_event.get());

        m_event->target()->dispatchEvent(m_event);

71 m_event.c~~lear()~~;

71 m_event = nullptr;

    }

    void cancel()

    {

        m_isCancelled = true;

77 m_event.c~~lear()~~;

77 m_event = nullptr;

    }

private:

Source/WebCore/workers/WorkerMessagingProxy.cpp

@@void WorkerMessagingProxy::workerGlobalScopeDestroyedInternal()

    // WorkerGlobalScopeDestroyedTask is always the last to be performed, so the proxy is not needed for communication

    // in either side any more. However, the Worker object may still exist, and it assumes that the proxy exists, too.

    m_askedToTerminate = true;

267 m_workerThread = 0;

267 m_workerThread = nullptr;

    InspectorInstrumentation::workerGlobalScopeTerminated(m_scriptExecutionContext.get(), this);

Source/WebCore/workers/WorkerThread.cpp

@@void WorkerThread::workerThread()

    // The below assignment will destroy the context, which will in turn notify messaging proxy.

    // We cannot let any objects survive past thread exit, because no other thread will run GC or otherwise destroy them.

174 m_workerGlobalScope = 0;

174 m_workerGlobalScope = nullptr;

    // Clean up WebCore::ThreadGlobalData before WTF::WTFThreadData goes away!

    threadGlobalData().destroy();

Source/WebCore/xml/XMLHttpRequest.cpp

@@Blob* XMLHttpRequest::responseBlob()

            data.append(m_binaryResponseBuilder->data(), m_binaryResponseBuilder->size());

            String normalizedContentType = Blob::normalizedContentType(responseMIMEType()); // responseMIMEType defaults to text/xml which may be incorrect.

            m_responseBlob = Blob::create(WTF::move(data), normalizedContentType);

248 m_binaryResponseBuilder.c~~lear()~~;

248 m_binaryResponseBuilder = nullptr;

        } else {

            // If we errored out or got no data, we still return a blob, just an empty one.

            m_responseBlob = Blob::create();

@@ArrayBuffer* XMLHttpRequest::responseArrayBuffer()

            m_responseArrayBuffer = m_binaryResponseBuilder->createArrayBuffer();

        else

            m_responseArrayBuffer = ArrayBuffer::create(nullptr, 0);

268 m_binaryResponseBuilder.c~~lear()~~;

268 m_binaryResponseBuilder = nullptr;

    }

    return m_responseArrayBuffer.get();

@@void XMLHttpRequest::clearResponseBuffers()

    m_createdDocument = false;

    m_responseDocument = nullptr;

    m_responseBlob = nullptr;

871 m_binaryResponseBuilder.c~~lear()~~;

872 m_responseArrayBuffer.c~~lear()~~;

871 m_binaryResponseBuilder = nullptr;

872 m_responseArrayBuffer = nullptr;

    m_responseCacheIsValid = false;

}

Source/WebCore/xml/XSLTProcessor.cpp

@@void XSLTProcessor::removeParameter(const String& /*namespaceURI*/, const String

void XSLTProcessor::reset()

{

165 m_stylesheet.c~~lear()~~;

166 m_stylesheetRootNode.c~~lear()~~;

165 m_stylesheet = nullptr;

166 m_stylesheetRootNode = nullptr;

    m_parameters.clear();

}

Source/WebKit/Storage/StorageAreaSync.cpp

@@void StorageAreaSync::scheduleFinalSync()

    ASSERT(isMainThread());

    // FIXME: We do this to avoid races, but it'd be better to make things safe without blocking.

    blockUntilImportComplete();

91 m_storageArea = 0; // This is done in blockUntilImportComplete() but this is here as a form of documentation that we must be absolutely sure the ref count cycle is broken.

91 m_storageArea = nullptr; // This is done in blockUntilImportComplete() but this is here as a form of documentation that we must be absolutely sure the ref count cycle is broken.

    if (m_syncTimer.isActive())

        m_syncTimer.stop();

@@void StorageAreaSync::blockUntilImportComplete()

    MutexLocker locker(m_importLock);

    while (!m_importComplete)

        m_importCondition.wait(m_importLock);

378 m_storageArea = 0;

378 m_storageArea = nullptr;

}

void StorageAreaSync::sync(bool clearItems, const HashMap<String, String>& items)

Source/WebKit/mac/ChangeLog

2015-07-02  Chris Dumez  <cdumez@apple.com>

        Drop RefPtr::clear() method

        https://bugs.webkit.org/show_bug.cgi?id=146556

        Reviewed by NOBODY (OOPS!).

        * WebCoreSupport/WebEditorClient.mm:

        (WebEditorClient::didCheckSucceed):

2015-07-02  Timothy Horton  <timothy_horton@apple.com>

        Fix the build.

Source/WebKit/mac/Plugins/Hosted/WebHostedNetscapePluginView.mm

@@- (void)destroyPlugin

        }

        _proxy->destroy();

284 _proxy = 0;

284 _proxy = nullptr;

    }

    _pluginLayer = 0;

@@- (void)pluginHostDied

        downcast<RenderEmbeddedObject>(*_element->renderer()).setPluginUnavailabilityReason(RenderEmbeddedObject::PluginCrashed);

    _pluginLayer = nil;

435 _proxy = 0;

435 _proxy = nullptr;

    
    // No need for us to be layer backed anymore

    self.wantsLayer = NO;

Source/WebKit/mac/WebCoreSupport/WebEditorClient.mm

@@void WebEditorClient::didCheckSucceed(int sequence, NSArray* results)

{

    ASSERT_UNUSED(sequence, sequence == m_textCheckingRequest->data().sequence());

    m_textCheckingRequest->didSucceed(core(results, m_textCheckingRequest->data().mask()));

1146 m_textCheckingRequest.c~~lear()~~;

1146 m_textCheckingRequest = nullptr;

}

#endif

Source/WebKit/mac/WebCoreSupport/WebUserMediaClient.mm

@@- (void)cancelRequest

    if (!_request)

        return;

145 _request = 0;

145 _request = nullptr;

#endif

}

Source/WebKit/win/ChangeLog

2015-07-02  Chris Dumez  <cdumez@apple.com>

        Drop RefPtr::clear() method

        https://bugs.webkit.org/show_bug.cgi?id=146556

        Reviewed by NOBODY (OOPS!).

        * WebView.cpp:

        (WebView::deleteBackingStore):

        (WebView::updateBackingStore):

2015-06-30  Simon Fraser  <simon.fraser@apple.com>

        Fix Mac and Windows builds.

Source/WebKit/win/WebView.cpp

@@void WebView::deleteBackingStore()

        KillTimer(m_viewWindow, DeleteBackingStoreTimer);

        m_deleteBackingStoreTimerActive = false;

    }

854 m_backingStoreBitmap.c~~lear()~~;

855 m_backingStoreDirtyRegion.c~~lear()~~;

854 m_backingStoreBitmap = nullptr;

855 m_backingStoreDirtyRegion = nullptr;

    m_backingStoreSize.cx = m_backingStoreSize.cy = 0;

}

@@void WebView::updateBackingStore(FrameView* frameView, HDC dc, bool backingStore

        if (m_uiDelegatePrivate)

            m_uiDelegatePrivate->webViewPainted(this);

1082 m_backingStoreDirtyRegion.c~~lear()~~;

1082 m_backingStoreDirtyRegion = nullptr;

    }

    if (!dc)

Source/WebKit2/ChangeLog

2015-07-02  Chris Dumez  <cdumez@apple.com>

        Drop RefPtr::clear() method

        https://bugs.webkit.org/show_bug.cgi?id=146556

        Reviewed by NOBODY (OOPS!).

        * DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp:

        (WebKit::UniqueIDBDatabase::shutdownBackingStore):

        * Shared/CoordinatedGraphics/CoordinatedBackingStore.cpp:

        (WebKit::CoordinatedBackingStoreTile::swapBuffers):

        * UIProcess/API/efl/EwkView.cpp:

        (EwkView::hideContextMenu):

        * UIProcess/InspectorServer/WebSocketServerConnection.cpp:

        (WebKit::WebSocketServerConnection::didCloseSocketStream):

        * UIProcess/Network/CustomProtocols/mac/CustomProtocolManagerProxyMac.mm:

        (-[WKCustomProtocolLoader dealloc]):

        * UIProcess/ios/WKGeolocationProviderIOS.mm:

        (-[WKGeolocationProviderIOS _stopUpdating]):

2015-07-03  Carlos Garcia Campos  <cgarcia@igalia.com>

        REGRESSION(r186025): [SOUP] NetworkCache gets blocked in traverse since r186025

Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp

@@void UniqueIDBDatabase::shutdownBackingStore(UniqueIDBDatabaseShutdownType type,

{

    ASSERT(!RunLoop::isMain());

150 m_backingStore.c~~lear()~~;

150 m_backingStore = nullptr;

    if (type == UniqueIDBDatabaseShutdownType::DeleteShutdown) {

        String dbFilename = UniqueIDBDatabase::calculateAbsoluteDatabaseFilename(databaseDirectory);

Source/WebKit2/PluginProcess/PluginControllerProxy.cpp

@@bool PluginControllerProxy::initialize(const PluginCreationParameters& creationP

        // used as an identifier so it's OK to just get a weak reference.

        Plugin* plugin = m_plugin.get();

129 m_plugin = 0;

129 m_plugin = nullptr;

        // This will delete the plug-in controller proxy object.

        m_connection->removePluginControllerProxy(this, plugin);

@@void PluginControllerProxy::destroy()

    Plugin* plugin = m_plugin.get();

    m_plugin->destroyPlugin();

159 m_plugin = 0;

159 m_plugin = nullptr;

    platformDestroy();

Source/WebKit2/Shared/ChildProcessProxy.cpp

@@ChildProcessProxy::~ChildProcessProxy()

    if (m_processLauncher) {

        m_processLauncher->invalidate();

45 m_processLauncher = 0;

45 m_processLauncher = nullptr;

    }

}

Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedBackingStore.cpp

@@void CoordinatedBackingStoreTile::swapBuffers(TextureMapper* textureMapper)

        texture->reset(m_tileRect.size(), m_surface->supportsAlpha());

    m_surface->copyToTexture(texture, m_sourceRect, m_surfaceOffset);

58 m_surface.c~~lear()~~;

58 m_surface = nullptr;

}

void CoordinatedBackingStoreTile::setBackBuffer(const IntRect& tileRect, const IntRect& sourceRect, PassRefPtr<CoordinatedSurface> buffer, const IntPoint& offset)

Source/WebKit2/UIProcess/API/efl/EwkView.cpp

@@void EwkView::hideContextMenu()

    if (sd->api->context_menu_hide)

        sd->api->context_menu_hide(sd);

943 m_contextMenu.c~~lear()~~;

943 m_contextMenu = nullptr;

}

void EwkView::requestPopupMenu(WKPopupMenuListenerRef popupMenuListener, const WKRect& rect, WKPopupItemTextDirection textDirection, double pageScaleFactor, WKArrayRef items, int32_t selectedIndex)

Source/WebKit2/UIProcess/API/mac/WKView.mm

@@- (void)_setPromisedDataForAttachment:(NSString *)filename withExtension:(NSStri

- (void)pasteboardChangedOwner:(NSPasteboard *)pasteboard

{

3523 _data->_promisedImage = 0;

3523 _data->_promisedImage = nullptr;

    _data->_promisedFilename = "";

    _data->_promisedURL = "";

}

@@- (void)pasteboard:(NSPasteboard *)pasteboard provideDataForType:(NSString *)typ

    if ([type isEqual:NSTIFFPboardType] && _data->_promisedImage) {

        [pasteboard setData:(NSData *)_data->_promisedImage->getTIFFRepresentation() forType:NSTIFFPboardType];

3534 _data->_promisedImage = 0;

3534 _data->_promisedImage = nullptr;

    }

}

Source/WebKit2/UIProcess/InspectorServer/WebSocketServerConnection.cpp

@@void WebSocketServerConnection::sendRawData(const char* data, size_t length)

void WebSocketServerConnection::didCloseSocketStream(SocketStreamHandle*)

{

    // Destroy the SocketStreamHandle now to prevent closing an already closed socket later.

129 m_socket.c~~lear()~~;

129 m_socket = nullptr;

    // Web Socket Mode.

    if (m_mode == WebSocket)

Source/WebKit2/UIProcess/Network/CustomProtocols/mac/CustomProtocolManagerProxyMac.mm

@@- (id)initWithCustomProtocolManagerProxy:(CustomProtocolManagerProxy*)customProt

- (void)dealloc

{

79 _connection.c~~lear()~~;

79 _connection = nullptr;

    [_urlConnection cancel];

    [_urlConnection release];

    [super dealloc];

Source/WebKit2/UIProcess/StatisticsRequest.cpp

@@void StatisticsRequest::completedRequest(uint64_t requestID, const StatisticsDat

    if (m_outstandingRequests.isEmpty()) {

        m_callback->performCallbackWithReturnValue(m_responseDictionary.get());

98 m_callback = 0;

98 m_callback = nullptr;

    }

}

Source/WebKit2/UIProcess/WebFrameListenerProxy.cpp

@@WebFrameListenerProxy::~WebFrameListenerProxy()

void WebFrameListenerProxy::invalidate()

{

45 m_frame = 0;

45 m_frame = nullptr;

}

void WebFrameListenerProxy::receivedPolicyDecision(WebCore::PolicyAction action)

@@void WebFrameListenerProxy::receivedPolicyDecision(WebCore::PolicyAction action)

        return;

    m_frame->receivedPolicyDecision(action, m_listenerID, m_navigation.get());

54 m_frame = 0;

54 m_frame = nullptr;

}

} // namespace WebKit

Source/WebKit2/UIProcess/WebFrameProxy.cpp

@@WebFrameProxy::~WebFrameProxy()

void WebFrameProxy::webProcessWillShutDown()

{

60 m_page = 0;

60 m_page = nullptr;

    if (m_activeListener) {

        m_activeListener->invalidate();

64 m_activeListener = 0;

64 m_activeListener = nullptr;

    }

}

Source/WebKit2/UIProcess/WebOpenPanelResultListenerProxy.cpp

@@void WebOpenPanelResultListenerProxy::cancel()

void WebOpenPanelResultListenerProxy::invalidate()

{

92 m_page = 0;

92 m_page = nullptr;

}

} // namespace WebKit

Source/WebKit2/UIProcess/WebPageProxy.cpp

@@void WebPageProxy::runOpenPanel(uint64_t frameID, const FileChooserSettings& set

{

    if (m_openPanelResultListener) {

        m_openPanelResultListener->invalidate();

3709 m_openPanelResultListener = 0;

3709 m_openPanelResultListener = nullptr;

    }

    WebFrameProxy* frame = m_process->webFrame(frameID);

@@void WebPageProxy::showColorPicker(const WebCore::Color& initialColor, const Int

#if ENABLE(INPUT_TYPE_COLOR_POPOVER)

    // A new popover color well needs to be created (and the previous one destroyed) for

    // each activation of a color element.

3811 m_colorPicker = 0;

3811 m_colorPicker = nullptr;

#endif

    if (!m_colorPicker)

        m_colorPicker = m_pageClient.createColorPicker(this, initialColor, elementRect);

@@void WebPageProxy::didChooseFilesForOpenPanel(const Vector<String>& fileURLs)

    m_process->send(Messages::WebPage::DidChooseFilesForOpenPanel(fileURLs), m_pageID);

    m_openPanelResultListener->invalidate();

4303 m_openPanelResultListener = 0;

4303 m_openPanelResultListener = nullptr;

}

void WebPageProxy::didCancelForOpenPanel()

@@void WebPageProxy::didCancelForOpenPanel()

    m_process->send(Messages::WebPage::DidCancelForOpenPanel(), m_pageID);

    m_openPanelResultListener->invalidate();

4314 m_openPanelResultListener = 0;

4314 m_openPanelResultListener = nullptr;

}

void WebPageProxy::advanceToNextMisspelling(bool startBeforeSelection)

@@void WebPageProxy::printFinishedCallback(const ResourceError& printError, uint64

void WebPageProxy::focusedFrameChanged(uint64_t frameID)

{

    if (!frameID) {

4770 m_focusedFrame = 0;

4770 m_focusedFrame = nullptr;

        return;

    }

@@void WebPageProxy::focusedFrameChanged(uint64_t frameID)

void WebPageProxy::frameSetLargestFrameChanged(uint64_t frameID)

{

    if (!frameID) {

4783 m_frameSetLargestFrame = 0;

4783 m_frameSetLargestFrame = nullptr;

        return;

    }

Source/WebKit2/UIProcess/ios/WKGeolocationProviderIOS.mm

@@-(void)_stopUpdating

{

    _isWebCoreGeolocationActive = NO;

    [_coreLocationProvider stop];

121 _lastActivePosition.c~~lear()~~;

121 _lastActivePosition = nullptr;

}

-(void)_setEnableHighAccuracy:(BOOL)enableHighAccuracy

Source/WebKit2/WebProcess/InjectedBundle/mac/InjectedBundleMac.mm

@@bool InjectedBundle::initialize(const WebProcessCreationParameters& parameters,

            return false;

        }

58 m_sandboxExtension = 0;

58 m_sandboxExtension = nullptr;

    }

    RetainPtr<CFStringRef> injectedBundlePathStr = m_path.createCFString();

Source/WebKit2/WebProcess/Network/WebResourceLoader.cpp

@@void WebResourceLoader::cancelResourceLoader()

void WebResourceLoader::detachFromCoreLoader()

{

79 m_coreLoader = 0;

79 m_coreLoader = nullptr;

}

void WebResourceLoader::willSendRequest(const ResourceRequest& proposedRequest, const ResourceResponse& redirectResponse)

Source/WebKit2/WebProcess/Plugins/Netscape/NetscapePlugin.cpp

@@void NetscapePlugin::cancelStreamLoad(NetscapePluginStream* pluginStream)

void NetscapePlugin::removePluginStream(NetscapePluginStream* pluginStream)

{

    if (pluginStream == m_manualStream) {

280 m_manualStream = 0;

280 m_manualStream = nullptr;

        return;

    }

Source/WebKit2/WebProcess/Plugins/PDF/PDFPlugin.mm

@@void PDFPlugin::destroy()

            frameView->removeScrollableArea(this);

    }

1106 m_activeAnnotation = 0;

1107 m_annotationContainer = 0;

1106 m_activeAnnotation = nullptr;

1107 m_annotationContainer = nullptr;

    destroyScrollbar(HorizontalScrollbar);

    destroyScrollbar(VerticalScrollbar);

@@void PDFPlugin::setActiveAnnotation(PDFAnnotation *annotation)

    if (annotation) {

        if ([annotation isKindOfClass:pdfAnnotationTextWidgetClass()] && static_cast<PDFAnnotationTextWidget *>(annotation).isReadOnly) {

1607 m_activeAnnotation = 0;

1607 m_activeAnnotation = nullptr;

            return;

        }

        m_activeAnnotation = PDFPluginAnnotation::create(annotation, m_pdfLayerController.get(), this);

        m_activeAnnotation->attach(m_annotationContainer.get());

    } else

1614 m_activeAnnotation = 0;

1614 m_activeAnnotation = nullptr;

}

bool PDFPlugin::supportsForms()

Source/WebKit2/WebProcess/Plugins/PluginView.cpp

@@void PluginView::Stream::cancel()

    m_streamWasCancelled = true;

    m_loader->cancel(m_loader->cancelledError());

169 m_loader = 0;

169 m_loader = nullptr;

}

static String buildHTTPHeaders(const ResourceResponse& response, long long& expectedContentLength)

@@void PluginView::initializePlugin()

void PluginView::didFailToInitializePlugin()

{

607 m_plugin = 0;

607 m_plugin = nullptr;

#if ENABLE(NETSCAPE_PLUGIN_API)

    String frameURLString = frame()->loader().documentLoader()->responseURL().string();

Source/WebKit2/WebProcess/WebPage/WebPage.cpp

@@void WebPage::close()

    }

#if ENABLE(FULLSCREEN_API)

933 m_fullScreenManager = 0;

933 m_fullScreenManager = nullptr;

#endif

    if (m_activePopupMenu) {

        m_activePopupMenu->disconnectFromPage();

938 m_activePopupMenu = 0;

938 m_activePopupMenu = nullptr;

    }

    if (m_activeOpenPanelResultListener) {

        m_activeOpenPanelResultListener->disconnectFromPage();

943 m_activeOpenPanelResultListener = 0;

943 m_activeOpenPanelResultListener = nullptr;

    }

#if ENABLE(INPUT_TYPE_COLOR)

    if (m_activeColorChooser) {

        m_activeColorChooser->disconnectFromPage();

949 m_activeColorChooser = 0;

949 m_activeColorChooser = nullptr;

    }

#endif

@@void WebPage::countStringMatches(const String& string, uint32_t options, uint32_

void WebPage::didChangeSelectedIndexForActivePopupMenu(int32_t newIndex)

{

    changeSelectedIndex(newIndex);

3273 m_activePopupMenu = 0;

3273 m_activePopupMenu = nullptr;

}

void WebPage::changeSelectedIndex(int32_t index)

@@void WebPage::didChooseFilesForOpenPanel(const Vector<String>& files)

        return;

    m_activeOpenPanelResultListener->didChooseFiles(files);

3309 m_activeOpenPanelResultListener = 0;

3309 m_activeOpenPanelResultListener = nullptr;

}

void WebPage::didCancelForOpenPanel()

{

3314 m_activeOpenPanelResultListener = 0;

3314 m_activeOpenPanelResultListener = nullptr;

}

#if ENABLE(SANDBOX_EXTENSIONS)

@@void WebPage::didSelectItemFromActiveContextMenu(const WebContextMenuItemData& i

        return;

    m_contextMenu->itemSelected(item);

3418 m_contextMenu = 0;

3418 m_contextMenu = nullptr;

}

#endif

Source/WebKit2/WebProcess/WebPage/ios/WebPageIOS.mm

@@void WebPage::syncApplyAutocorrection(const String& correction, const String& or

        while (textForRange.length() && textForRange.length() > originalText.length() && loopCount < maxPositionsAttempts) {

            position = position.next();

            if (position.isNotNull() && position >= frame.selection().selection().start())

1981 range = ~~NULL~~;

1981 range = nullptr;

            else

                range = Range::create(*frame.document(), position, frame.selection().selection().start());

            textForRange = (range) ? plainTextReplacingNoBreakSpace(range.get()) : emptyString();

@@void WebPage::elementDidBlur(WebCore::Node* node)

                send(Messages::WebPageProxy::StopAssistingNode());

            m_hasPendingBlurNotification = false;

        });

2461 m_assistedNode = 0;

2461 m_assistedNode = nullptr;

    }

}

Source/WebKit2/WebProcess/WebProcess.cpp

@@void WebProcess::networkProcessConnectionClosed(NetworkProcessConnection* connec

    ASSERT(m_networkProcessConnection);

    ASSERT_UNUSED(connection, m_networkProcessConnection == connection);

1037 m_networkProcessConnection = 0;

1037 m_networkProcessConnection = nullptr;

    
    m_webResourceLoadScheduler->networkProcessCrashed();

}

@@void WebProcess::webToDatabaseProcessConnectionClosed(WebToDatabaseProcessConnec

    ASSERT(m_webToDatabaseProcessConnection);

    ASSERT(m_webToDatabaseProcessConnection == connection);

1054 m_webToDatabaseProcessConnection = 0;

1054 m_webToDatabaseProcessConnection = nullptr;

}

WebToDatabaseProcessConnection* WebProcess::webToDatabaseProcessConnection()

Tools/ChangeLog

2015-07-02  Chris Dumez  <cdumez@apple.com>

        Drop RefPtr::clear() method

        https://bugs.webkit.org/show_bug.cgi?id=146556

        Reviewed by NOBODY (OOPS!).

        * DumpRenderTree/mac/DumpRenderTree.mm:

        (runTest):

        * DumpRenderTree/win/DumpRenderTree.cpp:

        (runTest):

        * TestWebKitAPI/Tests/WTF/RefPtr.cpp:

        (TestWebKitAPI::TEST):

2015-07-02  Daniel Bates  <dabates@apple.com>

        [iOS] Add WebKitSystemInterface for iOS 8.4

Tools/DumpRenderTree/mac/DumpRenderTree.mm

@@static void runTest(const string& inputLine)

    ASSERT(CFArrayGetCount(openWindowsRef) == 1);

    ASSERT(CFArrayGetValueAtIndex(openWindowsRef, 0) == [[mainFrame webView] window]);

2067 gTestRunner.c~~lear()~~;

2067 gTestRunner = nullptr;

    if (ignoreWebCoreNodeLeaks)

        [WebCoreStatistics stopIgnoringWebCoreNodeLeaks];

Tools/DumpRenderTree/win/DumpRenderTree.cpp

@@static void runTest(const string& inputLine)

exit:

    removeFontFallbackIfPresent(fallbackPath);

1186 ::gTestRunner.c~~lear()~~;

1186 ::gTestRunner = nullptr;

    fputs("#EOF\n", stderr);

    fflush(stderr);

Tools/TestWebKitAPI/Tests/WTF/RefPtr.cpp

#include "config.h"

#include "RefLogger.h"

29#include <wtf/CurrentTime.h>

2930#include <wtf/RefPtr.h>

31#include <wtf/RefCounted.h>

namespace TestWebKitAPI {

@@TEST(WTF_RefPtr, Basic)

    {

        RefPtr<RefLogger> ptr(&a);

        ASSERT_EQ(&a, ptr.get());

105 ptr.c~~lear()~~;

107 ptr = nullptr;

        ASSERT_EQ(nullptr, ptr.get());

    }

    ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str());