Attachment #256027 for bug #146556

View Details Raw Unified Return to Bug 146556

| Differences between

Lines 422-428 JSStringRef JSValueToStringCopy(JSContextRef ctx, JSValueRef value, JSValueRef* a/Source/JavaScriptCore/API/JSValueRef.cpp_sec1
- a/Source/JavaScriptCore/API/JSValueRef.cpp -1 / +1 lines
422		422
423	RefPtr<OpaqueJSString> stringRef(OpaqueJSString::create(jsValue.toString(exec)->value(exec)));	423	RefPtr<OpaqueJSString> stringRef(OpaqueJSString::create(jsValue.toString(exec)->value(exec)));
424	if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)	424	if (handleExceptionIfNeeded(exec, exception) == ExceptionStatus::DidThrow)
425	stringRef.clear();	425	stringRef = nullptr;
426	return stringRef.release().leakRef();	426	return stringRef.release().leakRef();
427	}	427	}
428		428

Lines 43-49 void CallLinkInfo::clearStub() a/Source/JavaScriptCore/bytecode/CallLinkInfo.cpp_sec1
- a/Source/JavaScriptCore/bytecode/CallLinkInfo.cpp -1 / +1 lines
43	return;	43	return;
44		44
45	m_stub->clearCallNodesFor(this);	45	m_stub->clearCallNodesFor(this);
46	m_stub.clear();	46	m_stub = nullptr;
47	}	47	}
48		48
49	void CallLinkInfo::unlink(RepatchBuffer& repatchBuffer)	49	void CallLinkInfo::unlink(RepatchBuffer& repatchBuffer)



    {
        deref();
        accessType = access_unset;
        stubRoutine = nullptr;
        watchpoints = nullptr;
    }

    void deref();

Lines 443-449 public: a/Source/JavaScriptCore/dfg/DFGGraph.h_sec1
- a/Source/JavaScriptCore/dfg/DFGGraph.h -1 / +1 lines
443		443
444	void killBlock(BlockIndex blockIndex)	444	void killBlock(BlockIndex blockIndex)
445	{	445	{
446	m_blocks[blockIndex].clear();	446	m_blocks[blockIndex] = nullptr;
447	}	447	}
448		448
449	void killBlock(BasicBlock* basicBlock)	449	void killBlock(BasicBlock* basicBlock)

Lines 1447-1453 char* JIT_OPERATION triggerOSREntryNow( a/Source/JavaScriptCore/dfg/DFGOperations.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGOperations.cpp -1 / +1 lines
1447		1447
1448	// OSR entry failed. Oh no! This implies that we need to retry. We retry	1448	// OSR entry failed. Oh no! This implies that we need to retry. We retry
1449	// without exponential backoff and we only do this for the entry code block.	1449	// without exponential backoff and we only do this for the entry code block.
1450	jitCode->osrEntryBlock.clear();	1450	jitCode->osrEntryBlock = nullptr;
1451	jitCode->osrEntryRetry = 0;	1451	jitCode->osrEntryRetry = 0;
1452	return 0;	1452	return 0;
1453	}	1453	}

Lines 273-279 void ConsoleMessage::clear() a/Source/JavaScriptCore/inspector/ConsoleMessage.cpp_sec1
- a/Source/JavaScriptCore/inspector/ConsoleMessage.cpp -1 / +1 lines
273	m_message = ASCIILiteral("<message collected>");	273	m_message = ASCIILiteral("<message collected>");
274		274
275	if (m_arguments)	275	if (m_arguments)
276	m_arguments.clear();	276	m_arguments = nullptr;
277	}	277	}
278		278
279	JSC::ExecState* ConsoleMessage::scriptState() const	279	JSC::ExecState* ConsoleMessage::scriptState() const

Lines 131-137 void JSGlobalObjectInspectorController::disconnectFrontend(DisconnectReason reas a/Source/JavaScriptCore/inspector/JSGlobalObjectInspectorController.cpp_sec1
- a/Source/JavaScriptCore/inspector/JSGlobalObjectInspectorController.cpp -1 / +1 lines
131	m_agents.willDestroyFrontendAndBackend(reason);	131	m_agents.willDestroyFrontendAndBackend(reason);
132		132
133	m_backendDispatcher->clearFrontend();	133	m_backendDispatcher->clearFrontend();
134	m_backendDispatcher.clear();	134	m_backendDispatcher = nullptr;
135	m_frontendChannel = nullptr;	135	m_frontendChannel = nullptr;
136		136
137	m_isAutomaticInspection = false;	137	m_isAutomaticInspection = false;

Lines 57-63 void InspectorAgent::didCreateFrontendAndBackend(FrontendChannel* frontendChanne a/Source/JavaScriptCore/inspector/agents/InspectorAgent.cpp_sec1
- a/Source/JavaScriptCore/inspector/agents/InspectorAgent.cpp -1 / +1 lines
57	void InspectorAgent::willDestroyFrontendAndBackend(DisconnectReason)	57	void InspectorAgent::willDestroyFrontendAndBackend(DisconnectReason)
58	{	58	{
59	m_frontendDispatcher = nullptr;	59	m_frontendDispatcher = nullptr;
60	m_backendDispatcher.clear();	60	m_backendDispatcher = nullptr;
61		61
62	m_pendingEvaluateTestCommands.clear();	62	m_pendingEvaluateTestCommands.clear();
63		63

Lines 64-70 void InspectorConsoleAgent::didCreateFrontendAndBackend(FrontendChannel* fronten a/Source/JavaScriptCore/inspector/agents/InspectorConsoleAgent.cpp_sec1
- a/Source/JavaScriptCore/inspector/agents/InspectorConsoleAgent.cpp -1 / +1 lines
64	void InspectorConsoleAgent::willDestroyFrontendAndBackend(DisconnectReason)	64	void InspectorConsoleAgent::willDestroyFrontendAndBackend(DisconnectReason)
65	{	65	{
66	m_frontendDispatcher = nullptr;	66	m_frontendDispatcher = nullptr;
67	m_backendDispatcher.clear();	67	m_backendDispatcher = nullptr;
68		68
69	String errorString;	69	String errorString;
70	disable(errorString);	70	disable(errorString);

Lines 77-83 void InspectorDebuggerAgent::didCreateFrontendAndBackend(FrontendChannel* fronte a/Source/JavaScriptCore/inspector/agents/InspectorDebuggerAgent.cpp_sec1
- a/Source/JavaScriptCore/inspector/agents/InspectorDebuggerAgent.cpp -1 / +1 lines
77	void InspectorDebuggerAgent::willDestroyFrontendAndBackend(DisconnectReason reason)	77	void InspectorDebuggerAgent::willDestroyFrontendAndBackend(DisconnectReason reason)
78	{	78	{
79	m_frontendDispatcher = nullptr;	79	m_frontendDispatcher = nullptr;
80	m_backendDispatcher.clear();	80	m_backendDispatcher = nullptr;
81		81
82	bool skipRecompile = reason == DisconnectReason::InspectedTargetDestroyed;	82	bool skipRecompile = reason == DisconnectReason::InspectedTargetDestroyed;
83	disable(skipRecompile);	83	disable(skipRecompile);

Lines 49-55 void JSGlobalObjectRuntimeAgent::didCreateFrontendAndBackend(FrontendChannel* fr a/Source/JavaScriptCore/inspector/agents/JSGlobalObjectRuntimeAgent.cpp_sec1
- a/Source/JavaScriptCore/inspector/agents/JSGlobalObjectRuntimeAgent.cpp -1 / +1 lines
49	void JSGlobalObjectRuntimeAgent::willDestroyFrontendAndBackend(DisconnectReason reason)	49	void JSGlobalObjectRuntimeAgent::willDestroyFrontendAndBackend(DisconnectReason reason)
50	{	50	{
51	m_frontendDispatcher = nullptr;	51	m_frontendDispatcher = nullptr;
52	m_backendDispatcher.clear();	52	m_backendDispatcher = nullptr;
53		53
54	InspectorRuntimeAgent::willDestroyFrontendAndBackend(reason);	54	InspectorRuntimeAgent::willDestroyFrontendAndBackend(reason);
55	}	55	}



void ExecutableBase::clearCode()
{
#if ENABLE(JIT)
    m_jitCodeForCall = nullptr;
    m_jitCodeForConstruct = nullptr;
    m_jitCodeForCallWithArityCheck = MacroAssemblerCodePtr();
    m_jitCodeForConstructWithArityCheck = MacroAssemblerCodePtr();
    m_jitCodeForCallWithArityCheckAndPreserveRegs = MacroAssemblerCodePtr();


void EvalExecutable::clearCode()
{
    m_evalCodeBlock = nullptr;
    m_unlinkedEvalCodeBlock.clear();
    Base::clearCode();
}


void ProgramExecutable::clearCode()
{
    m_programCodeBlock = nullptr;
    m_unlinkedProgramCodeBlock.clear();
    Base::clearCode();
}


void FunctionExecutable::clearCode()
{
    m_codeBlockForCall = nullptr;
    m_codeBlockForConstruct = nullptr;
    Base::clearCode();
}


Lines 73-79 void JSLockHolder::init() a/Source/JavaScriptCore/runtime/JSLock.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSLock.cpp -1 / +1 lines
73	JSLockHolder::~JSLockHolder()	73	JSLockHolder::~JSLockHolder()
74	{	74	{
75	RefPtr<JSLock> apiLock(&m_vm->apiLock());	75	RefPtr<JSLock> apiLock(&m_vm->apiLock());
76	m_vm.clear();	76	m_vm = nullptr;
77	apiLock->unlock();	77	apiLock->unlock();
78	}	78	}
79		79

Lines 737-743 void Structure::pin() a/Source/JavaScriptCore/runtime/Structure.cpp_sec1
- a/Source/JavaScriptCore/runtime/Structure.cpp -1 / +1 lines
737	ASSERT(propertyTable());	737	ASSERT(propertyTable());
738	setIsPinnedPropertyTable(true);	738	setIsPinnedPropertyTable(true);
739	clearPreviousID();	739	clearPreviousID();
740	m_nameInPrevious.clear();	740	m_nameInPrevious = nullptr;
741	}	741	}
742		742
743	void Structure::allocateRareData(VM& vm)	743	void Structure::allocateRareData(VM& vm)




    T* get() const { return m_ptr; }
    
    void clear();
    PassRefPtr<T> release() { PassRefPtr<T> tmp = adoptRef(m_ptr); m_ptr = nullptr; return tmp; }
    Ref<T> releaseNonNull() { ASSERT(m_ptr); Ref<T> tmp(adoptRef(*m_ptr)); m_ptr = nullptr; return tmp; }


{
}

template<typename T> inline void RefPtr<T>::clear()
{
    derefIfNotNull(std::exchange(m_ptr, nullptr));
}

template<typename T>
inline T* RefPtr<T>::leakRef()
{

Lines 259-265 void IDBCursor::close() a/Source/WebCore/Modules/indexeddb/IDBCursor.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/IDBCursor.cpp -1 / +1 lines
259	m_transactionNotifier.cursorFinished();	259	m_transactionNotifier.cursorFinished();
260	if (m_request) {	260	if (m_request) {
261	m_request->finishCursor();	261	m_request->finishCursor();
262	m_request.clear();	262	m_request = nullptr;
263	}	263	}
264	}	264	}
265		265

Lines 333-339 void IDBDatabaseBackend::transactionFinished(IDBTransactionBackend* rawTransacti a/Source/WebCore/Modules/indexeddb/IDBDatabaseBackend.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/IDBDatabaseBackend.cpp -1 / +1 lines
333	m_transactions.remove(transaction->id());	333	m_transactions.remove(transaction->id());
334	if (transaction->mode() == IndexedDB::TransactionMode::VersionChange) {	334	if (transaction->mode() == IndexedDB::TransactionMode::VersionChange) {
335	ASSERT(transaction.get() == m_runningVersionChangeTransaction.get());	335	ASSERT(transaction.get() == m_runningVersionChangeTransaction.get());
336	m_runningVersionChangeTransaction.clear();	336	m_runningVersionChangeTransaction = nullptr;
337	}	337	}
338	}	338	}
339		339

Lines 337-343 private: a/Source/WebCore/Modules/indexeddb/IDBObjectStore.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/IDBObjectStore.cpp -1 / +1 lines
337	// Now that we are done indexing, tell the backend to go	337	// Now that we are done indexing, tell the backend to go
338	// back to processing tasks of type NormalTask.	338	// back to processing tasks of type NormalTask.
339	m_databaseBackend->setIndexesReady(m_transactionId, m_objectStoreId, indexIds);	339	m_databaseBackend->setIndexesReady(m_transactionId, m_objectStoreId, indexIds);
340	m_databaseBackend.clear();	340	m_databaseBackend = nullptr;
341	}	341	}
342		342
343	}	343	}

Lines 142-148 bool IDBOpenDBRequest::dispatchEvent(PassRefPtr<Event> event) a/Source/WebCore/Modules/indexeddb/IDBOpenDBRequest.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/IDBOpenDBRequest.cpp -1 / +1 lines
142	// If the connection closed between onUpgradeNeeded and the delivery of the "success" event,	142	// If the connection closed between onUpgradeNeeded and the delivery of the "success" event,
143	// an "error" event should be fired instead.	143	// an "error" event should be fired instead.
144	if (event->type() == eventNames().successEvent && m_result->type() == IDBAny::IDBDatabaseType && m_result->idbDatabase()->isClosePending()) {	144	if (event->type() == eventNames().successEvent && m_result->type() == IDBAny::IDBDatabaseType && m_result->idbDatabase()->isClosePending()) {
145	m_result.clear();	145	m_result = nullptr;
146	onError(IDBDatabaseError::create(IDBDatabaseException::AbortError, "The connection was closed."));	146	onError(IDBDatabaseError::create(IDBDatabaseException::AbortError, "The connection was closed."));
147	return false;	147	return false;
148	}	148	}



    m_enqueuedEvents.clear();

    m_errorCode = 0;
    m_error = nullptr;
    m_errorMessage = String();
    m_result = nullptr;
    onError(IDBDatabaseError::create(IDBDatabaseException::AbortError));
    m_requestAborted = true;
}

    ASSERT(cursor == getResultCursor());

    m_pendingCursor = cursor;
    m_result = nullptr;
    m_readyState = PENDING;
    m_errorCode = 0;
    m_error = nullptr;
    m_errorMessage = String();
    m_transaction->registerRequest(this);
}

    m_errorCode = error->code();
    m_errorMessage = error->message();
    m_error = DOMError::create(IDBDatabaseException::getErrorName(error->idbCode()));
    m_pendingCursor = nullptr;
    enqueueEvent(Event::create(eventNames().errorEvent, true, true));
}


    m_result = IDBAny::create(value);
    if (m_pendingCursor) {
        m_pendingCursor->close();
        m_pendingCursor = nullptr;
    }
    enqueueEvent(createSuccessEvent());
}

    ASSERT(m_transaction->isVersionChange());
    ASSERT(m_readyState == DONE);
    ASSERT(scriptExecutionContext());
    m_transaction = nullptr;
    m_readyState = PENDING;
}


Lines 240-246 void IDBTransaction::OpenCursorNotifier::cursorFinished() a/Source/WebCore/Modules/indexeddb/IDBTransaction.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/IDBTransaction.cpp -1 / +1 lines
240	if (m_cursor) {	240	if (m_cursor) {
241	m_transaction->unregisterOpenCursor(m_cursor);	241	m_transaction->unregisterOpenCursor(m_cursor);
242	m_cursor = nullptr;	242	m_cursor = nullptr;
243	m_transaction.clear();	243	m_transaction = nullptr;
244	}	244	}
245	}	245	}
246		246



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

    if (state == closedKeyword()) {
        m_private = nullptr;
        m_mediaElement = nullptr;
        m_duration = MediaTime::invalidTime();
    }

    m_asyncEventQueue.close();
    if (!isClosed())
        setReadyState(closedKeyword());
    m_private = nullptr;
}

bool MediaSource::canSuspendForPageCache() const




void RTCSessionDescriptionRequestImpl::clear()
{
    m_successCallback = nullptr;
    m_errorCallback = nullptr;
}

} // namespace WebCore

Lines 104-110 bool RTCStatsRequestImpl::canSuspendForPageCache() const a/Source/WebCore/Modules/mediastream/RTCStatsRequestImpl.cpp_sec1
- a/Source/WebCore/Modules/mediastream/RTCStatsRequestImpl.cpp -1 / +1 lines
104		104
105	void RTCStatsRequestImpl::clear()	105	void RTCStatsRequestImpl::clear()
106	{	106	{
107	m_successCallback.clear();	107	m_successCallback = nullptr;
108	}	108	}
109		109
110		110




void RTCVoidRequestImpl::clear()
{
    m_successCallback = nullptr;
    m_errorCallback = nullptr;
}

} // namespace WebCore

Lines 231-237 void AudioContext::clear() a/Source/WebCore/Modules/webaudio/AudioContext.cpp_sec1
- a/Source/WebCore/Modules/webaudio/AudioContext.cpp -1 / +1 lines
231	{	231	{
232	// 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.	232	// 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.
233	if (m_destinationNode)	233	if (m_destinationNode)
234	m_destinationNode.clear();	234	m_destinationNode = nullptr;
235		235
236	// Audio thread is dead. Nobody will schedule node deletion action. Let's do it ourselves.	236	// Audio thread is dead. Nobody will schedule node deletion action. Let's do it ourselves.
237	do {	237	do {

Lines 845-851 void SQLTransactionBackend::releaseOriginLockIfNeeded() a/Source/WebCore/Modules/webdatabase/SQLTransactionBackend.cpp_sec1
- a/Source/WebCore/Modules/webdatabase/SQLTransactionBackend.cpp -1 / +1 lines
845	{	845	{
846	if (m_originLock) {	846	if (m_originLock) {
847	m_originLock->unlock();	847	m_originLock->unlock();
848	m_originLock.clear();	848	m_originLock = nullptr;
849	}	849	}
850	}	850	}
851		851

Lines 126-132 void WorkerThreadableWebSocketChannel::fail(const String& reason) a/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.cpp_sec1
- a/Source/WebCore/Modules/websockets/WorkerThreadableWebSocketChannel.cpp -1 / +1 lines
126	void WorkerThreadableWebSocketChannel::disconnect()	126	void WorkerThreadableWebSocketChannel::disconnect()
127	{	127	{
128	m_bridge->disconnect();	128	m_bridge->disconnect();
129	m_bridge.clear();	129	m_bridge = nullptr;
130	}	130	}
131		131
132	void WorkerThreadableWebSocketChannel::suspend()	132	void WorkerThreadableWebSocketChannel::suspend()

Lines 44-50 public: a/Source/WebCore/bindings/js/WebCoreJSClientData.h_sec1
- a/Source/WebCore/bindings/js/WebCoreJSClientData.h -1 / +1 lines
44	ASSERT(m_worldSet.contains(m_normalWorld.get()));	44	ASSERT(m_worldSet.contains(m_normalWorld.get()));
45	ASSERT(m_worldSet.size() == 1);	45	ASSERT(m_worldSet.size() == 1);
46	ASSERT(m_normalWorld->hasOneRef());	46	ASSERT(m_normalWorld->hasOneRef());
47	m_normalWorld.clear();	47	m_normalWorld = nullptr;
48	ASSERT(m_worldSet.isEmpty());	48	ASSERT(m_worldSet.isEmpty());
49	}	49	}
50		50

Lines 62-68 WorkerScriptController::~WorkerScriptController() a/Source/WebCore/bindings/js/WorkerScriptController.cpp_sec1
- a/Source/WebCore/bindings/js/WorkerScriptController.cpp -1 / +1 lines
62	{	62	{
63	JSLockHolder lock(vm());	63	JSLockHolder lock(vm());
64	m_workerGlobalScopeWrapper.clear();	64	m_workerGlobalScopeWrapper.clear();
65	m_vm.clear();	65	m_vm = nullptr;
66	}	66	}
67		67
68	void WorkerScriptController::initScript()	68	void WorkerScriptController::initScript()

Lines 277-283 std::error_code parseRuleList(const String& rules, Vector<ContentExtensionRule>& a/Source/WebCore/contentextensions/ContentExtensionParser.cpp_sec1
- a/Source/WebCore/contentextensions/ContentExtensionParser.cpp -1 / +1 lines
277	ExecState* exec = globalObject->globalExec();	277	ExecState* exec = globalObject->globalExec();
278	auto error = loadEncodedRules(*exec, rules, ruleList);	278	auto error = loadEncodedRules(*exec, rules, ruleList);
279		279
280	vm.clear();	280	vm = nullptr;
281		281
282	if (error)	282	if (error)
283	return error;	283	return error;



    if (value2)
        valueList.next();
    else {
        value1 = nullptr;
        return;
    }

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

    value1 = nullptr;
    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)

            valueList.next();
        else {
            if (!inShorthand()) {
                value1 = nullptr;
                return;
            }
        }

        return nullptr;

    ASSERT(!m_currentRuleDataStack->isEmpty());
    m_currentRuleData = nullptr;
    RefPtr<CSSRuleSourceData> data = m_currentRuleDataStack->last();
    m_currentRuleDataStack->removeLast();
    return data.release();

{
    if (!isExtractingSourceData())
        return;
    m_currentRuleData = nullptr;
    unsigned offset = tokenStartOffset();
    if (tokenStartChar() == '{')
        ++offset; // Skip the rule body opening brace.



    if (!m_parser)
        return;
    m_parser->detach();
    m_parser = nullptr;
}

void Document::cancelParsing()

    // FIXME: consider using ActiveDOMObject.
    if (m_scriptedAnimationController)
        m_scriptedAnimationController->clearDocumentPointer();
    m_scriptedAnimationController = nullptr;
}
#endif
    

            curr->setActive(false);
            m_userActionElements.setInActiveChain(curr, false);
        }
        m_activeElement = nullptr;
    } else {
        Element* newActiveElement = innerElementInDocument;
        if (!oldActiveElement && newActiveElement && request.active() && !request.touchMove()) {

Lines 131-137 public: a/Source/WebCore/dom/DocumentMarker.h_sec1
- a/Source/WebCore/dom/DocumentMarker.h -1 / +1 lines
131	DocumentMarkerDetails* details() const;	131	DocumentMarkerDetails* details() const;
132		132
133	void setActiveMatch(bool);	133	void setActiveMatch(bool);
134	void clearDetails() { m_details.clear(); }	134	void clearDetails() { m_details = nullptr; }
135		135
136	// Offset modifications are done by DocumentMarkerController.	136	// Offset modifications are done by DocumentMarkerController.
137	// Other classes should not call following setters.	137	// Other classes should not call following setters.

Lines 3207-3213 void Element::cloneAttributesFromElement(const Element& other) a/Source/WebCore/dom/Element.cpp_sec1
- a/Source/WebCore/dom/Element.cpp -1 / +1 lines
3207		3207
3208	other.synchronizeAllAttributes();	3208	other.synchronizeAllAttributes();
3209	if (!other.m_elementData) {	3209	if (!other.m_elementData) {
3210	m_elementData.clear();	3210	m_elementData = nullptr;
3211	return;	3211	return;
3212	}	3212	}
3213		3213




void NodeIterator::NodePointer::clear()
{
    node = nullptr;
}

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

{
    root()->document().detachNodeIterator(this);
    m_detached = true;
    m_referenceNode.node = nullptr;
}

void NodeIterator::nodeWillBeRemoved(Node& removedNode)

Lines 92-98 public: a/Source/WebCore/dom/Position.h_sec1
- a/Source/WebCore/dom/Position.h -1 / +1 lines
92		92
93	AnchorType anchorType() const { return static_cast<AnchorType>(m_anchorType); }	93	AnchorType anchorType() const { return static_cast<AnchorType>(m_anchorType); }
94		94
95	void clear() { m_anchorNode.clear(); m_offset = 0; m_anchorType = PositionIsOffsetInAnchor; m_isLegacyEditingPosition = false; }	95	void clear() { m_anchorNode = nullptr; m_offset = 0; m_anchorType = PositionIsOffsetInAnchor; m_isLegacyEditingPosition = false; }
96		96
97	// These are always DOM compliant values. Editing positions like [img, 0] (aka [img, before])	97	// These are always DOM compliant values. Editing positions like [img, 0] (aka [img, before])
98	// will return img->parentNode() and img->computeNodeIndex() from these functions.	98	// will return img->parentNode() and img->computeNodeIndex() from these functions.




inline void RangeBoundaryPoint::clear()
{
    m_containerNode = nullptr;
    m_offsetInContainer = 0;
    m_childBeforeBoundary = nullptr;
}

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

Lines 105-111 public: a/Source/WebCore/dom/SpaceSplitString.h_sec1
- a/Source/WebCore/dom/SpaceSplitString.h -1 / +1 lines
105	bool operator!=(const SpaceSplitString& other) const { return m_data != other.m_data; }	105	bool operator!=(const SpaceSplitString& other) const { return m_data != other.m_data; }
106		106
107	void set(const AtomicString&, bool shouldFoldCase);	107	void set(const AtomicString&, bool shouldFoldCase);
108	void clear() { m_data.clear(); }	108	void clear() { m_data = nullptr; }
109		109
110	bool contains(const AtomicString& string) const { return m_data && m_data->contains(string); }	110	bool contains(const AtomicString& string) const { return m_data && m_data->contains(string); }
111	bool containsAll(const SpaceSplitString& names) const { return !names.m_data \|\| (m_data && m_data->containsAll(*names.m_data)); }	111	bool containsAll(const SpaceSplitString& names) const { return !names.m_data \|\| (m_data && m_data->containsAll(*names.m_data)); }



    // 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))
        inlineStyle = nullptr;

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

    if (newStyleString.isNull()) {
        if (PropertySetCSSStyleDeclaration* cssomWrapper = inlineStyleCSSOMWrapper())
            cssomWrapper->clearParentElement();
        ensureUniqueElementData().m_inlineStyle = nullptr;
    } else if (reason == ModifiedByCloning || document().contentSecurityPolicy()->allowInlineStyle(document().url(), startLineNumber))
        setInlineStyleFromString(newStyleString);





    // If type is PanelTypeReversion, then the new range has been set. So we shouldn't clear it.
    if (type == AlternativeTextTypeCorrection)
        m_alternativeTextInfo.rangeWithAlternative = nullptr;
    m_alternativeTextInfo.type = type;
    m_timer.startOneShot(correctionPanelTimerInterval);
}

void AlternativeTextController::stopAlternativeTextUITimer()
{
    m_timer.stop();
    m_alternativeTextInfo.rangeWithAlternative = nullptr;
}

void AlternativeTextController::stopPendingCorrection(const VisibleSelection& oldSelection)

    if (doApplyCorrection)
        handleAlternativeTextUIResult(dismissSoon(ReasonForDismissingAlternativeTextAccepted)); 
    else
        m_alternativeTextInfo.rangeWithAlternative = nullptr;
}

bool AlternativeTextController::hasPendingCorrection() const

        Vector<String> suggestions;
        textChecker()->getGuessesForWord(m_alternativeTextInfo.originalText, paragraphText, suggestions);
        if (suggestions.isEmpty()) {
            m_alternativeTextInfo.rangeWithAlternative = nullptr;
            break;
        }
        String topSuggestion = suggestions.first();

        break;
    }

    m_alternativeTextInfo.rangeWithAlternative = nullptr;
}

bool AlternativeTextController::isAutomaticSpellingCorrectionEnabled()

Lines 638-644 void EditingStyle::overrideTypingStyleAt(const EditingStyle& style, const Positi a/Source/WebCore/editing/EditingStyle.cpp_sec1
- a/Source/WebCore/editing/EditingStyle.cpp -1 / +1 lines
638		638
639	void EditingStyle::clear()	639	void EditingStyle::clear()
640	{	640	{
641	m_mutableStyle.clear();	641	m_mutableStyle = nullptr;
642	m_shouldUseFixedDefaultFontSize = false;	642	m_shouldUseFixedDefaultFontSize = false;
643	m_fontSizeDelta = NoFontDelta;	643	m_fontSizeDelta = NoFontDelta;
644	setUnderlineChange(TextDecorationChange::None);	644	setUnderlineChange(TextDecorationChange::None);

Lines 828-834 void Editor::removeFormattingAndStyle() a/Source/WebCore/editing/Editor.cpp_sec1
- a/Source/WebCore/editing/Editor.cpp -1 / +1 lines
828		828
829	void Editor::clearLastEditCommand()	829	void Editor::clearLastEditCommand()
830	{	830	{
831	m_lastEditCommand.clear();	831	m_lastEditCommand = nullptr;
832	}	832	}
833	#if PLATFORM(IOS)	833	#if PLATFORM(IOS)
834	// If the selection is adjusted from UIKit without closing the typing, the typing command may	834	// If the selection is adjusted from UIKit without closing the typing, the typing command may

Lines 1359-1365 void FrameSelection::prepareForDestruction() a/Source/WebCore/editing/FrameSelection.cpp_sec1
- a/Source/WebCore/editing/FrameSelection.cpp -1 / +1 lines
1359	view->clearSelection();	1359	view->clearSelection();
1360		1360
1361	setSelectionWithoutUpdatingAppearance(VisibleSelection(), defaultSetSelectionOptions(), AlignCursorOnScrollIfNeeded, CharacterGranularity);	1361	setSelectionWithoutUpdatingAppearance(VisibleSelection(), defaultSetSelectionOptions(), AlignCursorOnScrollIfNeeded, CharacterGranularity);
1362	m_previousCaretNode.clear();	1362	m_previousCaretNode = nullptr;
1363	}	1363	}
1364		1364
1365	void FrameSelection::setStart(const VisiblePosition &pos, EUserTriggered trigger)	1365	void FrameSelection::setStart(const VisiblePosition &pos, EUserTriggered trigger)

Lines 359-365 inline EditingStyle* FrameSelection::typingStyle() const a/Source/WebCore/editing/FrameSelection.h_sec1
- a/Source/WebCore/editing/FrameSelection.h -1 / +1 lines
359		359
360	inline void FrameSelection::clearTypingStyle()	360	inline void FrameSelection::clearTypingStyle()
361	{	361	{
362	m_typingStyle.clear();	362	m_typingStyle = nullptr;
363	}	363	}
364		364
365	inline void FrameSelection::setTypingStyle(PassRefPtr<EditingStyle> style)	365	inline void FrameSelection::setTypingStyle(PassRefPtr<EditingStyle> style)

Lines 214-220 void SpellChecker::didCheck(int sequence, const Vector<TextCheckingResult>& resu a/Source/WebCore/editing/SpellChecker.cpp_sec1
- a/Source/WebCore/editing/SpellChecker.cpp -1 / +1 lines
214	if (m_lastProcessedSequence < sequence)	214	if (m_lastProcessedSequence < sequence)
215	m_lastProcessedSequence = sequence;	215	m_lastProcessedSequence = sequence;
216		216
217	m_processingRequest.clear();	217	m_processingRequest = nullptr;
218	if (!m_requestQueue.isEmpty())	218	if (!m_requestQueue.isEmpty())
219	m_timerToProcessQueuedRequest.startOneShot(0);	219	m_timerToProcessQueuedRequest.startOneShot(0);
220	}	220	}

Lines 98-104 void BaseChooserOnlyDateAndTimeInputType::didChooseValue(const String& value) a/Source/WebCore/html/BaseChooserOnlyDateAndTimeInputType.cpp_sec1
- a/Source/WebCore/html/BaseChooserOnlyDateAndTimeInputType.cpp -1 / +1 lines
98		98
99	void BaseChooserOnlyDateAndTimeInputType::didEndChooser()	99	void BaseChooserOnlyDateAndTimeInputType::didEndChooser()
100	{	100	{
101	m_dateTimeChooser.clear();	101	m_dateTimeChooser = nullptr;
102	}	102	}
103		103
104	void BaseChooserOnlyDateAndTimeInputType::closeDateTimeChooser()	104	void BaseChooserOnlyDateAndTimeInputType::closeDateTimeChooser()

Lines 250-256 void FileInputType::setValue(const String&, bool, TextFieldEventBehavior) a/Source/WebCore/html/FileInputType.cpp_sec1
- a/Source/WebCore/html/FileInputType.cpp -1 / +1 lines
250	{	250	{
251	// FIXME: Should we clear the file list, or replace it with a new empty one here? This is observable from JavaScript through custom properties.	251	// FIXME: Should we clear the file list, or replace it with a new empty one here? This is observable from JavaScript through custom properties.
252	m_fileList->clear();	252	m_fileList->clear();
253	m_icon.clear();	253	m_icon = nullptr;
254	element().setNeedsStyleRecalc();	254	element().setNeedsStyleRecalc();
255	}	255	}
256		256




void HTMLCanvasElement::clearPresentationCopy()
{
    m_presentedImage = nullptr;
}

void HTMLCanvasElement::setSurfaceSize(const IntSize& size)


void HTMLCanvasElement::clearCopiedImage()
{
    m_copiedImage = nullptr;
    m_didClearImageBuffer = false;
}





void HTMLPlugInElement::willDetachRenderers()
{
    m_instance = nullptr;

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


void HTMLPlugInElement::resetInstance()
{
    m_instance = nullptr;
}

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

Lines 462-468 void TextFieldInputType::updatePlaceholderText() a/Source/WebCore/html/TextFieldInputType.cpp_sec1
- a/Source/WebCore/html/TextFieldInputType.cpp -1 / +1 lines
462	if (placeholderText.isEmpty()) {	462	if (placeholderText.isEmpty()) {
463	if (m_placeholder) {	463	if (m_placeholder) {
464	m_placeholder->parentNode()->removeChild(m_placeholder.get(), ASSERT_NO_EXCEPTION);	464	m_placeholder->parentNode()->removeChild(m_placeholder.get(), ASSERT_NO_EXCEPTION);
465	m_placeholder.clear();	465	m_placeholder = nullptr;
466	}	466	}
467	return;	467	return;
468	}	468	}

Lines 623-629 void WebGLRenderingContextBase::destroyGraphicsContext3D() a/Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp_sec1
- a/Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp -1 / +1 lines
623	if (m_context) {	623	if (m_context) {
624	m_context->setContextLostCallback(nullptr);	624	m_context->setContextLostCallback(nullptr);
625	m_context->setErrorMessageCallback(nullptr);	625	m_context->setErrorMessageCallback(nullptr);
626	m_context.clear();	626	m_context = nullptr;
627	}	627	}
628	}	628	}
629		629

Lines 58-64 void InspectorApplicationCacheAgent::didCreateFrontendAndBackend(FrontendChannel a/Source/WebCore/inspector/InspectorApplicationCacheAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorApplicationCacheAgent.cpp -1 / +1 lines
58	void InspectorApplicationCacheAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)	58	void InspectorApplicationCacheAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)
59	{	59	{
60	m_frontendDispatcher = nullptr;	60	m_frontendDispatcher = nullptr;
61	m_backendDispatcher.clear();	61	m_backendDispatcher = nullptr;
62		62
63	m_instrumentingAgents->setInspectorApplicationCacheAgent(nullptr);	63	m_instrumentingAgents->setInspectorApplicationCacheAgent(nullptr);
64	}	64	}

Lines 360-366 void InspectorCSSAgent::didCreateFrontendAndBackend(Inspector::FrontendChannel* a/Source/WebCore/inspector/InspectorCSSAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorCSSAgent.cpp -1 / +1 lines
360	void InspectorCSSAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)	360	void InspectorCSSAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)
361	{	361	{
362	m_frontendDispatcher = nullptr;	362	m_frontendDispatcher = nullptr;
363	m_backendDispatcher.clear();	363	m_backendDispatcher = nullptr;
364		364
365	resetNonPersistentData();	365	resetNonPersistentData();
366	}	366	}

Lines 263-269 void InspectorController::disconnectFrontend(DisconnectReason reason) a/Source/WebCore/inspector/InspectorController.cpp_sec1
- a/Source/WebCore/inspector/InspectorController.cpp -1 / +1 lines
263	m_agents.willDestroyFrontendAndBackend(reason);	263	m_agents.willDestroyFrontendAndBackend(reason);
264		264
265	m_backendDispatcher->clearFrontend();	265	m_backendDispatcher->clearFrontend();
266	m_backendDispatcher.clear();	266	m_backendDispatcher = nullptr;
267	m_frontendChannel = nullptr;	267	m_frontendChannel = nullptr;
268		268
269	m_isAutomaticInspection = false;	269	m_isAutomaticInspection = false;

Lines 238-244 void InspectorDOMAgent::didCreateFrontendAndBackend(Inspector::FrontendChannel* a/Source/WebCore/inspector/InspectorDOMAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorDOMAgent.cpp -1 / +1 lines
238	void InspectorDOMAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)	238	void InspectorDOMAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)
239	{	239	{
240	m_frontendDispatcher = nullptr;	240	m_frontendDispatcher = nullptr;
241	m_backendDispatcher.clear();	241	m_backendDispatcher = nullptr;
242		242
243	m_history.reset();	243	m_history.reset();
244	m_domEditor.reset();	244	m_domEditor.reset();

Lines 109-115 void InspectorDOMDebuggerAgent::didCreateFrontendAndBackend(Inspector::FrontendC a/Source/WebCore/inspector/InspectorDOMDebuggerAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorDOMDebuggerAgent.cpp -1 / +1 lines
109		109
110	void InspectorDOMDebuggerAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)	110	void InspectorDOMDebuggerAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)
111	{	111	{
112	m_backendDispatcher.clear();	112	m_backendDispatcher = nullptr;
113		113
114	disable();	114	disable();
115	}	115	}

Lines 76-82 void InspectorDOMStorageAgent::didCreateFrontendAndBackend(Inspector::FrontendCh a/Source/WebCore/inspector/InspectorDOMStorageAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorDOMStorageAgent.cpp -1 / +1 lines
76	void InspectorDOMStorageAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)	76	void InspectorDOMStorageAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)
77	{	77	{
78	m_frontendDispatcher = nullptr;	78	m_frontendDispatcher = nullptr;
79	m_backendDispatcher.clear();	79	m_backendDispatcher = nullptr;
80		80
81	ErrorString unused;	81	ErrorString unused;
82	disable(unused);	82	disable(unused);

Lines 231-237 void InspectorDatabaseAgent::didCreateFrontendAndBackend(Inspector::FrontendChan a/Source/WebCore/inspector/InspectorDatabaseAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorDatabaseAgent.cpp -1 / +1 lines
231	void InspectorDatabaseAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)	231	void InspectorDatabaseAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)
232	{	232	{
233	m_frontendDispatcher = nullptr;	233	m_frontendDispatcher = nullptr;
234	m_backendDispatcher.clear();	234	m_backendDispatcher = nullptr;
235		235
236	ErrorString unused;	236	ErrorString unused;
237	disable(unused);	237	disable(unused);

Lines 582-588 void InspectorIndexedDBAgent::didCreateFrontendAndBackend(Inspector::FrontendCha a/Source/WebCore/inspector/InspectorIndexedDBAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorIndexedDBAgent.cpp -1 / +1 lines
582		582
583	void InspectorIndexedDBAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)	583	void InspectorIndexedDBAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)
584	{	584	{
585	m_backendDispatcher.clear();	585	m_backendDispatcher = nullptr;
586		586
587	ErrorString unused;	587	ErrorString unused;
588	disable(unused);	588	disable(unused);

Lines 65-71 void InspectorLayerTreeAgent::didCreateFrontendAndBackend(Inspector::FrontendCha a/Source/WebCore/inspector/InspectorLayerTreeAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorLayerTreeAgent.cpp -1 / +1 lines
65	void InspectorLayerTreeAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)	65	void InspectorLayerTreeAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)
66	{	66	{
67	m_frontendDispatcher = nullptr;	67	m_frontendDispatcher = nullptr;
68	m_backendDispatcher.clear();	68	m_backendDispatcher = nullptr;
69		69
70	ErrorString unused;	70	ErrorString unused;
71	disable(unused);	71	disable(unused);




void InspectorOverlay::hideHighlight()
{
    m_highlightNode = nullptr;
    m_highlightNodeList = nullptr;
    m_highlightQuad = nullptr;
    update();
}


{
    m_nodeHighlightConfig = highlightConfig;
    m_highlightNodeList = nodes;
    m_highlightNode = nullptr;
    update();
}


{
    m_nodeHighlightConfig = highlightConfig;
    m_highlightNode = node;
    m_highlightNodeList = nullptr;
    update();
}




void InspectorPageAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)
{
    m_frontendDispatcher = nullptr;
    m_backendDispatcher = nullptr;

    ErrorString unused;
    disable(unused);

void InspectorPageAgent::disable(ErrorString&)
{
    m_enabled = false;
    m_scriptsToEvaluateOnLoad = nullptr;
    m_instrumentingAgents->setInspectorPageAgent(nullptr);

    ErrorString unused;

Lines 193-199 void InspectorReplayAgent::didCreateFrontendAndBackend(Inspector::FrontendChanne a/Source/WebCore/inspector/InspectorReplayAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorReplayAgent.cpp -1 / +1 lines
193	void InspectorReplayAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)	193	void InspectorReplayAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)
194	{	194	{
195	m_frontendDispatcher = nullptr;	195	m_frontendDispatcher = nullptr;
196	m_backendDispatcher.clear();	196	m_backendDispatcher = nullptr;
197		197
198	m_instrumentingAgents->setInspectorReplayAgent(nullptr);	198	m_instrumentingAgents->setInspectorReplayAgent(nullptr);
199		199

Lines 181-187 void InspectorResourceAgent::didCreateFrontendAndBackend(Inspector::FrontendChan a/Source/WebCore/inspector/InspectorResourceAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorResourceAgent.cpp -1 / +1 lines
181	void InspectorResourceAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)	181	void InspectorResourceAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)
182	{	182	{
183	m_frontendDispatcher = nullptr;	183	m_frontendDispatcher = nullptr;
184	m_backendDispatcher.clear();	184	m_backendDispatcher = nullptr;
185		185
186	ErrorString unused;	186	ErrorString unused;
187	disable(unused);	187	disable(unused);



    m_isStyleTextValid = false;
    if (m_element->isStyledElement() && m_element->style() != m_inspectorStyle->cssStyle())
        m_inspectorStyle = InspectorStyle::create(InspectorCSSId(id(), 0), inlineStyle(), this);
    m_ruleSourceData = nullptr;
}

bool InspectorStyleSheetForInlineStyle::getText(String* result) const


    m_styleText = text;
    m_isStyleTextValid = true;
    m_ruleSourceData = nullptr;
    return !ec;
}


    // The "style" property value can get changed indirectly, e.g. via element.style.borderWidth = "2px".
    const String& currentStyleText = elementStyleText();
    if (m_styleText != currentStyleText) {
        m_ruleSourceData = nullptr;
        m_styleText = currentStyleText;
        m_isStyleTextValid = true;
    }

Lines 103-109 void InspectorTimelineAgent::didCreateFrontendAndBackend(Inspector::FrontendChan a/Source/WebCore/inspector/InspectorTimelineAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorTimelineAgent.cpp -1 / +1 lines
103	void InspectorTimelineAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason reason)	103	void InspectorTimelineAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason reason)
104	{	104	{
105	m_frontendDispatcher = nullptr;	105	m_frontendDispatcher = nullptr;
106	m_backendDispatcher.clear();	106	m_backendDispatcher = nullptr;
107		107
108	m_instrumentingAgents->setPersistentInspectorTimelineAgent(nullptr);	108	m_instrumentingAgents->setPersistentInspectorTimelineAgent(nullptr);
109		109

Lines 127-133 void InspectorWorkerAgent::willDestroyFrontendAndBackend(Inspector::DisconnectRe a/Source/WebCore/inspector/InspectorWorkerAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorWorkerAgent.cpp -1 / +1 lines
127	disable(unused);	127	disable(unused);
128		128
129	m_frontendDispatcher = nullptr;	129	m_frontendDispatcher = nullptr;
130	m_backendDispatcher.clear();	130	m_backendDispatcher = nullptr;
131	}	131	}
132		132
133	void InspectorWorkerAgent::enable(ErrorString&)	133	void InspectorWorkerAgent::enable(ErrorString&)

Lines 69-75 void PageRuntimeAgent::didCreateFrontendAndBackend(Inspector::FrontendChannel* f a/Source/WebCore/inspector/PageRuntimeAgent.cpp_sec1
- a/Source/WebCore/inspector/PageRuntimeAgent.cpp -1 / +1 lines
69	void PageRuntimeAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason reason)	69	void PageRuntimeAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason reason)
70	{	70	{
71	m_frontendDispatcher = nullptr;	71	m_frontendDispatcher = nullptr;
72	m_backendDispatcher.clear();	72	m_backendDispatcher = nullptr;
73		73
74	String unused;	74	String unused;
75	disable(unused);	75	disable(unused);

Lines 44-50 void WebInjectedScriptManager::disconnect() a/Source/WebCore/inspector/WebInjectedScriptManager.cpp_sec1
- a/Source/WebCore/inspector/WebInjectedScriptManager.cpp -1 / +1 lines
44	InjectedScriptManager::disconnect();	44	InjectedScriptManager::disconnect();
45		45
46	m_commandLineAPIHost->disconnect();	46	m_commandLineAPIHost->disconnect();
47	m_commandLineAPIHost.clear();	47	m_commandLineAPIHost = nullptr;
48	}	48	}
49		49
50	void WebInjectedScriptManager::didCreateInjectedScript(InjectedScript injectedScript)	50	void WebInjectedScriptManager::didCreateInjectedScript(InjectedScript injectedScript)

Lines 126-132 void WorkerInspectorController::disconnectFrontend(Inspector::DisconnectReason r a/Source/WebCore/inspector/WorkerInspectorController.cpp_sec1
- a/Source/WebCore/inspector/WorkerInspectorController.cpp -1 / +1 lines
126		126
127	m_agents.willDestroyFrontendAndBackend(reason);	127	m_agents.willDestroyFrontendAndBackend(reason);
128	m_backendDispatcher->clearFrontend();	128	m_backendDispatcher->clearFrontend();
129	m_backendDispatcher.clear();	129	m_backendDispatcher = nullptr;
130	m_frontendChannel = nullptr;	130	m_frontendChannel = nullptr;
131	}	131	}
132		132

Lines 60-66 void WorkerRuntimeAgent::didCreateFrontendAndBackend(Inspector::FrontendChannel* a/Source/WebCore/inspector/WorkerRuntimeAgent.cpp_sec1
- a/Source/WebCore/inspector/WorkerRuntimeAgent.cpp -1 / +1 lines
60		60
61	void WorkerRuntimeAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason reason)	61	void WorkerRuntimeAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason reason)
62	{	62	{
63	m_backendDispatcher.clear();	63	m_backendDispatcher = nullptr;
64		64
65	InspectorRuntimeAgent::willDestroyFrontendAndBackend(reason);	65	InspectorRuntimeAgent::willDestroyFrontendAndBackend(reason);
66	}	66	}

Lines 690-696 void FrameLoader::didBeginDocument(bool dispatch) a/Source/WebCore/loader/FrameLoader.cpp_sec1
- a/Source/WebCore/loader/FrameLoader.cpp -1 / +1 lines
690		690
691	if (m_pendingStateObject) {	691	if (m_pendingStateObject) {
692	m_frame.document()->statePopped(m_pendingStateObject.get());	692	m_frame.document()->statePopped(m_pendingStateObject.get());
693	m_pendingStateObject.clear();	693	m_pendingStateObject = nullptr;
694	}	694	}
695		695
696	if (dispatch)	696	if (dispatch)



        return;

    m_parsedStyleSheetCache->removedFromMemoryCache();
    m_parsedStyleSheetCache = nullptr;

    setDecodedSize(0);
}

PassRefPtr<StyleSheetContents> CachedCSSStyleSheet::restoreParsedStyleSheet(const CSSParserContext& context, CachePolicy cachePolicy)
{
    if (!m_parsedStyleSheetCache)
        return nullptr;
    if (!m_parsedStyleSheetCache->subresourcesAllowReuse(cachePolicy)) {
        m_parsedStyleSheetCache->removedFromMemoryCache();
        m_parsedStyleSheetCache = nullptr;
        return nullptr;
    }

    ASSERT(m_parsedStyleSheetCache->isCacheable());


    // Contexts must be identical so we know we would get the same exact result if we parsed again.
    if (m_parsedStyleSheetCache->parserContext() != context)
        return nullptr;

    didAccessDecodedData(monotonicallyIncreasingTime());




    // 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)
        m_image->setImageObserver(nullptr);
    m_image = nullptr;
}

void CachedImage::addIncrementalDataBuffer(SharedBuffer& data)

Lines 268-274 bool CachedRawResource::canReuse(const ResourceRequest& newRequest) const a/Source/WebCore/loader/cache/CachedRawResource.cpp_sec1
- a/Source/WebCore/loader/cache/CachedRawResource.cpp -1 / +1 lines
268		268
269	void CachedRawResource::clear()	269	void CachedRawResource::clear()
270	{	270	{
271	m_data.clear();	271	m_data = nullptr;
272	setEncodedSize(0);	272	setEncodedSize(0);
273	if (m_loader)	273	if (m_loader)
274	m_loader->clearResourceData();	274	m_loader->clearResourceData();

Lines 317-323 void CachedResource::error(CachedResource::Status status) a/Source/WebCore/loader/cache/CachedResource.cpp_sec1
- a/Source/WebCore/loader/cache/CachedResource.cpp -1 / +1 lines
317	{	317	{
318	setStatus(status);	318	setStatus(status);
319	ASSERT(errorOccurred());	319	ASSERT(errorOccurred());
320	m_data.clear();	320	m_data = nullptr;
321		321
322	setLoading(false);	322	setLoading(false);
323	checkNotify();	323	checkNotify();

Lines 71-77 void IconRecord::setImageData(PassRefPtr<SharedBuffer> data) a/Source/WebCore/loader/icon/IconRecord.cpp_sec1
- a/Source/WebCore/loader/icon/IconRecord.cpp -1 / +1 lines
71	// Copy the provided data into the buffer of the new Image object.	71	// Copy the provided data into the buffer of the new Image object.
72	if (!m_image->setData(data, true)) {	72	if (!m_image->setData(data, true)) {
73	LOG(IconDatabase, "Manual image data for iconURL '%s' FAILED - it was probably invalid image data", m_iconURL.ascii().data());	73	LOG(IconDatabase, "Manual image data for iconURL '%s' FAILED - it was probably invalid image data", m_iconURL.ascii().data());
74	m_image.clear();	74	m_image = nullptr;
75	}	75	}
76		76
77	m_dataSet = true;	77	m_dataSet = true;



#endif
#if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
    m_originatingTouchPointTargets.clear();
    m_originatingTouchPointDocument = nullptr;
    m_originatingTouchPointTargetKey = 0;
#endif
    m_maxMouseMovedDuration = 0;

    }
    m_touchPressed = touches->length() > 0;
    if (allTouchReleased)
        m_originatingTouchPointDocument = nullptr;

    // Now iterate the changedTouches list and m_targets within it, sending events to the targets as required.
    bool swallowedEvent = false;

Lines 516-522 void Page::refreshPlugins(bool reload) a/Source/WebCore/page/Page.cpp_sec1
- a/Source/WebCore/page/Page.cpp -1 / +1 lines
516	Vector<Ref<Frame>> framesNeedingReload;	516	Vector<Ref<Frame>> framesNeedingReload;
517		517
518	for (auto& page : *allPages) {	518	for (auto& page : *allPages) {
519	page->m_pluginData.clear();	519	page->m_pluginData = nullptr;
520		520
521	if (!reload)	521	if (!reload)
522	continue;	522	continue;

Lines 86-92 void CARingBuffer::allocate(uint32_t channelCount, size_t bytesPerFrame, size_t a/Source/WebCore/platform/audio/mac/CARingBuffer.cpp_sec1
- a/Source/WebCore/platform/audio/mac/CARingBuffer.cpp -1 / +1 lines
86	void CARingBuffer::deallocate()	86	void CARingBuffer::deallocate()
87	{	87	{
88	if (m_buffers)	88	if (m_buffers)
89	m_buffers.clear();	89	m_buffers = nullptr;
90		90
91	m_channelCount = 0;	91	m_channelCount = 0;
92	m_capacityBytes = 0;	92	m_capacityBytes = 0;

Lines 363-369 const OpenTypeMathData* Font::mathData() const a/Source/WebCore/platform/graphics/Font.cpp_sec1
- a/Source/WebCore/platform/graphics/Font.cpp -1 / +1 lines
363	if (!m_mathData) {	363	if (!m_mathData) {
364	m_mathData = OpenTypeMathData::create(m_platformData);	364	m_mathData = OpenTypeMathData::create(m_platformData);
365	if (!m_mathData->hasMathData())	365	if (!m_mathData->hasMathData())
366	m_mathData.clear();	366	m_mathData = nullptr;
367	}	367	}
368	return m_mathData.get();	368	return m_mathData.get();
369	}	369	}

Lines 320-326 PassRefPtr<OpenTypeVerticalData> FontCache::getVerticalData(const FontFileKey& k a/Source/WebCore/platform/graphics/FontCache.cpp_sec1
- a/Source/WebCore/platform/graphics/FontCache.cpp -1 / +1 lines
320		320
321	RefPtr<OpenTypeVerticalData> verticalData = OpenTypeVerticalData::create(platformData);	321	RefPtr<OpenTypeVerticalData> verticalData = OpenTypeVerticalData::create(platformData);
322	if (!verticalData->isOpenType())	322	if (!verticalData->isOpenType())
323	verticalData.clear();	323	verticalData = nullptr;
324	fontVerticalDataCache.set(key, verticalData);	324	fontVerticalDataCache.set(key, verticalData);
325	return verticalData;	325	return verticalData;
326	}	326	}



{
    m_state.strokeColor = color;
    m_state.strokeColorSpace = colorSpace;
    m_state.strokeGradient = nullptr;
    m_state.strokePattern = nullptr;
    setPlatformStrokeColor(color, colorSpace);
}


{
    m_state.fillColor = color;
    m_state.fillColorSpace = colorSpace;
    m_state.fillGradient = nullptr;
    m_state.fillPattern = nullptr;
    setPlatformFillColor(color, colorSpace);
}



void GraphicsContext::setStrokePattern(Ref<Pattern>&& pattern)
{
    m_state.strokeGradient = nullptr;
    m_state.strokePattern = WTF::move(pattern);
}

void GraphicsContext::setFillPattern(Ref<Pattern>&& pattern)
{
    m_state.fillGradient = nullptr;
    m_state.fillPattern = WTF::move(pattern);
}

void GraphicsContext::setStrokeGradient(Ref<Gradient>&& gradient)
{
    m_state.strokeGradient = WTF::move(gradient);
    m_state.strokePattern = nullptr;
}

void GraphicsContext::setFillGradient(Ref<Gradient>&& gradient)
{
    m_state.fillGradient = WTF::move(gradient);
    m_state.fillPattern = nullptr;
}

void GraphicsContext::beginTransparencyLayer(float opacity)

Lines 43-49 BackingStoreBackendCairoX11::BackingStoreBackendCairoX11(unsigned long rootWindo a/Source/WebCore/platform/graphics/cairo/BackingStoreBackendCairoX11.cpp_sec1
- a/Source/WebCore/platform/graphics/cairo/BackingStoreBackendCairoX11.cpp -1 / +1 lines
43	BackingStoreBackendCairoX11::~BackingStoreBackendCairoX11()	43	BackingStoreBackendCairoX11::~BackingStoreBackendCairoX11()
44	{	44	{
45	// The pixmap needs to exist when the surface is destroyed, so begin by clearing it.	45	// The pixmap needs to exist when the surface is destroyed, so begin by clearing it.
46	m_surface.clear();	46	m_surface = nullptr;
47	}	47	}
48		48
49	void BackingStoreBackendCairoX11::scroll(const IntRect& scrollRect, const IntSize& scrollOffset)	49	void BackingStoreBackendCairoX11::scroll(const IntRect& scrollRect, const IntSize& scrollOffset)

Lines 159-165 bool FrameData::clear(bool clearMetadata) a/Source/WebCore/platform/graphics/cairo/BitmapImageCairo.cpp_sec1
- a/Source/WebCore/platform/graphics/cairo/BitmapImageCairo.cpp -1 / +1 lines
159	m_haveMetadata = false;	159	m_haveMetadata = false;
160		160
161	if (m_frame) {	161	if (m_frame) {
162	m_frame.clear();	162	m_frame = nullptr;
163	return true;	163	return true;
164	}	164	}
165	return false;	165	return false;



    if (m_imageBufferResult)
        m_imageBufferResult.reset();
    if (m_unmultipliedImageResult)
        m_unmultipliedImageResult = nullptr;
    if (m_premultipliedImageResult)
        m_premultipliedImageResult = nullptr;
#if ENABLE(OPENCL)
    if (m_openCLImageResult)
        m_openCLImageResult = nullptr;
#endif
}


#if ENABLE(OPENCL)
    if (openCLImage()) {
        if (m_imageBufferResult)
            m_imageBufferResult = nullptr;
        FilterContextOpenCL* context = FilterContextOpenCL::context();
        ASSERT(context);
        context->openCLTransformColorSpace(m_openCLImageResult, absolutePaintRect(), m_resultColorSpace, dstColorSpace);

    m_resultColorSpace = dstColorSpace;

    if (m_unmultipliedImageResult)
        m_unmultipliedImageResult = nullptr;
    if (m_premultipliedImageResult)
        m_premultipliedImageResult = nullptr;
#endif
}




ImageGStreamer::~ImageGStreamer()
{
    if (m_image)
        m_image = nullptr;

    m_image = 0;

    // 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().

Lines 278-284 PassRefPtr<BitmapTexture> BitmapTextureGL::applyFilters(TextureMapper* textureMa a/Source/WebCore/platform/graphics/texmap/BitmapTextureGL.cpp_sec1
- a/Source/WebCore/platform/graphics/texmap/BitmapTextureGL.cpp -1 / +1 lines
278	texmapGL->drawFiltered(resultSurface.get(), spareSurface.get(), filter, j);	278	texmapGL->drawFiltered(resultSurface.get(), spareSurface.get(), filter, j);
279	if (!j && filter->type() == FilterOperation::DROP_SHADOW) {	279	if (!j && filter->type() == FilterOperation::DROP_SHADOW) {
280	spareSurface = resultSurface;	280	spareSurface = resultSurface;
281	resultSurface.clear();	281	resultSurface = nullptr;
282	}	282	}
283	std::swap(resultSurface, intermediateSurface);	283	std::swap(resultSurface, intermediateSurface);
284	}	284	}

Lines 691-697 void TextureMapperGL::bindDefaultSurface() a/Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp_sec1
- a/Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp -1 / +1 lines
691	data().projectionMatrix = createProjectionMatrix(viewportSize, data().PaintFlags & PaintingMirrored);	691	data().projectionMatrix = createProjectionMatrix(viewportSize, data().PaintFlags & PaintingMirrored);
692	m_context3D->viewport(data().viewport[0], data().viewport[1], viewportSize.width(), viewportSize.height());	692	m_context3D->viewport(data().viewport[0], data().viewport[1], viewportSize.width(), viewportSize.height());
693	m_clipStack.apply(m_context3D.get());	693	m_clipStack.apply(m_context3D.get());
694	data().currentSurface.clear();	694	data().currentSurface = nullptr;
695	}	695	}
696		696
697	void TextureMapperGL::bindSurface(BitmapTexture *surface)	697	void TextureMapperGL::bindSurface(BitmapTexture *surface)

Lines 408-414 void TextureMapperLayer::paintWithIntermediateSurface(const TextureMapperPaintOp a/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.cpp_sec1
- a/Source/WebCore/platform/graphics/texmap/TextureMapperLayer.cpp -1 / +1 lines
408		408
409	if (replicaSurface && options.opacity == 1) {	409	if (replicaSurface && options.opacity == 1) {
410	commitSurface(options, replicaSurface, rect, 1);	410	commitSurface(options, replicaSurface, rect, 1);
411	replicaSurface.clear();	411	replicaSurface = nullptr;
412	}	412	}
413		413
414	mainSurface = paintIntoSurface(paintOptions, rect.size());	414	mainSurface = paintIntoSurface(paintOptions, rect.size());

Lines 39-45 void TextureMapperTiledBackingStore::updateContentsFromImageIfNeeded(TextureMapp a/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.cpp_sec1
- a/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.cpp -1 / +1 lines
39	return;	39	return;
40		40
41	updateContents(textureMapper, m_image.get(), m_image->size(), enclosingIntRect(m_image->rect()), BitmapTexture::UpdateCannotModifyOriginalImageData);	41	updateContents(textureMapper, m_image.get(), m_image->size(), enclosingIntRect(m_image->rect()), BitmapTexture::UpdateCannotModifyOriginalImageData);
42	m_image.clear();	42	m_image = nullptr;
43	}	43	}
44		44
45	TransformationMatrix TextureMapperTiledBackingStore::adjustedTransformForRect(const FloatRect& targetRect)	45	TransformationMatrix TextureMapperTiledBackingStore::adjustedTransformForRect(const FloatRect& targetRect)

Lines 820-826 void CoordinatedGraphicsLayer::releaseImageBackingIfNeeded() a/Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp_sec1
- a/Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp -1 / +1 lines
820		820
821	ASSERT(m_coordinator);	821	ASSERT(m_coordinator);
822	m_coordinatedImageBacking->removeHost(this);	822	m_coordinatedImageBacking->removeHost(this);
823	m_coordinatedImageBacking.clear();	823	m_coordinatedImageBacking = nullptr;
824	m_layerState.imageID = InvalidCoordinatedImageBackingID;	824	m_layerState.imageID = InvalidCoordinatedImageBackingID;
825	m_layerState.imageChanged = true;	825	m_layerState.imageChanged = true;
826	}	826	}

Lines 141-147 void CoordinatedImageBacking::releaseSurfaceIfNeeded() a/Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedImageBacking.cpp_sec1
- a/Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedImageBacking.cpp -1 / +1 lines
141	{	141	{
142	// We must keep m_surface until UI Process reads m_surface.	142	// We must keep m_surface until UI Process reads m_surface.
143	// If m_surface exists, it was created in the previous update.	143	// If m_surface exists, it was created in the previous update.
144	m_surface.clear();	144	m_surface = nullptr;
145	}	145	}
146		146
147	static const double clearContentsTimerInterval = 3;	147	static const double clearContentsTimerInterval = 3;

Lines 155-161 void GamepadsGtk::unregisterDevice(String deviceFile) a/Source/WebCore/platform/gtk/GamepadsGtk.cpp_sec1
- a/Source/WebCore/platform/gtk/GamepadsGtk.cpp -1 / +1 lines
155	size_t index = m_slots.find(gamepadDevice);	155	size_t index = m_slots.find(gamepadDevice);
156	ASSERT(index != notFound);	156	ASSERT(index != notFound);
157		157
158	m_slots[index].clear();	158	m_slots[index] = nullptr;
159	}	159	}
160		160
161	void GamepadsGtk::updateGamepadList(GamepadList* into)	161	void GamepadsGtk::updateGamepadList(GamepadList* into)

Lines 954-960 void InlineFlowBox::computeOverflow(LayoutUnit lineTop, LayoutUnit lineBottom, G a/Source/WebCore/rendering/InlineFlowBox.cpp_sec1
- a/Source/WebCore/rendering/InlineFlowBox.cpp -1 / +1 lines
954	return;	954	return;
955		955
956	if (m_overflow)	956	if (m_overflow)
957	m_overflow.clear();	957	m_overflow = nullptr;
958		958
959	// Visual overflow just includes overflow for stuff we need to repaint ourselves. Self-painting layers are ignored.	959	// Visual overflow just includes overflow for stuff we need to repaint ourselves. Self-painting layers are ignored.
960	// Layout overflow is used to determine scrolling extent, so it still includes child layers and also factors in	960	// Layout overflow is used to determine scrolling extent, so it still includes child layers and also factors in

Lines 4497-4503 void RenderBox::addVisualOverflow(const LayoutRect& rect) a/Source/WebCore/rendering/RenderBox.cpp_sec1
- a/Source/WebCore/rendering/RenderBox.cpp -1 / +1 lines
4497		4497
4498	void RenderBox::clearOverflow()	4498	void RenderBox::clearOverflow()
4499	{	4499	{
4500	m_overflow.clear();	4500	m_overflow = nullptr;
4501	RenderFlowThread* flowThread = flowThreadContainingBlock();	4501	RenderFlowThread* flowThread = flowThreadContainingBlock();
4502	if (flowThread)	4502	if (flowThread)
4503	flowThread->clearRegionsOverflow(this);	4503	flowThread->clearRegionsOverflow(this);

Lines 53-59 public: a/Source/WebCore/rendering/RenderBoxRegionInfo.h_sec1
- a/Source/WebCore/rendering/RenderBoxRegionInfo.h -1 / +1 lines
53	void clearOverflow()	53	void clearOverflow()
54	{	54	{
55	if (m_overflow)	55	if (m_overflow)
56	m_overflow.clear();	56	m_overflow = nullptr;
57	}	57	}
58		58
59	private:	59	private:



    void setSize(FillSize f) { m_sizeType = f.type; m_sizeLength = f.size; }
    void setMaskSourceType(EMaskSourceType m) { m_maskSourceType = m; m_maskSourceTypeSet = true; }

    void clearMaskImage() { m_maskImageOperation = nullptr; }
    void clearImage() { m_image = nullptr; m_imageSet = false; }
    void clearXPosition() { m_xPosSet = false; m_backgroundOriginSet = false; }
    void clearYPosition() { m_yPosSet = false; m_backgroundOriginSet = false; }


Lines 104-110 void SVGTRefTargetEventListener::detach() a/Source/WebCore/svg/SVGTRefElement.cpp_sec1
- a/Source/WebCore/svg/SVGTRefElement.cpp -1 / +1 lines
104		104
105	m_target->removeEventListener(eventNames().DOMSubtreeModifiedEvent, this, false);	105	m_target->removeEventListener(eventNames().DOMSubtreeModifiedEvent, this, false);
106	m_target->removeEventListener(eventNames().DOMNodeRemovedFromDocumentEvent, this, false);	106	m_target->removeEventListener(eventNames().DOMNodeRemovedFromDocumentEvent, this, false);
107	m_target.clear();	107	m_target = nullptr;
108	}	108	}
109		109
110	bool SVGTRefTargetEventListener::operator==(const EventListener& listener)	110	bool SVGTRefTargetEventListener::operator==(const EventListener& listener)

Lines 1723-1729 void Internals::closeDummyInspectorFrontend() a/Source/WebCore/testing/Internals.cpp_sec1
- a/Source/WebCore/testing/Internals.cpp -1 / +1 lines
1723	m_frontendChannel = nullptr;	1723	m_frontendChannel = nullptr;
1724		1724
1725	m_frontendWindow->close(m_frontendWindow->scriptExecutionContext());	1725	m_frontendWindow->close(m_frontendWindow->scriptExecutionContext());
1726	m_frontendWindow.clear();	1726	m_frontendWindow = nullptr;
1727	}	1727	}
1728		1728
1729	void Internals::setJavaScriptProfilingEnabled(bool enabled, ExceptionCode& ec)	1729	void Internals::setJavaScriptProfilingEnabled(bool enabled, ExceptionCode& ec)



            return;
        m_eventQueue.m_eventDispatcherMap.remove(m_event.get());
        m_event->target()->dispatchEvent(m_event);
        m_event = nullptr;
    }

    void cancel()
    {
        m_isCancelled = true;
        m_event = nullptr;
    }

private:



            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);
            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();

            m_responseArrayBuffer = m_binaryResponseBuilder->createArrayBuffer();
        else
            m_responseArrayBuffer = ArrayBuffer::create(nullptr, 0);
        m_binaryResponseBuilder = nullptr;
    }

    return m_responseArrayBuffer.get();

    m_createdDocument = false;
    m_responseDocument = nullptr;
    m_responseBlob = nullptr;
    m_binaryResponseBuilder = nullptr;
    m_responseArrayBuffer = nullptr;
    m_responseCacheIsValid = false;
}





void XSLTProcessor::reset()
{
    m_stylesheet = nullptr;
    m_stylesheetRootNode = nullptr;
    m_parameters.clear();
}


Lines 1143-1149 void WebEditorClient::didCheckSucceed(int sequence, NSArray* results) a/Source/WebKit/mac/WebCoreSupport/WebEditorClient.mm_sec1
- a/Source/WebKit/mac/WebCoreSupport/WebEditorClient.mm -1 / +1 lines
1143	{	1143	{
1144	ASSERT_UNUSED(sequence, sequence == m_textCheckingRequest->data().sequence());	1144	ASSERT_UNUSED(sequence, sequence == m_textCheckingRequest->data().sequence());
1145	m_textCheckingRequest->didSucceed(core(results, m_textCheckingRequest->data().mask()));	1145	m_textCheckingRequest->didSucceed(core(results, m_textCheckingRequest->data().mask()));
1146	m_textCheckingRequest.clear();	1146	m_textCheckingRequest = nullptr;
1147	}	1147	}
1148	#endif	1148	#endif
1149		1149



        KillTimer(m_viewWindow, DeleteBackingStoreTimer);
        m_deleteBackingStoreTimerActive = false;
    }
    m_backingStoreBitmap = nullptr;
    m_backingStoreDirtyRegion = nullptr;
    m_backingStoreSize.cx = m_backingStoreSize.cy = 0;
}


        if (m_uiDelegatePrivate)
            m_uiDelegatePrivate->webViewPainted(this);

        m_backingStoreDirtyRegion = nullptr;
    }

    if (!dc)

Lines 147-153 void UniqueIDBDatabase::shutdownBackingStore(UniqueIDBDatabaseShutdownType type, a/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp_sec1
- a/Source/WebKit2/DatabaseProcess/IndexedDB/UniqueIDBDatabase.cpp -1 / +1 lines
147	{	147	{
148	ASSERT(!RunLoop::isMain());	148	ASSERT(!RunLoop::isMain());
149		149
150	m_backingStore.clear();	150	m_backingStore = nullptr;
151		151
152	if (type == UniqueIDBDatabaseShutdownType::DeleteShutdown) {	152	if (type == UniqueIDBDatabaseShutdownType::DeleteShutdown) {
153	String dbFilename = UniqueIDBDatabase::calculateAbsoluteDatabaseFilename(databaseDirectory);	153	String dbFilename = UniqueIDBDatabase::calculateAbsoluteDatabaseFilename(databaseDirectory);

Lines 55-61 void CoordinatedBackingStoreTile::swapBuffers(TextureMapper* textureMapper) a/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedBackingStore.cpp_sec1
- a/Source/WebKit2/Shared/CoordinatedGraphics/CoordinatedBackingStore.cpp -1 / +1 lines
55	texture->reset(m_tileRect.size(), m_surface->supportsAlpha());	55	texture->reset(m_tileRect.size(), m_surface->supportsAlpha());
56		56
57	m_surface->copyToTexture(texture, m_sourceRect, m_surfaceOffset);	57	m_surface->copyToTexture(texture, m_sourceRect, m_surfaceOffset);
58	m_surface.clear();	58	m_surface = nullptr;
59	}	59	}
60		60
61	void CoordinatedBackingStoreTile::setBackBuffer(const IntRect& tileRect, const IntRect& sourceRect, PassRefPtr<CoordinatedSurface> buffer, const IntPoint& offset)	61	void CoordinatedBackingStoreTile::setBackBuffer(const IntRect& tileRect, const IntRect& sourceRect, PassRefPtr<CoordinatedSurface> buffer, const IntPoint& offset)

Lines 940-946 void EwkView::hideContextMenu() a/Source/WebKit2/UIProcess/API/efl/EwkView.cpp_sec1
- a/Source/WebKit2/UIProcess/API/efl/EwkView.cpp -1 / +1 lines
940	if (sd->api->context_menu_hide)	940	if (sd->api->context_menu_hide)
941	sd->api->context_menu_hide(sd);	941	sd->api->context_menu_hide(sd);
942		942
943	m_contextMenu.clear();	943	m_contextMenu = nullptr;
944	}	944	}
945		945
946	void EwkView::requestPopupMenu(WKPopupMenuListenerRef popupMenuListener, const WKRect& rect, WKPopupItemTextDirection textDirection, double pageScaleFactor, WKArrayRef items, int32_t selectedIndex)	946	void EwkView::requestPopupMenu(WKPopupMenuListenerRef popupMenuListener, const WKRect& rect, WKPopupItemTextDirection textDirection, double pageScaleFactor, WKArrayRef items, int32_t selectedIndex)

Lines 126-132 void WebSocketServerConnection::sendRawData(const char* data, size_t length) a/Source/WebKit2/UIProcess/InspectorServer/WebSocketServerConnection.cpp_sec1
- a/Source/WebKit2/UIProcess/InspectorServer/WebSocketServerConnection.cpp -1 / +1 lines
126	void WebSocketServerConnection::didCloseSocketStream(SocketStreamHandle*)	126	void WebSocketServerConnection::didCloseSocketStream(SocketStreamHandle*)
127	{	127	{
128	// Destroy the SocketStreamHandle now to prevent closing an already closed socket later.	128	// Destroy the SocketStreamHandle now to prevent closing an already closed socket later.
129	m_socket.clear();	129	m_socket = nullptr;
130		130
131	// Web Socket Mode.	131	// Web Socket Mode.
132	if (m_mode == WebSocket)	132	if (m_mode == WebSocket)

Lines 76-82 - (id)initWithCustomProtocolManagerProxy:(CustomProtocolManagerProxy*)customProt a/Source/WebKit2/UIProcess/Network/CustomProtocols/mac/CustomProtocolManagerProxyMac.mm_sec1
- a/Source/WebKit2/UIProcess/Network/CustomProtocols/mac/CustomProtocolManagerProxyMac.mm -1 / +1 lines
76		76
77	- (void)dealloc	77	- (void)dealloc
78	{	78	{
79	_connection.clear();	79	_connection = nullptr;
80	[_urlConnection cancel];	80	[_urlConnection cancel];
81	[_urlConnection release];	81	[_urlConnection release];
82	[super dealloc];	82	[super dealloc];

Lines 118-124 -(void)_stopUpdating a/Source/WebKit2/UIProcess/ios/WKGeolocationProviderIOS.mm_sec1
- a/Source/WebKit2/UIProcess/ios/WKGeolocationProviderIOS.mm -1 / +1 lines
118	{	118	{
119	_isWebCoreGeolocationActive = NO;	119	_isWebCoreGeolocationActive = NO;
120	[_coreLocationProvider stop];	120	[_coreLocationProvider stop];
121	_lastActivePosition.clear();	121	_lastActivePosition = nullptr;
122	}	122	}
123		123
124	-(void)_setEnableHighAccuracy:(BOOL)enableHighAccuracy	124	-(void)_setEnableHighAccuracy:(BOOL)enableHighAccuracy

Lines 2064-2070 static void runTest(const string& inputLine) a/Tools/DumpRenderTree/mac/DumpRenderTree.mm_sec1
- a/Tools/DumpRenderTree/mac/DumpRenderTree.mm -1 / +1 lines
2064	ASSERT(CFArrayGetCount(openWindowsRef) == 1);	2064	ASSERT(CFArrayGetCount(openWindowsRef) == 1);
2065	ASSERT(CFArrayGetValueAtIndex(openWindowsRef, 0) == [[mainFrame webView] window]);	2065	ASSERT(CFArrayGetValueAtIndex(openWindowsRef, 0) == [[mainFrame webView] window]);
2066		2066
2067	gTestRunner.clear();	2067	gTestRunner = nullptr;
2068		2068
2069	if (ignoreWebCoreNodeLeaks)	2069	if (ignoreWebCoreNodeLeaks)
2070	[WebCoreStatistics stopIgnoringWebCoreNodeLeaks];	2070	[WebCoreStatistics stopIgnoringWebCoreNodeLeaks];

Lines 1183-1189 static void runTest(const string& inputLine) a/Tools/DumpRenderTree/win/DumpRenderTree.cpp_sec1
- a/Tools/DumpRenderTree/win/DumpRenderTree.cpp -1 / +1 lines
1183		1183
1184	exit:	1184	exit:
1185	removeFontFallbackIfPresent(fallbackPath);	1185	removeFontFallbackIfPresent(fallbackPath);
1186	::gTestRunner.clear();	1186	::gTestRunner = nullptr;
1187		1187
1188	fputs("#EOF\n", stderr);	1188	fputs("#EOF\n", stderr);
1189	fflush(stderr);	1189	fflush(stderr);

Lines 102-108 TEST(WTF_RefPtr, Basic) a/Tools/TestWebKitAPI/Tests/WTF/RefPtr.cpp_sec1
- a/Tools/TestWebKitAPI/Tests/WTF/RefPtr.cpp -1 / +1 lines
102	{	102	{
103	RefPtr<RefLogger> ptr(&a);	103	RefPtr<RefLogger> ptr(&a);
104	ASSERT_EQ(&a, ptr.get());	104	ASSERT_EQ(&a, ptr.get());
105	ptr.clear();	105	ptr = nullptr;
106	ASSERT_EQ(nullptr, ptr.get());	106	ASSERT_EQ(nullptr, ptr.get());
107	}	107	}
108	ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str());	108	ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str());

Return to Bug 146556

Lines 394-400 void MediaSource::setReadyState(const AtomicString& state) a/Source/WebCore/Modules/mediasource/MediaSource.cpp_sec1
- a/Source/WebCore/Modules/mediasource/MediaSource.cpp -2 / +2 lines
394	LOG(MediaSource, "MediaSource::setReadyState(%p) : %s -> %s", this, oldState.string().ascii().data(), state.string().ascii().data());	394	LOG(MediaSource, "MediaSource::setReadyState(%p) : %s -> %s", this, oldState.string().ascii().data(), state.string().ascii().data());
395		395
396	if (state == closedKeyword()) {	396	if (state == closedKeyword()) {
397	m_private.clear();	397	m_private = nullptr;
398	m_mediaElement = nullptr;	398	m_mediaElement = nullptr;
399	m_duration = MediaTime::invalidTime();	399	m_duration = MediaTime::invalidTime();
400	}	400	}
Lines 811-817 void MediaSource::stop() a/Source/WebCore/Modules/mediasource/MediaSource.cpp_sec2
811	m_asyncEventQueue.close();	811	m_asyncEventQueue.close();
812	if (!isClosed())	812	if (!isClosed())
813	setReadyState(closedKeyword());	813	setReadyState(closedKeyword());
814	m_private.clear();	814	m_private = nullptr;
815	}	815	}
816		816
817	bool MediaSource::canSuspendForPageCache() const	817	bool MediaSource::canSuspendForPageCache() const

Lines 4502-4516 void CSSParser::parseFillPosition(CSSParserValueList& valueList, RefPtr<CSSValue a/Source/WebCore/css/CSSParser.cpp_sec1
- a/Source/WebCore/css/CSSParser.cpp -6 / +6 lines
4502	if (value2)	4502	if (value2)
4503	valueList.next();	4503	valueList.next();
4504	else {	4504	else {
4505	value1.clear();	4505	value1 = nullptr;
4506	return;	4506	return;
4507	}	4507	}
4508		4508
4509	RefPtr<CSSPrimitiveValue> parsedValue1 = downcast<CSSPrimitiveValue>(value1.get());	4509	RefPtr<CSSPrimitiveValue> parsedValue1 = downcast<CSSPrimitiveValue>(value1.get());
4510	RefPtr<CSSPrimitiveValue> parsedValue2 = downcast<CSSPrimitiveValue>(value2.get());	4510	RefPtr<CSSPrimitiveValue> parsedValue2 = downcast<CSSPrimitiveValue>(value2.get());
4511		4511
4512	value1.clear();	4512	value1 = nullptr;
4513	value2.clear();	4513	value2 = nullptr;
4514		4514
4515	// Per CSS3 syntax, <position> can't have 'center' as its second keyword as we have more arguments to follow.	4515	// Per CSS3 syntax, <position> can't have 'center' as its second keyword as we have more arguments to follow.
4516	if (parsedValue2->getValueID() == CSSValueCenter)	4516	if (parsedValue2->getValueID() == CSSValueCenter)
Lines 4549-4555 void CSSParser::parse2ValuesFillPosition(CSSParserValueList& valueList, RefPtr<C a/Source/WebCore/css/CSSParser.cpp_sec2
4549	valueList.next();	4549	valueList.next();
4550	else {	4550	else {
4551	if (!inShorthand()) {	4551	if (!inShorthand()) {
4552	value1.clear();	4552	value1 = nullptr;
4553	return;	4553	return;
4554	}	4554	}
4555	}	4555	}
Lines 12184-12190 PassRefPtr<CSSRuleSourceData> CSSParser::popRuleData() a/Source/WebCore/css/CSSParser.cpp_sec3
12184	return nullptr;	12184	return nullptr;
12185		12185
12186	ASSERT(!m_currentRuleDataStack->isEmpty());	12186	ASSERT(!m_currentRuleDataStack->isEmpty());
12187	m_currentRuleData.clear();	12187	m_currentRuleData = nullptr;
12188	RefPtr<CSSRuleSourceData> data = m_currentRuleDataStack->last();	12188	RefPtr<CSSRuleSourceData> data = m_currentRuleDataStack->last();
12189	m_currentRuleDataStack->removeLast();	12189	m_currentRuleDataStack->removeLast();
12190	return data.release();	12190	return data.release();
Lines 12605-12611 void CSSParser::markRuleBodyStart() a/Source/WebCore/css/CSSParser.cpp_sec4
12605	{	12605	{
12606	if (!isExtractingSourceData())	12606	if (!isExtractingSourceData())
12607	return;	12607	return;
12608	m_currentRuleData.clear();	12608	m_currentRuleData = nullptr;
12609	unsigned offset = tokenStartOffset();	12609	unsigned offset = tokenStartOffset();
12610	if (tokenStartChar() == '{')	12610	if (tokenStartChar() == '{')
12611	++offset; // Skip the rule body opening brace.	12611	++offset; // Skip the rule body opening brace.

Lines 2424-2430 void Document::detachParser() a/Source/WebCore/dom/Document.cpp_sec1
- a/Source/WebCore/dom/Document.cpp -3 / +3 lines
2424	if (!m_parser)	2424	if (!m_parser)
2425	return;	2425	return;
2426	m_parser->detach();	2426	m_parser->detach();
2427	m_parser.clear();	2427	m_parser = nullptr;
2428	}	2428	}
2429		2429
2430	void Document::cancelParsing()	2430	void Document::cancelParsing()
Lines 5882-5888 void Document::clearScriptedAnimationController() a/Source/WebCore/dom/Document.cpp_sec2
5882	// FIXME: consider using ActiveDOMObject.	5882	// FIXME: consider using ActiveDOMObject.
5883	if (m_scriptedAnimationController)	5883	if (m_scriptedAnimationController)
5884	m_scriptedAnimationController->clearDocumentPointer();	5884	m_scriptedAnimationController->clearDocumentPointer();
5885	m_scriptedAnimationController.clear();	5885	m_scriptedAnimationController = nullptr;
5886	}	5886	}
5887	#endif	5887	#endif
5888		5888
Lines 6300-6306 void Document::updateHoverActiveState(const HitTestRequest& request, Element* in a/Source/WebCore/dom/Document.cpp_sec3
6300	curr->setActive(false);	6300	curr->setActive(false);
6301	m_userActionElements.setInActiveChain(curr, false);	6301	m_userActionElements.setInActiveChain(curr, false);
6302	}	6302	}
6303	m_activeElement.clear();	6303	m_activeElement = nullptr;
6304	} else {	6304	} else {
6305	Element* newActiveElement = innerElementInDocument;	6305	Element* newActiveElement = innerElementInDocument;
6306	if (!oldActiveElement && newActiveElement && request.active() && !request.touchMove()) {	6306	if (!oldActiveElement && newActiveElement && request.active() && !request.touchMove()) {

Lines 149-156 struct StructureStubInfo { a/Source/JavaScriptCore/bytecode/StructureStubInfo.h_sec1
- a/Source/JavaScriptCore/bytecode/StructureStubInfo.h -2 / +2 lines
149	{	149	{
150	deref();	150	deref();
151	accessType = access_unset;	151	accessType = access_unset;
152	stubRoutine.clear();	152	stubRoutine = nullptr;
153	watchpoints.clear();	153	watchpoints = nullptr;
154	}	154	}
155		155
156	void deref();	156	void deref();

Lines 52-59 void ExecutableBase::destroy(JSCell* cell) a/Source/JavaScriptCore/runtime/Executable.cpp_sec1
- a/Source/JavaScriptCore/runtime/Executable.cpp -6 / +6 lines
52	void ExecutableBase::clearCode()	52	void ExecutableBase::clearCode()
53	{	53	{
54	#if ENABLE(JIT)	54	#if ENABLE(JIT)
55	m_jitCodeForCall.clear();	55	m_jitCodeForCall = nullptr;
56	m_jitCodeForConstruct.clear();	56	m_jitCodeForConstruct = nullptr;
57	m_jitCodeForCallWithArityCheck = MacroAssemblerCodePtr();	57	m_jitCodeForCallWithArityCheck = MacroAssemblerCodePtr();
58	m_jitCodeForConstructWithArityCheck = MacroAssemblerCodePtr();	58	m_jitCodeForConstructWithArityCheck = MacroAssemblerCodePtr();
59	m_jitCodeForCallWithArityCheckAndPreserveRegs = MacroAssemblerCodePtr();	59	m_jitCodeForCallWithArityCheckAndPreserveRegs = MacroAssemblerCodePtr();
Lines 464-470 void EvalExecutable::unlinkCalls() a/Source/JavaScriptCore/runtime/Executable.cpp_sec2
464		464
465	void EvalExecutable::clearCode()	465	void EvalExecutable::clearCode()
466	{	466	{
467	m_evalCodeBlock.clear();	467	m_evalCodeBlock = nullptr;
468	m_unlinkedEvalCodeBlock.clear();	468	m_unlinkedEvalCodeBlock.clear();
469	Base::clearCode();	469	Base::clearCode();
470	}	470	}
Lines 543-549 void ProgramExecutable::visitChildren(JSCell* cell, SlotVisitor& visitor) a/Source/JavaScriptCore/runtime/Executable.cpp_sec3
543		543
544	void ProgramExecutable::clearCode()	544	void ProgramExecutable::clearCode()
545	{	545	{
546	m_programCodeBlock.clear();	546	m_programCodeBlock = nullptr;
547	m_unlinkedProgramCodeBlock.clear();	547	m_unlinkedProgramCodeBlock.clear();
548	Base::clearCode();	548	Base::clearCode();
549	}	549	}
Lines 587-594 void FunctionExecutable::clearUnlinkedCodeForRecompilation() a/Source/JavaScriptCore/runtime/Executable.cpp_sec4
587		587
588	void FunctionExecutable::clearCode()	588	void FunctionExecutable::clearCode()
589	{	589	{
590	m_codeBlockForCall.clear();	590	m_codeBlockForCall = nullptr;
591	m_codeBlockForConstruct.clear();	591	m_codeBlockForConstruct = nullptr;
592	Base::clearCode();	592	Base::clearCode();
593	}	593	}
594		594

Lines 60-66 public: a/Source/WTF/wtf/RefPtr.h_sec1
- a/Source/WTF/wtf/RefPtr.h -6 lines
60		60
61	T* get() const { return m_ptr; }	61	T* get() const { return m_ptr; }
62		62
63	void clear();
64	PassRefPtr<T> release() { PassRefPtr<T> tmp = adoptRef(m_ptr); m_ptr = nullptr; return tmp; }	63	PassRefPtr<T> release() { PassRefPtr<T> tmp = adoptRef(m_ptr); m_ptr = nullptr; return tmp; }
65	Ref<T> releaseNonNull() { ASSERT(m_ptr); Ref<T> tmp(adoptRef(*m_ptr)); m_ptr = nullptr; return tmp; }	64	Ref<T> releaseNonNull() { ASSERT(m_ptr); Ref<T> tmp(adoptRef(*m_ptr)); m_ptr = nullptr; return tmp; }
66		65
Lines 109-119 template<typename T> template<typename U> inline RefPtr<T>::RefPtr(Ref<U>&& refe a/Source/WTF/wtf/RefPtr.h_sec2
109	{	108	{
110	}	109	}
111		110
112	template<typename T> inline void RefPtr<T>::clear()
113	{
114	derefIfNotNull(std::exchange(m_ptr, nullptr));
115	}
116
117	template<typename T>	111	template<typename T>
118	inline T* RefPtr<T>::leakRef()	112	inline T* RefPtr<T>::leakRef()
119	{	113	{

Lines 170-178 void IDBRequest::abort() a/Source/WebCore/Modules/indexeddb/IDBRequest.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/IDBRequest.cpp -7 / +7 lines
170	m_enqueuedEvents.clear();	170	m_enqueuedEvents.clear();
171		171
172	m_errorCode = 0;	172	m_errorCode = 0;
173	m_error.clear();	173	m_error = nullptr;
174	m_errorMessage = String();	174	m_errorMessage = String();
175	m_result.clear();	175	m_result = nullptr;
176	onError(IDBDatabaseError::create(IDBDatabaseException::AbortError));	176	onError(IDBDatabaseError::create(IDBDatabaseException::AbortError));
177	m_requestAborted = true;	177	m_requestAborted = true;
178	}	178	}
Lines 194-203 void IDBRequest::setPendingCursor(PassRefPtr<IDBCursor> cursor) a/Source/WebCore/Modules/indexeddb/IDBRequest.cpp_sec2
194	ASSERT(cursor == getResultCursor());	194	ASSERT(cursor == getResultCursor());
195		195
196	m_pendingCursor = cursor;	196	m_pendingCursor = cursor;
197	m_result.clear();	197	m_result = nullptr;
198	m_readyState = PENDING;	198	m_readyState = PENDING;
199	m_errorCode = 0;	199	m_errorCode = 0;
200	m_error.clear();	200	m_error = nullptr;
201	m_errorMessage = String();	201	m_errorMessage = String();
202	m_transaction->registerRequest(this);	202	m_transaction->registerRequest(this);
203	}	203	}
Lines 256-262 void IDBRequest::onError(PassRefPtr<IDBDatabaseError> error) a/Source/WebCore/Modules/indexeddb/IDBRequest.cpp_sec3
256	m_errorCode = error->code();	256	m_errorCode = error->code();
257	m_errorMessage = error->message();	257	m_errorMessage = error->message();
258	m_error = DOMError::create(IDBDatabaseException::getErrorName(error->idbCode()));	258	m_error = DOMError::create(IDBDatabaseException::getErrorName(error->idbCode()));
259	m_pendingCursor.clear();	259	m_pendingCursor = nullptr;
260	enqueueEvent(Event::create(eventNames().errorEvent, true, true));	260	enqueueEvent(Event::create(eventNames().errorEvent, true, true));
261	}	261	}
262		262
Lines 404-410 void IDBRequest::onSuccessInternal(const Deprecated::ScriptValue& value) a/Source/WebCore/Modules/indexeddb/IDBRequest.cpp_sec4
404	m_result = IDBAny::create(value);	404	m_result = IDBAny::create(value);
405	if (m_pendingCursor) {	405	if (m_pendingCursor) {
406	m_pendingCursor->close();	406	m_pendingCursor->close();
407	m_pendingCursor.clear();	407	m_pendingCursor = nullptr;
408	}	408	}
409	enqueueEvent(createSuccessEvent());	409	enqueueEvent(createSuccessEvent());
410	}	410	}
Lines 553-559 void IDBRequest::transactionDidFinishAndDispatch() a/Source/WebCore/Modules/indexeddb/IDBRequest.cpp_sec5
553	ASSERT(m_transaction->isVersionChange());	553	ASSERT(m_transaction->isVersionChange());
554	ASSERT(m_readyState == DONE);	554	ASSERT(m_readyState == DONE);
555	ASSERT(scriptExecutionContext());	555	ASSERT(scriptExecutionContext());
556	m_transaction.clear();	556	m_transaction = nullptr;
557	m_readyState = PENDING;	557	m_readyState = PENDING;
558	}	558	}
559		559

Lines 97-104 bool RTCSessionDescriptionRequestImpl::canSuspendForPageCache() const a/Source/WebCore/Modules/mediastream/RTCSessionDescriptionRequestImpl.cpp_sec1
- a/Source/WebCore/Modules/mediastream/RTCSessionDescriptionRequestImpl.cpp -2 / +2 lines
97		97
98	void RTCSessionDescriptionRequestImpl::clear()	98	void RTCSessionDescriptionRequestImpl::clear()
99	{	99	{
100	m_successCallback.clear();	100	m_successCallback = nullptr;
101	m_errorCallback.clear();	101	m_errorCallback = nullptr;
102	}	102	}
103		103
104	} // namespace WebCore	104	} // namespace WebCore

Lines 94-101 bool RTCVoidRequestImpl::canSuspendForPageCache() const a/Source/WebCore/Modules/mediastream/RTCVoidRequestImpl.cpp_sec1
- a/Source/WebCore/Modules/mediastream/RTCVoidRequestImpl.cpp -2 / +2 lines
94		94
95	void RTCVoidRequestImpl::clear()	95	void RTCVoidRequestImpl::clear()
96	{	96	{
97	m_successCallback.clear();	97	m_successCallback = nullptr;
98	m_errorCallback.clear();	98	m_errorCallback = nullptr;
99	}	99	}
100		100
101	} // namespace WebCore	101	} // namespace WebCore

Lines 45-51 NodeIterator::NodePointer::NodePointer(PassRefPtr<Node> n, bool b) a/Source/WebCore/dom/NodeIterator.cpp_sec1
- a/Source/WebCore/dom/NodeIterator.cpp -2 / +2 lines
45		45
46	void NodeIterator::NodePointer::clear()	46	void NodeIterator::NodePointer::clear()
47	{	47	{
48	node.clear();	48	node = nullptr;
49	}	49	}
50		50
51	bool NodeIterator::NodePointer::moveToNext(Node* root)	51	bool NodeIterator::NodePointer::moveToNext(Node* root)
Lines 151-157 void NodeIterator::detach() a/Source/WebCore/dom/NodeIterator.cpp_sec2
151	{	151	{
152	root()->document().detachNodeIterator(this);	152	root()->document().detachNodeIterator(this);
153	m_detached = true;	153	m_detached = true;
154	m_referenceNode.node.clear();	154	m_referenceNode.node = nullptr;
155	}	155	}
156		156
157	void NodeIterator::nodeWillBeRemoved(Node& removedNode)	157	void NodeIterator::nodeWillBeRemoved(Node& removedNode)

Lines 112-120 inline int RangeBoundaryPoint::offset() const a/Source/WebCore/dom/RangeBoundaryPoint.h_sec1
- a/Source/WebCore/dom/RangeBoundaryPoint.h -2 / +2 lines
112		112
113	inline void RangeBoundaryPoint::clear()	113	inline void RangeBoundaryPoint::clear()
114	{	114	{
115	m_containerNode.clear();	115	m_containerNode = nullptr;
116	m_offsetInContainer = 0;	116	m_offsetInContainer = 0;
117	m_childBeforeBoundary = 0;	117	m_childBeforeBoundary = nullptr;
118	}	118	}
119		119
120	inline void RangeBoundaryPoint::set(PassRefPtr<Node> container, int offset, Node* childBefore)	120	inline void RangeBoundaryPoint::set(PassRefPtr<Node> container, int offset, Node* childBefore)

Lines 185-191 inline void StyledElement::setInlineStyleFromString(const AtomicString& newStyle a/Source/WebCore/dom/StyledElement.cpp_sec1
- a/Source/WebCore/dom/StyledElement.cpp -2 / +2 lines
185	// We reconstruct the property set instead of mutating if there is no CSSOM wrapper.	185	// We reconstruct the property set instead of mutating if there is no CSSOM wrapper.
186	// This makes wrapperless property sets immutable and so cacheable.	186	// This makes wrapperless property sets immutable and so cacheable.
187	if (inlineStyle && !is<MutableStyleProperties>(*inlineStyle))	187	if (inlineStyle && !is<MutableStyleProperties>(*inlineStyle))
188	inlineStyle.clear();	188	inlineStyle = nullptr;
189		189
190	if (!inlineStyle)	190	if (!inlineStyle)
191	inlineStyle = CSSParser::parseInlineStyleDeclaration(newStyleString, this);	191	inlineStyle = CSSParser::parseInlineStyleDeclaration(newStyleString, this);
Lines 202-208 void StyledElement::styleAttributeChanged(const AtomicString& newStyleString, At a/Source/WebCore/dom/StyledElement.cpp_sec2
202	if (newStyleString.isNull()) {	202	if (newStyleString.isNull()) {
203	if (PropertySetCSSStyleDeclaration* cssomWrapper = inlineStyleCSSOMWrapper())	203	if (PropertySetCSSStyleDeclaration* cssomWrapper = inlineStyleCSSOMWrapper())
204	cssomWrapper->clearParentElement();	204	cssomWrapper->clearParentElement();
205	ensureUniqueElementData().m_inlineStyle.clear();	205	ensureUniqueElementData().m_inlineStyle = nullptr;
206	} else if (reason == ModifiedByCloning \|\| document().contentSecurityPolicy()->allowInlineStyle(document().url(), startLineNumber))	206	} else if (reason == ModifiedByCloning \|\| document().contentSecurityPolicy()->allowInlineStyle(document().url(), startLineNumber))
207	setInlineStyleFromString(newStyleString);	207	setInlineStyleFromString(newStyleString);
208		208

Lines 147-153 void AlternativeTextController::startAlternativeTextUITimer(AlternativeTextType a/Source/WebCore/editing/AlternativeTextController.cpp_sec1
- a/Source/WebCore/editing/AlternativeTextController.cpp -5 / +5 lines
147		147
148	// If type is PanelTypeReversion, then the new range has been set. So we shouldn't clear it.	148	// If type is PanelTypeReversion, then the new range has been set. So we shouldn't clear it.
149	if (type == AlternativeTextTypeCorrection)	149	if (type == AlternativeTextTypeCorrection)
150	m_alternativeTextInfo.rangeWithAlternative.clear();	150	m_alternativeTextInfo.rangeWithAlternative = nullptr;
151	m_alternativeTextInfo.type = type;	151	m_alternativeTextInfo.type = type;
152	m_timer.startOneShot(correctionPanelTimerInterval);	152	m_timer.startOneShot(correctionPanelTimerInterval);
153	}	153	}
Lines 155-161 void AlternativeTextController::startAlternativeTextUITimer(AlternativeTextType a/Source/WebCore/editing/AlternativeTextController.cpp_sec2
155	void AlternativeTextController::stopAlternativeTextUITimer()	155	void AlternativeTextController::stopAlternativeTextUITimer()
156	{	156	{
157	m_timer.stop();	157	m_timer.stop();
158	m_alternativeTextInfo.rangeWithAlternative.clear();	158	m_alternativeTextInfo.rangeWithAlternative = nullptr;
159	}	159	}
160		160
161	void AlternativeTextController::stopPendingCorrection(const VisibleSelection& oldSelection)	161	void AlternativeTextController::stopPendingCorrection(const VisibleSelection& oldSelection)
Lines 183-189 void AlternativeTextController::applyPendingCorrection(const VisibleSelection& s a/Source/WebCore/editing/AlternativeTextController.cpp_sec3
183	if (doApplyCorrection)	183	if (doApplyCorrection)
184	handleAlternativeTextUIResult(dismissSoon(ReasonForDismissingAlternativeTextAccepted));	184	handleAlternativeTextUIResult(dismissSoon(ReasonForDismissingAlternativeTextAccepted));
185	else	185	else
186	m_alternativeTextInfo.rangeWithAlternative.clear();	186	m_alternativeTextInfo.rangeWithAlternative = nullptr;
187	}	187	}
188		188
189	bool AlternativeTextController::hasPendingCorrection() const	189	bool AlternativeTextController::hasPendingCorrection() const
Lines 359-365 void AlternativeTextController::timerFired() a/Source/WebCore/editing/AlternativeTextController.cpp_sec4
359	Vector<String> suggestions;	359	Vector<String> suggestions;
360	textChecker()->getGuessesForWord(m_alternativeTextInfo.originalText, paragraphText, suggestions);	360	textChecker()->getGuessesForWord(m_alternativeTextInfo.originalText, paragraphText, suggestions);
361	if (suggestions.isEmpty()) {	361	if (suggestions.isEmpty()) {
362	m_alternativeTextInfo.rangeWithAlternative.clear();	362	m_alternativeTextInfo.rangeWithAlternative = nullptr;
363	break;	363	break;
364	}	364	}
365	String topSuggestion = suggestions.first();	365	String topSuggestion = suggestions.first();
Lines 422-428 void AlternativeTextController::handleAlternativeTextUIResult(const String& resu a/Source/WebCore/editing/AlternativeTextController.cpp_sec5
422	break;	422	break;
423	}	423	}
424		424
425	m_alternativeTextInfo.rangeWithAlternative.clear();	425	m_alternativeTextInfo.rangeWithAlternative = nullptr;
426	}	426	}
427		427
428	bool AlternativeTextController::isAutomaticSpellingCorrectionEnabled()	428	bool AlternativeTextController::isAutomaticSpellingCorrectionEnabled()

Lines 423-429 void HTMLCanvasElement::makePresentationCopy() a/Source/WebCore/html/HTMLCanvasElement.cpp_sec1
- a/Source/WebCore/html/HTMLCanvasElement.cpp -2 / +2 lines
423		423
424	void HTMLCanvasElement::clearPresentationCopy()	424	void HTMLCanvasElement::clearPresentationCopy()
425	{	425	{
426	m_presentedImage.clear();	426	m_presentedImage = nullptr;
427	}	427	}
428		428
429	void HTMLCanvasElement::setSurfaceSize(const IntSize& size)	429	void HTMLCanvasElement::setSurfaceSize(const IntSize& size)
Lines 644-650 void HTMLCanvasElement::clearImageBuffer() const a/Source/WebCore/html/HTMLCanvasElement.cpp_sec2
644		644
645	void HTMLCanvasElement::clearCopiedImage()	645	void HTMLCanvasElement::clearCopiedImage()
646	{	646	{
647	m_copiedImage.clear();	647	m_copiedImage = nullptr;
648	m_didClearImageBuffer = false;	648	m_didClearImageBuffer = false;
649	}	649	}
650		650

Lines 104-110 bool HTMLPlugInElement::willRespondToMouseClickEvents() a/Source/WebCore/html/HTMLPlugInElement.cpp_sec1
- a/Source/WebCore/html/HTMLPlugInElement.cpp -2 / +2 lines
104		104
105	void HTMLPlugInElement::willDetachRenderers()	105	void HTMLPlugInElement::willDetachRenderers()
106	{	106	{
107	m_instance.clear();	107	m_instance = nullptr;
108		108
109	if (m_isCapturingMouseEvents) {	109	if (m_isCapturingMouseEvents) {
110	if (Frame* frame = document().frame())	110	if (Frame* frame = document().frame())
Lines 122-128 void HTMLPlugInElement::willDetachRenderers() a/Source/WebCore/html/HTMLPlugInElement.cpp_sec2
122		122
123	void HTMLPlugInElement::resetInstance()	123	void HTMLPlugInElement::resetInstance()
124	{	124	{
125	m_instance.clear();	125	m_instance = nullptr;
126	}	126	}
127		127
128	PassRefPtr<JSC::Bindings::Instance> HTMLPlugInElement::getInstance()	128	PassRefPtr<JSC::Bindings::Instance> HTMLPlugInElement::getInstance()

Lines 243-251 void InspectorOverlay::setPausedInDebuggerMessage(const String* message) a/Source/WebCore/inspector/InspectorOverlay.cpp_sec1
- a/Source/WebCore/inspector/InspectorOverlay.cpp -5 / +5 lines
243		243
244	void InspectorOverlay::hideHighlight()	244	void InspectorOverlay::hideHighlight()
245	{	245	{
246	m_highlightNode.clear();	246	m_highlightNode = nullptr;
247	m_highlightNodeList.clear();	247	m_highlightNodeList = nullptr;
248	m_highlightQuad.reset();	248	m_highlightQuad = nullptr;
249	update();	249	update();
250	}	250	}
251		251
Lines 253-259 void InspectorOverlay::highlightNodeList(PassRefPtr<NodeList> nodes, const Highl a/Source/WebCore/inspector/InspectorOverlay.cpp_sec2
253	{	253	{
254	m_nodeHighlightConfig = highlightConfig;	254	m_nodeHighlightConfig = highlightConfig;
255	m_highlightNodeList = nodes;	255	m_highlightNodeList = nodes;
256	m_highlightNode.clear();	256	m_highlightNode = nullptr;
257	update();	257	update();
258	}	258	}
259		259
Lines 261-267 void InspectorOverlay::highlightNode(Node* node, const HighlightConfig& highligh a/Source/WebCore/inspector/InspectorOverlay.cpp_sec3
261	{	261	{
262	m_nodeHighlightConfig = highlightConfig;	262	m_nodeHighlightConfig = highlightConfig;
263	m_highlightNode = node;	263	m_highlightNode = node;
264	m_highlightNodeList.clear();	264	m_highlightNodeList = nullptr;
265	update();	265	update();
266	}	266	}
267		267

Lines 348-354 void InspectorPageAgent::didCreateFrontendAndBackend(Inspector::FrontendChannel* a/Source/WebCore/inspector/InspectorPageAgent.cpp_sec1
- a/Source/WebCore/inspector/InspectorPageAgent.cpp -2 / +2 lines
348	void InspectorPageAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)	348	void InspectorPageAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)
349	{	349	{
350	m_frontendDispatcher = nullptr;	350	m_frontendDispatcher = nullptr;
351	m_backendDispatcher.clear();	351	m_backendDispatcher = nullptr;
352		352
353	ErrorString unused;	353	ErrorString unused;
354	disable(unused);	354	disable(unused);
Lines 374-380 void InspectorPageAgent::enable(ErrorString&) a/Source/WebCore/inspector/InspectorPageAgent.cpp_sec2
374	void InspectorPageAgent::disable(ErrorString&)	374	void InspectorPageAgent::disable(ErrorString&)
375	{	375	{
376	m_enabled = false;	376	m_enabled = false;
377	m_scriptsToEvaluateOnLoad.clear();	377	m_scriptsToEvaluateOnLoad = nullptr;
378	m_instrumentingAgents->setInspectorPageAgent(nullptr);	378	m_instrumentingAgents->setInspectorPageAgent(nullptr);
379		379
380	ErrorString unused;	380	ErrorString unused;

Lines 1261-1267 void InspectorStyleSheetForInlineStyle::didModifyElementAttribute() a/Source/WebCore/inspector/InspectorStyleSheet.cpp_sec1
- a/Source/WebCore/inspector/InspectorStyleSheet.cpp -3 / +3 lines
1261	m_isStyleTextValid = false;	1261	m_isStyleTextValid = false;
1262	if (m_element->isStyledElement() && m_element->style() != m_inspectorStyle->cssStyle())	1262	if (m_element->isStyledElement() && m_element->style() != m_inspectorStyle->cssStyle())
1263	m_inspectorStyle = InspectorStyle::create(InspectorCSSId(id(), 0), inlineStyle(), this);	1263	m_inspectorStyle = InspectorStyle::create(InspectorCSSId(id(), 0), inlineStyle(), this);
1264	m_ruleSourceData.clear();	1264	m_ruleSourceData = nullptr;
1265	}	1265	}
1266		1266
1267	bool InspectorStyleSheetForInlineStyle::getText(String* result) const	1267	bool InspectorStyleSheetForInlineStyle::getText(String* result) const
Lines 1285-1291 bool InspectorStyleSheetForInlineStyle::setStyleText(CSSStyleDeclaration* style, a/Source/WebCore/inspector/InspectorStyleSheet.cpp_sec2
1285		1285
1286	m_styleText = text;	1286	m_styleText = text;
1287	m_isStyleTextValid = true;	1287	m_isStyleTextValid = true;
1288	m_ruleSourceData.clear();	1288	m_ruleSourceData = nullptr;
1289	return !ec;	1289	return !ec;
1290	}	1290	}
1291		1291
Lines 1304-1310 bool InspectorStyleSheetForInlineStyle::ensureParsedDataReady() a/Source/WebCore/inspector/InspectorStyleSheet.cpp_sec3
1304	// The "style" property value can get changed indirectly, e.g. via element.style.borderWidth = "2px".	1304	// The "style" property value can get changed indirectly, e.g. via element.style.borderWidth = "2px".
1305	const String& currentStyleText = elementStyleText();	1305	const String& currentStyleText = elementStyleText();
1306	if (m_styleText != currentStyleText) {	1306	if (m_styleText != currentStyleText) {
1307	m_ruleSourceData.clear();	1307	m_ruleSourceData = nullptr;
1308	m_styleText = currentStyleText;	1308	m_styleText = currentStyleText;
1309	m_isStyleTextValid = true;	1309	m_isStyleTextValid = true;
1310	}	1310	}

Lines 138-144 void CachedCSSStyleSheet::destroyDecodedData() a/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp_sec1
- a/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp -5 / +5 lines
138	return;	138	return;
139		139
140	m_parsedStyleSheetCache->removedFromMemoryCache();	140	m_parsedStyleSheetCache->removedFromMemoryCache();
141	m_parsedStyleSheetCache.clear();	141	m_parsedStyleSheetCache = nullptr;
142		142
143	setDecodedSize(0);	143	setDecodedSize(0);
144	}	144	}
Lines 146-156 void CachedCSSStyleSheet::destroyDecodedData() a/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp_sec2
146	PassRefPtr<StyleSheetContents> CachedCSSStyleSheet::restoreParsedStyleSheet(const CSSParserContext& context, CachePolicy cachePolicy)	146	PassRefPtr<StyleSheetContents> CachedCSSStyleSheet::restoreParsedStyleSheet(const CSSParserContext& context, CachePolicy cachePolicy)
147	{	147	{
148	if (!m_parsedStyleSheetCache)	148	if (!m_parsedStyleSheetCache)
149	return 0;	149	return nullptr;
150	if (!m_parsedStyleSheetCache->subresourcesAllowReuse(cachePolicy)) {	150	if (!m_parsedStyleSheetCache->subresourcesAllowReuse(cachePolicy)) {
151	m_parsedStyleSheetCache->removedFromMemoryCache();	151	m_parsedStyleSheetCache->removedFromMemoryCache();
152	m_parsedStyleSheetCache.clear();	152	m_parsedStyleSheetCache = nullptr;
153	return 0;	153	return nullptr;
154	}	154	}
155		155
156	ASSERT(m_parsedStyleSheetCache->isCacheable());	156	ASSERT(m_parsedStyleSheetCache->isCacheable());
Lines 158-164 PassRefPtr<StyleSheetContents> CachedCSSStyleSheet::restoreParsedStyleSheet(cons a/Source/WebCore/loader/cache/CachedCSSStyleSheet.cpp_sec3
158		158
159	// Contexts must be identical so we know we would get the same exact result if we parsed again.	159	// Contexts must be identical so we know we would get the same exact result if we parsed again.
160	if (m_parsedStyleSheetCache->parserContext() != context)	160	if (m_parsedStyleSheetCache->parserContext() != context)
161	return 0;	161	return nullptr;
162		162
163	didAccessDecodedData(monotonicallyIncreasingTime());	163	didAccessDecodedData(monotonicallyIncreasingTime());
164		164

Lines 365-372 inline void CachedImage::clearImage() a/Source/WebCore/loader/cache/CachedImage.cpp_sec1
- a/Source/WebCore/loader/cache/CachedImage.cpp -2 / +2 lines
365	// If our Image has an observer, it's always us so we need to clear the back pointer	365	// If our Image has an observer, it's always us so we need to clear the back pointer
366	// before dropping our reference.	366	// before dropping our reference.
367	if (m_image)	367	if (m_image)
368	m_image->setImageObserver(0);	368	m_image->setImageObserver(nullptr);
369	m_image.clear();	369	m_image = nullptr;
370	}	370	}
371		371
372	void CachedImage::addIncrementalDataBuffer(SharedBuffer& data)	372	void CachedImage::addIncrementalDataBuffer(SharedBuffer& data)

Lines 494-500 void EventHandler::clear() a/Source/WebCore/page/EventHandler.cpp_sec1
- a/Source/WebCore/page/EventHandler.cpp -2 / +2 lines
494	#endif	494	#endif
495	#if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)	495	#if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
496	m_originatingTouchPointTargets.clear();	496	m_originatingTouchPointTargets.clear();
497	m_originatingTouchPointDocument.clear();	497	m_originatingTouchPointDocument = nullptr;
498	m_originatingTouchPointTargetKey = 0;	498	m_originatingTouchPointTargetKey = 0;
499	#endif	499	#endif
500	m_maxMouseMovedDuration = 0;	500	m_maxMouseMovedDuration = 0;
Lines 3994-4000 bool EventHandler::handleTouchEvent(const PlatformTouchEvent& event) a/Source/WebCore/page/EventHandler.cpp_sec2
3994	}	3994	}
3995	m_touchPressed = touches->length() > 0;	3995	m_touchPressed = touches->length() > 0;
3996	if (allTouchReleased)	3996	if (allTouchReleased)
3997	m_originatingTouchPointDocument.clear();	3997	m_originatingTouchPointDocument = nullptr;
3998		3998
3999	// Now iterate the changedTouches list and m_targets within it, sending events to the targets as required.	3999	// Now iterate the changedTouches list and m_targets within it, sending events to the targets as required.
4000	bool swallowedEvent = false;	4000	bool swallowedEvent = false;

Lines 178-185 void GraphicsContext::setStrokeColor(const Color& color, ColorSpace colorSpace) a/Source/WebCore/platform/graphics/GraphicsContext.cpp_sec1
- a/Source/WebCore/platform/graphics/GraphicsContext.cpp -8 / +8 lines
178	{	178	{
179	m_state.strokeColor = color;	179	m_state.strokeColor = color;
180	m_state.strokeColorSpace = colorSpace;	180	m_state.strokeColorSpace = colorSpace;
181	m_state.strokeGradient.clear();	181	m_state.strokeGradient = nullptr;
182	m_state.strokePattern.clear();	182	m_state.strokePattern = nullptr;
183	setPlatformStrokeColor(color, colorSpace);	183	setPlatformStrokeColor(color, colorSpace);
184	}	184	}
185		185
Lines 245-252 void GraphicsContext::setFillColor(const Color& color, ColorSpace colorSpace) a/Source/WebCore/platform/graphics/GraphicsContext.cpp_sec2
245	{	245	{
246	m_state.fillColor = color;	246	m_state.fillColor = color;
247	m_state.fillColorSpace = colorSpace;	247	m_state.fillColorSpace = colorSpace;
248	m_state.fillGradient.clear();	248	m_state.fillGradient = nullptr;
249	m_state.fillPattern.clear();	249	m_state.fillPattern = nullptr;
250	setPlatformFillColor(color, colorSpace);	250	setPlatformFillColor(color, colorSpace);
251	}	251	}
252		252
Lines 269-294 void GraphicsContext::setAntialiasedFontDilationEnabled(bool antialiasedFontDila a/Source/WebCore/platform/graphics/GraphicsContext.cpp_sec3
269		269
270	void GraphicsContext::setStrokePattern(Ref<Pattern>&& pattern)	270	void GraphicsContext::setStrokePattern(Ref<Pattern>&& pattern)
271	{	271	{
272	m_state.strokeGradient.clear();	272	m_state.strokeGradient = nullptr;
273	m_state.strokePattern = WTF::move(pattern);	273	m_state.strokePattern = WTF::move(pattern);
274	}	274	}
275		275
276	void GraphicsContext::setFillPattern(Ref<Pattern>&& pattern)	276	void GraphicsContext::setFillPattern(Ref<Pattern>&& pattern)
277	{	277	{
278	m_state.fillGradient.clear();	278	m_state.fillGradient = nullptr;
279	m_state.fillPattern = WTF::move(pattern);	279	m_state.fillPattern = WTF::move(pattern);
280	}	280	}
281		281
282	void GraphicsContext::setStrokeGradient(Ref<Gradient>&& gradient)	282	void GraphicsContext::setStrokeGradient(Ref<Gradient>&& gradient)
283	{	283	{
284	m_state.strokeGradient = WTF::move(gradient);	284	m_state.strokeGradient = WTF::move(gradient);
285	m_state.strokePattern.clear();	285	m_state.strokePattern = nullptr;
286	}	286	}
287		287
288	void GraphicsContext::setFillGradient(Ref<Gradient>&& gradient)	288	void GraphicsContext::setFillGradient(Ref<Gradient>&& gradient)
289	{	289	{
290	m_state.fillGradient = WTF::move(gradient);	290	m_state.fillGradient = WTF::move(gradient);
291	m_state.fillPattern.clear();	291	m_state.fillPattern = nullptr;
292	}	292	}
293		293
294	void GraphicsContext::beginTransparencyLayer(float opacity)	294	void GraphicsContext::beginTransparencyLayer(float opacity)

Lines 245-256 void FilterEffect::clearResult() a/Source/WebCore/platform/graphics/filters/FilterEffect.cpp_sec1
- a/Source/WebCore/platform/graphics/filters/FilterEffect.cpp -6 / +6 lines
245	if (m_imageBufferResult)	245	if (m_imageBufferResult)
246	m_imageBufferResult.reset();	246	m_imageBufferResult.reset();
247	if (m_unmultipliedImageResult)	247	if (m_unmultipliedImageResult)
248	m_unmultipliedImageResult.clear();	248	m_unmultipliedImageResult = nullptr;
249	if (m_premultipliedImageResult)	249	if (m_premultipliedImageResult)
250	m_premultipliedImageResult.clear();	250	m_premultipliedImageResult = nullptr;
251	#if ENABLE(OPENCL)	251	#if ENABLE(OPENCL)
252	if (m_openCLImageResult)	252	if (m_openCLImageResult)
253	m_openCLImageResult.clear();	253	m_openCLImageResult = nullptr;
254	#endif	254	#endif
255	}	255	}
256		256
Lines 540-546 void FilterEffect::transformResultColorSpace(ColorSpace dstColorSpace) a/Source/WebCore/platform/graphics/filters/FilterEffect.cpp_sec2
540	#if ENABLE(OPENCL)	540	#if ENABLE(OPENCL)
541	if (openCLImage()) {	541	if (openCLImage()) {
542	if (m_imageBufferResult)	542	if (m_imageBufferResult)
543	m_imageBufferResult.clear();	543	m_imageBufferResult = nullptr;
544	FilterContextOpenCL* context = FilterContextOpenCL::context();	544	FilterContextOpenCL* context = FilterContextOpenCL::context();
545	ASSERT(context);	545	ASSERT(context);
546	context->openCLTransformColorSpace(m_openCLImageResult, absolutePaintRect(), m_resultColorSpace, dstColorSpace);	546	context->openCLTransformColorSpace(m_openCLImageResult, absolutePaintRect(), m_resultColorSpace, dstColorSpace);
Lines 558-566 void FilterEffect::transformResultColorSpace(ColorSpace dstColorSpace) a/Source/WebCore/platform/graphics/filters/FilterEffect.cpp_sec3
558	m_resultColorSpace = dstColorSpace;	558	m_resultColorSpace = dstColorSpace;
559		559
560	if (m_unmultipliedImageResult)	560	if (m_unmultipliedImageResult)
561	m_unmultipliedImageResult.clear();	561	m_unmultipliedImageResult = nullptr;
562	if (m_premultipliedImageResult)	562	if (m_premultipliedImageResult)
563	m_premultipliedImageResult.clear();	563	m_premultipliedImageResult = nullptr;
564	#endif	564	#endif
565	}	565	}
566		566

Lines 71-79 ImageGStreamer::ImageGStreamer(GstSample* sample) a/Source/WebCore/platform/graphics/gstreamer/ImageGStreamerCairo.cpp_sec1
- a/Source/WebCore/platform/graphics/gstreamer/ImageGStreamerCairo.cpp -3 / +1 lines
71	ImageGStreamer::~ImageGStreamer()	71	ImageGStreamer::~ImageGStreamer()
72	{	72	{
73	if (m_image)	73	if (m_image)
74	m_image.clear();	74	m_image = nullptr;
75
76	m_image = 0;
77		75
78	// We keep the buffer memory mapped until the image is destroyed because the internal	76	// We keep the buffer memory mapped until the image is destroyed because the internal
79	// cairo_surface_t was created using cairo_image_surface_create_for_data().	77	// cairo_surface_t was created using cairo_image_surface_create_for_data().

Lines 121-128 public: a/Source/WebCore/rendering/style/FillLayer.h_sec1
- a/Source/WebCore/rendering/style/FillLayer.h -2 / +2 lines
121	void setSize(FillSize f) { m_sizeType = f.type; m_sizeLength = f.size; }	121	void setSize(FillSize f) { m_sizeType = f.type; m_sizeLength = f.size; }
122	void setMaskSourceType(EMaskSourceType m) { m_maskSourceType = m; m_maskSourceTypeSet = true; }	122	void setMaskSourceType(EMaskSourceType m) { m_maskSourceType = m; m_maskSourceTypeSet = true; }
123		123
124	void clearMaskImage() { m_maskImageOperation.clear(); }	124	void clearMaskImage() { m_maskImageOperation = nullptr; }
125	void clearImage() { m_image.clear(); m_imageSet = false; }	125	void clearImage() { m_image = nullptr; m_imageSet = false; }
126	void clearXPosition() { m_xPosSet = false; m_backgroundOriginSet = false; }	126	void clearXPosition() { m_xPosSet = false; m_backgroundOriginSet = false; }
127	void clearYPosition() { m_yPosSet = false; m_backgroundOriginSet = false; }	127	void clearYPosition() { m_yPosSet = false; m_backgroundOriginSet = false; }
128		128

Lines 68-80 public: a/Source/WebCore/workers/WorkerEventQueue.cpp_sec1
- a/Source/WebCore/workers/WorkerEventQueue.cpp -2 / +2 lines
68	return;	68	return;
69	m_eventQueue.m_eventDispatcherMap.remove(m_event.get());	69	m_eventQueue.m_eventDispatcherMap.remove(m_event.get());
70	m_event->target()->dispatchEvent(m_event);	70	m_event->target()->dispatchEvent(m_event);
71	m_event.clear();	71	m_event = nullptr;
72	}	72	}
73		73
74	void cancel()	74	void cancel()
75	{	75	{
76	m_isCancelled = true;	76	m_isCancelled = true;
77	m_event.clear();	77	m_event = nullptr;
78	}	78	}
79		79
80	private:	80	private:

Lines 245-251 Blob* XMLHttpRequest::responseBlob() a/Source/WebCore/xml/XMLHttpRequest.cpp_sec1
- a/Source/WebCore/xml/XMLHttpRequest.cpp -4 / +4 lines
245	data.append(m_binaryResponseBuilder->data(), m_binaryResponseBuilder->size());	245	data.append(m_binaryResponseBuilder->data(), m_binaryResponseBuilder->size());
246	String normalizedContentType = Blob::normalizedContentType(responseMIMEType()); // responseMIMEType defaults to text/xml which may be incorrect.	246	String normalizedContentType = Blob::normalizedContentType(responseMIMEType()); // responseMIMEType defaults to text/xml which may be incorrect.
247	m_responseBlob = Blob::create(WTF::move(data), normalizedContentType);	247	m_responseBlob = Blob::create(WTF::move(data), normalizedContentType);
248	m_binaryResponseBuilder.clear();	248	m_binaryResponseBuilder = nullptr;
249	} else {	249	} else {
250	// If we errored out or got no data, we still return a blob, just an empty one.	250	// If we errored out or got no data, we still return a blob, just an empty one.
251	m_responseBlob = Blob::create();	251	m_responseBlob = Blob::create();
Lines 265-271 ArrayBuffer* XMLHttpRequest::responseArrayBuffer() a/Source/WebCore/xml/XMLHttpRequest.cpp_sec2
265	m_responseArrayBuffer = m_binaryResponseBuilder->createArrayBuffer();	265	m_responseArrayBuffer = m_binaryResponseBuilder->createArrayBuffer();
266	else	266	else
267	m_responseArrayBuffer = ArrayBuffer::create(nullptr, 0);	267	m_responseArrayBuffer = ArrayBuffer::create(nullptr, 0);
268	m_binaryResponseBuilder.clear();	268	m_binaryResponseBuilder = nullptr;
269	}	269	}
270		270
271	return m_responseArrayBuffer.get();	271	return m_responseArrayBuffer.get();
Lines 868-875 void XMLHttpRequest::clearResponseBuffers() a/Source/WebCore/xml/XMLHttpRequest.cpp_sec3
868	m_createdDocument = false;	868	m_createdDocument = false;
869	m_responseDocument = nullptr;	869	m_responseDocument = nullptr;
870	m_responseBlob = nullptr;	870	m_responseBlob = nullptr;
871	m_binaryResponseBuilder.clear();	871	m_binaryResponseBuilder = nullptr;
872	m_responseArrayBuffer.clear();	872	m_responseArrayBuffer = nullptr;
873	m_responseCacheIsValid = false;	873	m_responseCacheIsValid = false;
874	}	874	}
875		875

Lines 162-169 void XSLTProcessor::removeParameter(const String& /namespaceURI/, const String a/Source/WebCore/xml/XSLTProcessor.cpp_sec1
- a/Source/WebCore/xml/XSLTProcessor.cpp -2 / +2 lines
162		162
163	void XSLTProcessor::reset()	163	void XSLTProcessor::reset()
164	{	164	{
165	m_stylesheet.clear();	165	m_stylesheet = nullptr;
166	m_stylesheetRootNode.clear();	166	m_stylesheetRootNode = nullptr;
167	m_parameters.clear();	167	m_parameters.clear();
168	}	168	}
169		169

Lines 851-858 void WebView::deleteBackingStore() a/Source/WebKit/win/WebView.cpp_sec1
- a/Source/WebKit/win/WebView.cpp -3 / +3 lines
851	KillTimer(m_viewWindow, DeleteBackingStoreTimer);	851	KillTimer(m_viewWindow, DeleteBackingStoreTimer);
852	m_deleteBackingStoreTimerActive = false;	852	m_deleteBackingStoreTimerActive = false;
853	}	853	}
854	m_backingStoreBitmap.clear();	854	m_backingStoreBitmap = nullptr;
855	m_backingStoreDirtyRegion.clear();	855	m_backingStoreDirtyRegion = nullptr;
856	m_backingStoreSize.cx = m_backingStoreSize.cy = 0;	856	m_backingStoreSize.cx = m_backingStoreSize.cy = 0;
857	}	857	}
858		858
Lines 1079-1085 void WebView::updateBackingStore(FrameView* frameView, HDC dc, bool backingStore a/Source/WebKit/win/WebView.cpp_sec2
1079	if (m_uiDelegatePrivate)	1079	if (m_uiDelegatePrivate)
1080	m_uiDelegatePrivate->webViewPainted(this);	1080	m_uiDelegatePrivate->webViewPainted(this);
1081		1081
1082	m_backingStoreDirtyRegion.clear();	1082	m_backingStoreDirtyRegion = nullptr;
1083	}	1083	}
1084		1084
1085	if (!dc)	1085	if (!dc)