// Try to create a PurgeableBuffer. We can fail to create one for any of the
// following reasons:
// - shouldUsePurgeableMemory is set to false.
// - the size of the buffer is less than the minimum size required by
// PurgeableBuffer (currently 16k).
// - PurgeableBuffer::createUninitialized() call fails.
void SharedBuffer::createPurgeableBuffer() const
{
if (m_purgeableBuffer)
return;
if (hasPlatformData())
return;
#if USE(NETWORK_CFDATA_ARRAY_CALLBACK)
if (singleDataArrayBuffer())
return;
#endif
if (!hasOneRef())
return;
if (!m_shouldUsePurgeableMemory)
return;
char* destination = 0;
m_purgeableBuffer = PurgeableBuffer::createUninitialized(m_size, destination);
if (!m_purgeableBuffer)
return;
unsigned bufferSize = m_buffer.size();
if (bufferSize) {
memcpy(destination, m_buffer.data(), bufferSize);
destination += bufferSize;
m_buffer.clear();
}
copyBufferAndClear(destination, m_size - bufferSize);
}
void MainFrame::selfOnlyDeref()
{
ASSERT(m_selfOnlyRefCount);
if (--m_selfOnlyRefCount)
return;
if (hasOneRef())
dropChildren();
deref();
}
bool MediaValuesCached::isSafeToSendToAnotherThread() const
{
#if ENABLE(OILPAN)
// Oilpan objects are safe to send to another thread as long as the thread
// does not outlive the thread used for creation. MediaValues are
// allocated on the main thread and may be passed to the parser thread,
// so this should be safe.
return true;
#else
return hasOneRef();
#endif
}
void IDBRequest::checkForReferenceCycle()
{
// If this request and its cursor have the only references
// to each other, then explicitly break the cycle.
IDBCursor* cursor = getResultCursor();
if (!cursor || cursor->request() != this)
return;
if (!hasOneRef() || !cursor->hasOneRef())
return;
m_result.clear();
}
void IDBCursor::checkForReferenceCycle()
{
// If this cursor and its request have the only references
// to each other, then explicitly break the cycle.
if (!m_request || m_request->getResultCursor() != this)
return;
if (!hasOneRef() || !m_request->hasOneRef())
return;
handleBlobAcks();
m_request.clear();
}
void PluginView::unprotectPluginFromDestruction()
{
if (m_isBeingDestroyed)
return;
// A plug-in may ask us to evaluate JavaScript that removes the plug-in from the
// page, but expect the object to still be alive when the call completes. Flash,
// for example, may crash if the plug-in is destroyed and we return to code for
// the destroyed object higher on the stack. To prevent this, if the plug-in has
// only one remaining reference, call deref() asynchronously.
if (hasOneRef())
RunLoop::main()->dispatch(bind(derefPluginView, this));
else
deref();
}
bool AnimationPlayer::canFree() const
{
ASSERT(m_content);
return hasOneRef() && m_content->isAnimation() && m_content->hasOneRef();
}
PassOwnPtr<PurgeableBuffer> SharedBuffer::releasePurgeableBuffer()
{
ASSERT(hasOneRef());
return m_purgeableBuffer.release();
}
bool MediaValues::isSafeToSendToAnotherThread() const
{
return (!m_frame && !m_style && m_mode == CachingMode && hasOneRef());
}
bool MediaValuesCached::isSafeToSendToAnotherThread() const
{
return hasOneRef();
}
