void WebSocketExtensionDispatcher::addProcessor(PassOwnPtr<WebSocketExtensionProcessor> processor)
{
for (size_t i = 0; i < m_processors.size(); ++i) {
if (m_processors[i]->extensionToken() == processor->extensionToken())
return;
}
ASSERT(processor->handshakeString().length());
ASSERT(!processor->handshakeString().contains('\n'));
ASSERT(!processor->handshakeString().contains(static_cast<UChar>('\0')));
m_processors.append(processor);
}
void HTMLResourcePreloader::preload(PassOwnPtr<PreloadRequest> preload)
{
ASSERT(m_document->frame());
ASSERT(m_document->renderView());
ASSERT(m_document->renderView()->style());
if (!preload->media().isEmpty() && !mediaAttributeMatches(m_document->frame(), m_document->renderView()->style(), preload->media()))
return;
CachedResourceRequest request = preload->resourceRequest(m_document);
m_document->cachedResourceLoader()->preload(preload->resourceType(), request, preload->charset());
}
void HeaderMap::forEachInternal(PassOwnPtr<HeaderMapForEachCallback> callback, ScriptValue* thisArg)
{
TrackExceptionState exceptionState;
for (HashMap<String, String>::const_iterator it = m_headers.begin(); it != m_headers.end(); ++it) {
if (thisArg)
callback->handleItem(*thisArg, it->value, it->key, this);
else
callback->handleItem(it->value, it->key, this);
if (exceptionState.hadException())
break;
}
}
void Headers::forEachInternal(PassOwnPtr<HeadersForEachCallback> callback, ScriptValue* thisArg)
{
TrackExceptionState exceptionState;
for (size_t i = 0; i < m_headerList->size(); ++i) {
if (thisArg)
callback->handleItem(*thisArg, m_headerList->list()[i]->second, m_headerList->list()[i]->first, this);
else
callback->handleItem(m_headerList->list()[i]->second, m_headerList->list()[i]->first, this);
if (exceptionState.hadException())
break;
}
}
void WorkerThreadableWebSocketChannel::Peer::sendArrayBuffer(PassOwnPtr<Vector<char> > data)
{
ASSERT(isMainThread());
if (!m_mainWebSocketChannel || !m_workerClientWrapper) {
m_syncHelper->setSendRequestResult(WebSocketChannel::SendFail);
} else {
RefPtr<ArrayBuffer> binaryData = ArrayBuffer::create(data->data(), data->size());
WebSocketChannel::SendResult sendRequestResult = m_mainWebSocketChannel->send(*binaryData, 0, binaryData->byteLength());
m_syncHelper->setSendRequestResult(sendRequestResult);
}
m_syncHelper->signalWorkerThread();
}
void ScrollingTree::commitNewTreeState(PassOwnPtr<ScrollingTreeState> scrollingTreeState)
{
ASSERT(ScrollingThread::isCurrentThread());
if (scrollingTreeState->changedProperties() & ScrollingTreeState::WheelEventHandlerCount) {
MutexLocker lock(m_mutex);
m_hasWheelEventHandlers = scrollingTreeState->wheelEventHandlerCount();
}
m_rootNode->update(scrollingTreeState.get());
}
PassOwnPtrWillBeRawPtr<MessagePortArray> MessagePort::entanglePorts(ExecutionContext& context, PassOwnPtr<MessagePortChannelArray> channels)
{
if (!channels || !channels->size())
return nullptr;
OwnPtrWillBeRawPtr<MessagePortArray> portArray = adoptPtrWillBeNoop(new MessagePortArray(channels->size()));
for (unsigned i = 0; i < channels->size(); ++i) {
RefPtrWillBeRawPtr<MessagePort> port = MessagePort::create(context);
port->entangle((*channels)[i].release());
(*portArray)[i] = port.release();
}
return portArray.release();
}
PassOwnPtr<MessagePortArray> MessagePort::entanglePorts(ScriptExecutionContext& context, PassOwnPtr<MessagePortChannelArray> channels)
{
if (!channels || !channels->size())
return 0;
MessagePortArray* portArray = new MessagePortArray(channels->size());
for (unsigned int i = 0; i < channels->size(); ++i) {
RefPtr<MessagePort> port = MessagePort::create(context);
port->entangle((*channels)[i].release());
(*portArray)[i] = port.release();
}
return portArray;
}
void WebWorkerClientImpl::postMessageToWorkerContextTask(ScriptExecutionContext* context,
WebWorkerClientImpl* thisPtr,
const String& message,
PassOwnPtr<MessagePortChannelArray> channels)
{
WebMessagePortChannelArray webChannels(channels.get() ? channels->size() : 0);
for (size_t i = 0; i < webChannels.size(); ++i) {
webChannels[i] = (*channels)[i]->channel()->webChannelRelease();
webChannels[i]->setClient(0);
}
thisPtr->m_webWorker->postMessageToWorkerContext(message, webChannels);
}
bool InspectorHistory::perform(PassOwnPtr<Action> action, ExceptionCode& ec)
{
if (!action->perform(ec))
return false;
if (!action->mergeId().isEmpty() && m_afterLastActionIndex > 0 && action->mergeId() == m_history[m_afterLastActionIndex - 1]->mergeId())
m_history[m_afterLastActionIndex - 1]->merge(action);
else {
m_history.resize(m_afterLastActionIndex);
m_history.append(action);
++m_afterLastActionIndex;
}
return true;
}
void MainThreadTaskRunner::perform(PassOwnPtr<ExecutionContextTask> task, bool isInspectorTask)
{
if (!isInspectorTask && (m_context->tasksNeedSuspension() || !m_pendingTasks.isEmpty())) {
m_pendingTasks.append(task);
return;
}
const bool instrumenting = !isInspectorTask && !task->taskNameForInstrumentation().isEmpty();
if (instrumenting)
InspectorInstrumentation::willPerformExecutionContextTask(m_context, task.get());
task->performTask(m_context);
if (instrumenting)
InspectorInstrumentation::didPerformExecutionContextTask(m_context);
}
void Connection::processIncomingMessage(MessageID messageID, PassOwnPtr<ArgumentDecoder> arguments)
{
// Check if this is a sync reply.
if (messageID == MessageID(CoreIPCMessage::SyncMessageReply)) {
MutexLocker locker(m_syncReplyStateMutex);
ASSERT(!m_pendingSyncReplies.isEmpty());
PendingSyncReply& pendingSyncReply = m_pendingSyncReplies.last();
ASSERT(pendingSyncReply.syncRequestID == arguments->destinationID());
pendingSyncReply.replyDecoder = arguments.leakPtr();
pendingSyncReply.didReceiveReply = true;
m_waitForSyncReplySemaphore.signal();
return;
}
// Check if this is a sync message. If it is, and we're waiting for a sync reply this message
// needs to be dispatched. If we don't we'll end up with a deadlock where both sync message senders are
// stuck waiting for a reply.
if (messageID.isSync()) {
MutexLocker locker(m_syncReplyStateMutex);
if (!m_pendingSyncReplies.isEmpty()) {
m_syncMessagesReceivedWhileWaitingForSyncReply.append(IncomingMessage(messageID, arguments));
// The message has been added, now wake up the client thread.
m_waitForSyncReplySemaphore.signal();
return;
}
}
// Check if we're waiting for this message.
{
MutexLocker locker(m_waitForMessageMutex);
HashMap<std::pair<unsigned, uint64_t>, ArgumentDecoder*>::iterator it = m_waitForMessageMap.find(std::make_pair(messageID.toInt(), arguments->destinationID()));
if (it != m_waitForMessageMap.end()) {
it->second = arguments.leakPtr();
m_waitForMessageCondition.signal();
return;
}
}
MutexLocker locker(m_incomingMessagesLock);
m_incomingMessages.append(IncomingMessage(messageID, arguments));
m_clientRunLoop->scheduleWork(WorkItem::create(this, &Connection::dispatchMessages));
}
void HTMLResourcePreloader::preload(PassOwnPtr<PreloadRequest> preload)
{
Document* executingDocument = m_document->import() ? m_document->import()->master() : m_document;
Document* loadingDocument = m_document;
ASSERT(executingDocument->frame());
ASSERT(executingDocument->renderer());
ASSERT(executingDocument->renderer()->style());
if (!preload->media().isEmpty() && !mediaAttributeMatches(executingDocument->frame(), executingDocument->renderer()->style(), preload->media()))
return;
FetchRequest request = preload->resourceRequest(m_document);
blink::Platform::current()->histogramCustomCounts("WebCore.PreloadDelayMs", static_cast<int>(1000 * (monotonicallyIncreasingTime() - preload->discoveryTime())), 0, 2000, 20);
loadingDocument->fetcher()->preload(preload->resourceType(), request, preload->charset());
}
void WebWorkerBase::postMessageTask(ScriptExecutionContext* context,
WebWorkerBase* thisPtr,
String message,
PassOwnPtr<MessagePortChannelArray> channels)
{
if (!thisPtr->client())
return;
WebMessagePortChannelArray webChannels(channels.get() ? channels->size() : 0);
for (size_t i = 0; i < webChannels.size(); ++i) {
webChannels[i] = (*channels)[i]->channel()->webChannelRelease();
webChannels[i]->setClient(0);
}
thisPtr->client()->postMessageToWorkerObject(message, webChannels);
}
void WebSocketImpl::didReceiveBinaryData(PassOwnPtr<Vector<char> > binaryData)
{
#if ENABLE(WEB_SOCKETS)
switch (m_binaryType) {
case BinaryTypeData:
case BinaryTypeBlob: // FIXME: Handle Blob after supporting WebBlob.
m_client->didReceiveBinaryData(WebData(binaryData->data(), binaryData->size()));
break;
case BinaryTypeArrayBuffer:
m_client->didReceiveArrayBuffer(WebArrayBuffer(ArrayBuffer::create(binaryData->data(), binaryData->size())));
break;
}
#else
ASSERT_NOT_REACHED();
#endif
}
void WebSocket::didReceiveBinaryData(PassOwnPtr<Vector<char>> binaryData)
{
LOG(Network, "WebSocket %p didReceiveBinaryData() %lu byte binary message", this, static_cast<unsigned long>(binaryData->size()));
switch (m_binaryType) {
case BinaryTypeBlob: {
// FIXME: We just received the data from NetworkProcess, and are sending it back. This is inefficient.
RefPtr<Blob> blob = Blob::create(std::move(*binaryData), emptyString());
dispatchEvent(MessageEvent::create(blob.release(), SecurityOrigin::create(m_url)->toString()));
break;
}
case BinaryTypeArrayBuffer:
dispatchEvent(MessageEvent::create(ArrayBuffer::create(binaryData->data(), binaryData->size()), SecurityOrigin::create(m_url)->toString()));
break;
}
}
MediaQuery::MediaQuery(Restrictor r, const String& mediaType, PassOwnPtr<Vector<MediaQueryExp*> > exprs)
: m_restrictor(r)
, m_mediaType(mediaType.lower())
, m_expressions(exprs.release())
, m_ignored(false)
{
if (!m_expressions) {
m_expressions = new Vector<MediaQueryExp*>;
return;
}
std::sort(m_expressions->begin(), m_expressions->end(), expressionCompare);
// remove all duplicated expressions
String key;
for (int i = m_expressions->size() - 1; i >= 0; --i) {
// if not all of the expressions is valid the media query must be ignored.
if (!m_ignored)
m_ignored = !m_expressions->at(i)->isValid();
if (m_expressions->at(i)->serialize() == key) {
MediaQueryExp* item = m_expressions->at(i);
m_expressions->remove(i);
delete item;
} else
key = m_expressions->at(i)->serialize();
}
}
void WebProcessConnection::addPluginControllerProxy(PassOwnPtr<PluginControllerProxy> pluginController)
{
uint64_t pluginInstanceID = pluginController->pluginInstanceID();
ASSERT(!m_pluginControllers.contains(pluginInstanceID));
m_pluginControllers.set(pluginInstanceID, pluginController);
}
WebSocketChannel::SendResult MainThreadWebSocketChannel::send(PassOwnPtr<Vector<char> > data)
{
WTF_LOG(Network, "MainThreadWebSocketChannel %p send() Sending Vector %p", this, data.get());
enqueueVector(WebSocketFrame::OpCodeBinary, data);
processOutgoingFrameQueue();
return WebSocketChannel::SendSuccess;
}
InspectorFrontendClientQt::InspectorFrontendClientQt(QWebPage* inspectedWebPage, PassOwnPtr<QWebView> inspectorView)
: InspectorFrontendClientLocal(inspectedWebPage->d->page->inspectorController(), inspectorView->page()->d->page)
, m_inspectedWebPage(inspectedWebPage)
, m_inspectorView(inspectorView)
, m_destroyingInspectorView(false)
{
}
PassRefPtr<SharedBuffer> SharedBuffer::adoptPurgeableBuffer(PassOwnPtr<PurgeableBuffer> purgeableBuffer)
{
ASSERT(!purgeableBuffer->isPurgeable());
RefPtr<SharedBuffer> buffer = create();
buffer->m_purgeableBuffer = purgeableBuffer;
return buffer.release();
}
DiscardablePixelRef::DiscardablePixelRef(const SkImageInfo& info, size_t rowBytes, PassOwnPtr<SkMutex> mutex)
: SkPixelRef(info, mutex.get())
, m_lockedMemory(0)
, m_mutex(mutex)
, m_rowBytes(rowBytes)
{
}
void StyleKeyframe::setKeys(PassOwnPtr<Vector<double> > keys)
{
ASSERT(keys && !keys->isEmpty());
m_keys = keys;
m_keyText = String();
ASSERT(m_keyText.isNull());
}
void CCThreadProxy::beginFrameCompleteOnImplThread(CCCompletionEvent* completion, PassOwnPtr<CCTextureUpdateQueue> queue, bool contentsTexturesWereDeleted)
{
TRACE_EVENT0("cc", "CCThreadProxy::beginFrameCompleteOnImplThread");
ASSERT(!m_commitCompletionEventOnImplThread);
ASSERT(isImplThread());
ASSERT(m_schedulerOnImplThread);
ASSERT(m_schedulerOnImplThread->commitPending());
if (!m_layerTreeHostImpl) {
TRACE_EVENT0("cc", "EarlyOut_NoLayerTree");
completion->signal();
return;
}
if (!contentsTexturesWereDeleted && m_layerTreeHostImpl->contentsTexturesPurged()) {
// We purged the content textures on the impl thread between the time we
// posted the beginFrame task and now, meaning we have a bunch of
// uploads that are now invalid. Clear the uploads (they all go to
// content textures), and kick another commit to fill them again.
queue->clearUploads();
setNeedsCommitOnImplThread();
} else
m_resetContentsTexturesPurgedAfterCommitOnImplThread = true;
m_currentTextureUpdateControllerOnImplThread = CCTextureUpdateController::create(CCProxy::implThread(), queue, m_layerTreeHostImpl->resourceProvider(), m_layerTreeHostImpl->renderer()->textureCopier(), m_layerTreeHostImpl->renderer()->textureUploader());
m_commitCompletionEventOnImplThread = completion;
m_schedulerOnImplThread->beginFrameComplete();
}
PassOwnPtr<SVGAnimatedType> SVGAnimatedType::createPath(PassOwnPtr<SVGPathByteStream> path)
{
ASSERT(path);
OwnPtr<SVGAnimatedType> animatedType = adoptPtr(new SVGAnimatedType(AnimatedPath));
animatedType->m_data.path = path.leakPtr();
return animatedType.release();
}
void NavigationScheduler::schedule(PassOwnPtr<ScheduledNavigation> redirect)
{
ASSERT(m_frame->page());
Ref<Frame> protect(*m_frame);
// If a redirect was scheduled during a load, then stop the current load.
// Otherwise when the current load transitions from a provisional to a
// committed state, pending redirects may be cancelled.
if (redirect->wasDuringLoad()) {
if (DocumentLoader* provisionalDocumentLoader = m_frame->loader().provisionalDocumentLoader())
provisionalDocumentLoader->stopLoading();
m_frame->loader().stopLoading(UnloadEventPolicyUnloadAndPageHide);
}
cancel();
m_redirect = redirect;
if (!m_frame->loader().isComplete() && m_redirect->isLocationChange())
m_frame->loader().completed();
if (!m_frame->page())
return;
startTimer();
}
PassOwnPtr<AsyncFileWriter> WorkerPlatformAsyncFileSystemCallbacks::createAsyncFileWriter(PassOwnPtr<BlackBerry::Platform::WebFileWriter> platformWriter)
{
ASSERT(m_writerClient);
BlackBerry::Platform::WebFileWriter* platformWriterPtr = platformWriter.get();
OwnPtr<WorkerAsyncFileWriterBlackBerry> writer = WorkerAsyncFileWriterBlackBerry::create(m_context, m_mode, platformWriter, m_writerClient);
platformWriterPtr->setClient(writer->platformWriterClient());
return writer.release();
}
void WebUrlLoaderClient::didFail(PassOwnPtr<WebResponse> webResponse)
{
if (isActive())
m_resourceHandle->client()->didFail(m_resourceHandle.get(), webResponse->createResourceError());
// Always finish a request, if not it will leak
finish();
}
void PlatformMessagePortChannel::postMessageToRemote(PassRefPtr<SerializedScriptValue> message, PassOwnPtr<MessagePortChannelArray> channels)
{
if (!m_localPort || !m_webChannel)
return;
WebKit::WebString messageString = message->toWireString();
WebKit::WebMessagePortChannelArray* webChannels = 0;
if (channels && channels->size()) {
webChannels = new WebKit::WebMessagePortChannelArray(channels->size());
for (size_t i = 0; i < channels->size(); ++i) {
PlatformMessagePortChannel* platformChannel = (*channels)[i]->channel();
(*webChannels)[i] = platformChannel->webChannelRelease();
(*webChannels)[i]->setClient(0);
}
}
m_webChannel->postMessage(messageString, webChannels);
}
void PlatformMessagePortChannel::postMessageToRemote(PassOwnPtr<MessagePortChannel::EventData> message)
{
if (!m_localPort || !m_webChannel)
return;
WebString messageString = message->message()->toWireString();
OwnPtr<WebCore::MessagePortChannelArray> channels = message->channels();
WebMessagePortChannelArray* webChannels = 0;
if (channels.get() && channels->size()) {
webChannels = new WebMessagePortChannelArray(channels->size());
for (size_t i = 0; i < channels->size(); ++i) {
WebCore::PlatformMessagePortChannel* platformChannel = (*channels)[i]->channel();
(*webChannels)[i] = platformChannel->webChannelRelease();
(*webChannels)[i]->setClient(0);
}
}
m_webChannel->postMessage(messageString, webChannels);
}