void effectType(const PassRefPtr<CanvasPixelArray>& srcPixelArray, PassRefPtr<ImageData>& imageData, const Vector<float>& values) { for (unsigned pixelOffset = 0; pixelOffset < srcPixelArray->length(); pixelOffset++) { unsigned pixelByteOffset = pixelOffset * 4; unsigned char r = 0, g = 0, b = 0, a = 0; srcPixelArray->get(pixelByteOffset, r); srcPixelArray->get(pixelByteOffset + 1, g); srcPixelArray->get(pixelByteOffset + 2, b); srcPixelArray->get(pixelByteOffset + 3, a); double red = r, green = g, blue = b, alpha = a; switch (filterType) { case FECOLORMATRIX_TYPE_MATRIX: matrix(red, green, blue, alpha, values); break; case FECOLORMATRIX_TYPE_SATURATE: saturate(red, green, blue, values[0]); break; case FECOLORMATRIX_TYPE_HUEROTATE: huerotate(red, green, blue, values[0]); break; case FECOLORMATRIX_TYPE_LUMINANCETOALPHA: luminance(red, green, blue, alpha); break; } imageData->data()->set(pixelByteOffset, red); imageData->data()->set(pixelByteOffset + 1, green); imageData->data()->set(pixelByteOffset + 2, blue); imageData->data()->set(pixelByteOffset + 3, alpha); } }
PassRefPtr<ImageData> ImageBufferData::getImageData(const IntRect& rect, const IntSize& size, VGImageFormat format) const { ASSERT(m_surface); PassRefPtr<ImageData> result = ImageData::create(rect.width(), rect.height()); unsigned char* data = result->data()->data()->data(); // If this copy operation won't fill all of the pixels in the target image, // paint it black in order to avoid random uninitialized pixel garbage. if (rect.x() < 0 || rect.y() < 0 || (rect.right()) > size.width() || (rect.bottom()) > size.height()) memset(data, 0, result->data()->length()); if (!m_tiledImage) m_surface->makeCurrent(); // OpenVG ignores pixels that are out of bounds, so we can just // call vgReadPixels() without any further safety assurances. if (m_surface->isCurrent()) { vgReadPixels(data, rect.width() * 4, format, rect.x(), rect.y(), rect.width(), rect.height()); } else { vgGetImageSubData(m_tiledImage->tile(0, 0), data, rect.width() * 4, format, rect.x(), rect.y(), rect.width(), rect.height()); } ASSERT_VG_NO_ERROR(); return result; }
PassRefPtr<ImageData> getImageData(const IntRect& rect, const ImageBufferData& data, const IntSize& size) { ASSERT(cairo_surface_get_type(data.m_surface) == CAIRO_SURFACE_TYPE_IMAGE); PassRefPtr<ImageData> result = ImageData::create(rect.width(), rect.height()); unsigned char* dataSrc = cairo_image_surface_get_data(data.m_surface); unsigned char* dataDst = result->data()->data()->data(); if (rect.x() < 0 || rect.y() < 0 || (rect.x() + rect.width()) > size.width() || (rect.y() + rect.height()) > size.height()) memset(dataDst, 0, result->data()->length()); int originx = rect.x(); int destx = 0; if (originx < 0) { destx = -originx; originx = 0; } int endx = rect.x() + rect.width(); if (endx > size.width()) endx = size.width(); int numColumns = endx - originx; int originy = rect.y(); int desty = 0; if (originy < 0) { desty = -originy; originy = 0; } int endy = rect.y() + rect.height(); if (endy > size.height()) endy = size.height(); int numRows = endy - originy; int stride = cairo_image_surface_get_stride(data.m_surface); unsigned destBytesPerRow = 4 * rect.width(); unsigned char* destRows = dataDst + desty * destBytesPerRow + destx * 4; for (int y = 0; y < numRows; ++y) { unsigned* row = reinterpret_cast<unsigned*>(dataSrc + stride * (y + originy)); for (int x = 0; x < numColumns; x++) { int basex = x * 4; unsigned* pixel = row + x + originx; Color pixelColor; if (multiplied == Unmultiplied) pixelColor = colorFromPremultipliedARGB(*pixel); else pixelColor = Color(*pixel); destRows[basex] = pixelColor.red(); destRows[basex + 1] = pixelColor.green(); destRows[basex + 2] = pixelColor.blue(); destRows[basex + 3] = pixelColor.alpha(); } destRows += destBytesPerRow; } return result; }
PassRefPtr<ImageData> ImageBuffer::getImageData(const IntRect& rect) const { if (!m_data) return 0; PassRefPtr<ImageData> result = ImageData::create(rect.width(), rect.height()); unsigned char* data = result->data()->data().data(); if (rect.x() < 0 || rect.y() < 0 || (rect.x() + rect.width()) > m_size.width() || (rect.y() + rect.height()) > m_size.height()) memset(data, 0, result->data()->length()); int originx = rect.x(); int destx = 0; if (originx < 0) { destx = -originx; originx = 0; } int endx = rect.x() + rect.width(); if (endx > m_size.width()) endx = m_size.width(); int numColumns = endx - originx; int originy = rect.y(); int desty = 0; if (originy < 0) { desty = -originy; originy = 0; } int endy = rect.y() + rect.height(); if (endy > m_size.height()) endy = m_size.height(); int numRows = endy - originy; unsigned srcBytesPerRow = 4 * m_size.width(); unsigned destBytesPerRow = 4 * rect.width(); unsigned char* srcRows = reinterpret_cast<unsigned char*>(m_data) + originy * srcBytesPerRow + originx * 4; unsigned char* destRows = data + desty * destBytesPerRow + destx * 4; for (int y = 0; y < numRows; ++y) { for (int x = 0; x < numColumns; x++) { int basex = x * 4; if (unsigned char alpha = srcRows[basex + 3]) { destRows[basex] = (srcRows[basex] * 255) / alpha; destRows[basex + 1] = (srcRows[basex + 1] * 255) / alpha; destRows[basex + 2] = (srcRows[basex + 2] * 255) / alpha; destRows[basex + 3] = alpha; } else { reinterpret_cast<uint32_t*>(destRows + basex)[0] = reinterpret_cast<uint32_t*>(srcRows + basex)[0]; } } srcRows += srcBytesPerRow; destRows += destBytesPerRow; } return result; }
PassRefPtr<ImageData> ImageBuffer::getImageData(const IntRect& rect) const { PassRefPtr<ImageData> result = ImageData::create(rect.width(), rect.height()); unsigned char* data = result->data()->data()->data(); if (rect.x() < 0 || rect.y() < 0 || (rect.x() + rect.width()) > m_size.width() || (rect.y() + rect.height()) > m_size.height()) memset(data, 0, result->data()->length()); int originx = rect.x(); int destx = 0; if (originx < 0) { destx = -originx; originx = 0; } int endx = rect.x() + rect.width(); if (endx > m_size.width()) endx = m_size.width(); int numColumns = endx - originx; int originy = rect.y(); int desty = 0; if (originy < 0) { desty = -originy; originy = 0; } int endy = rect.y() + rect.height(); if (endy > m_size.height()) endy = m_size.height(); int numRows = endy - originy; QImage image = m_data.m_pixmap.toImage().convertToFormat(QImage::Format_ARGB32); ASSERT(!image.isNull()); unsigned destBytesPerRow = 4 * rect.width(); unsigned char* destRows = data + desty * destBytesPerRow + destx * 4; for (int y = 0; y < numRows; ++y) { for (int x = 0; x < numColumns; x++) { QRgb value = image.pixel(x + originx, y + originy); int basex = x * 4; destRows[basex] = qRed(value); destRows[basex + 1] = qGreen(value); destRows[basex + 2] = qBlue(value); destRows[basex + 3] = qAlpha(value); } destRows += destBytesPerRow; } return result; }
template <bool premultiplied> PassRefPtr<ImageData> static getImageData(const IntRect& rect, const SharedBitmap* bitmap) { PassRefPtr<ImageData> imageData = ImageData::create(rect.width(), rect.height()); const unsigned char* src = static_cast<const unsigned char*>(bitmap->bytes()); if (!src) return imageData; IntRect sourceRect(0, 0, bitmap->width(), bitmap->height()); sourceRect.intersect(rect); if (sourceRect.isEmpty()) return imageData; unsigned char* dst = imageData->data()->data()->data(); memset(dst, 0, imageData->data()->data()->length()); src += (sourceRect.y() * bitmap->width() + sourceRect.x()) * 4; dst += ((sourceRect.y() - rect.y()) * imageData->width() + sourceRect.x() - rect.x()) * 4; int bytesToCopy = sourceRect.width() * 4; int srcSkip = (bitmap->width() - sourceRect.width()) * 4; int dstSkip = (imageData->width() - sourceRect.width()) * 4; const unsigned char* dstEnd = dst + sourceRect.height() * imageData->width() * 4; while (dst < dstEnd) { const unsigned char* dstRowEnd = dst + bytesToCopy; while (dst < dstRowEnd) { // Convert ARGB little endian to RGBA big endian int blue = *src++; int green = *src++; int red = *src++; int alpha = *src++; if (premultiplied) { *dst++ = static_cast<unsigned char>((red * alpha + 254) / 255); *dst++ = static_cast<unsigned char>((green * alpha + 254) / 255); *dst++ = static_cast<unsigned char>((blue * alpha + 254) / 255); *dst++ = static_cast<unsigned char>(alpha); } else { *dst++ = static_cast<unsigned char>(red); *dst++ = static_cast<unsigned char>(green); *dst++ = static_cast<unsigned char>(blue); *dst++ = static_cast<unsigned char>(alpha); ++src; } } src += srcSkip; dst += dstSkip; } return imageData; }
void HTMLMediaElementEncryptedMedia::generateKeyRequest(WebMediaPlayer* webMediaPlayer, const String& keySystem, PassRefPtr<DOMUint8Array> initData, ExceptionState& exceptionState) { WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::webkitGenerateKeyRequest"); if (!setEmeMode(EmeModePrefixed)) { exceptionState.throwDOMException(InvalidStateError, "Mixed use of EME prefixed and unprefixed API not allowed."); return; } if (keySystem.isEmpty()) { exceptionState.throwDOMException(SyntaxError, "The key system provided is empty."); return; } if (!webMediaPlayer) { exceptionState.throwDOMException(InvalidStateError, "No media has been loaded."); return; } const unsigned char* initDataPointer = 0; unsigned initDataLength = 0; if (initData) { initDataPointer = initData->data(); initDataLength = initData->length(); } WebMediaPlayer::MediaKeyException result = webMediaPlayer->generateKeyRequest(keySystem, initDataPointer, initDataLength); throwExceptionIfMediaKeyExceptionOccurred(keySystem, String(), result, exceptionState); }
void WebKitSourceBuffer::append(PassRefPtr<Uint8Array> data, ExceptionCode& ec) { // SourceBuffer.append() steps from October 1st version of the Media Source Extensions spec. // https://dvcs.w3.org/hg/html-media/raw-file/7bab66368f2c/media-source/media-source.html#dom-append // 2. If data is null then throw an INVALID_ACCESS_ERR exception and abort these steps. if (!data) { ec = INVALID_ACCESS_ERR; return; } // 3. If this object has been removed from the sourceBuffers attribute of media source then throw // an INVALID_STATE_ERR exception and abort these steps. if (isRemoved()) { ec = INVALID_STATE_ERR; return; } // 5. If the readyState attribute of media source is in the "ended" state then run the following steps: // 5.1. Set the readyState attribute of media source to "open" // 5.2. Queue a task to fire a simple event named sourceopen at media source. openIfInEndedState(); // Steps 6 & beyond are handled by the private implementation. m_private->append(data->data(), data->length()); }
void CachedRawResource::data(PassRefPtr<ResourceBuffer> data, bool allDataReceived) { CachedResourceHandle<CachedRawResource> protect(this); const char* incrementalData = 0; size_t incrementalDataLength = 0; if (data) { // If we are buffering data, then we are saving the buffer in m_data and need to manually // calculate the incremental data. If we are not buffering, then m_data will be null and // the buffer contains only the incremental data. size_t previousDataLength = (m_options.dataBufferingPolicy == BufferData) ? encodedSize() : 0; ASSERT(data->size() >= previousDataLength); incrementalData = data->data() + previousDataLength; incrementalDataLength = data->size() - previousDataLength; } if (m_options.dataBufferingPolicy == BufferData) { if (data) setEncodedSize(data->size()); m_data = data; } DataBufferingPolicy dataBufferingPolicy = m_options.dataBufferingPolicy; if (incrementalDataLength) { CachedResourceClientWalker<CachedRawResourceClient> w(m_clients); while (CachedRawResourceClient* c = w.next()) c->dataReceived(this, incrementalData, incrementalDataLength); } CachedResource::data(m_data, allDataReceived); if (dataBufferingPolicy == BufferData && m_options.dataBufferingPolicy == DoNotBufferData) { if (m_loader) m_loader->setDataBufferingPolicy(DoNotBufferData); clear(); } }
PassRefPtr<FontFace> FontFace::create(ExecutionContext* context, const AtomicString& family, PassRefPtr<ArrayBuffer> source, const Dictionary& descriptors, ExceptionState& exceptionState) { RefPtr<FontFace> fontFace = adoptRefWillBeRefCountedGarbageCollected<FontFace>(new FontFace()); if (initFontFace(fontFace.get(), context, family, descriptors, exceptionState)) fontFace->initCSSFontFace(static_cast<const unsigned char*>(source->data()), source->byteLength()); return fontFace.release(); }
void SourceBuffer::appendBuffer(PassRefPtr<DOMArrayBuffer> data, ExceptionState& exceptionState) { WTF_LOG(Media, "SourceBuffer(%p)::appendBuffer size=%u", this, data->byteLength()); // Section 3.2 appendBuffer() // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-SourceBuffer-appendBuffer-void-ArrayBufferView-data appendBufferInternal(static_cast<const unsigned char*>(data->data()), data->byteLength(), exceptionState); }
void WebKitSourceBuffer::append(PassRefPtr<Uint8Array> data, ExceptionState& es) { TRACE_EVENT0("media", "SourceBuffer::append"); // SourceBuffer.append() steps from October 1st version of the Media Source Extensions spec. // https://dvcs.w3.org/hg/html-media/raw-file/7bab66368f2c/media-source/media-source.html#dom-append // 2. If data is null then throw an InvalidAccessError exception and abort these steps. if (!data) { es.throwUninformativeAndGenericDOMException(InvalidAccessError); return; } // 3. If this object has been removed from the sourceBuffers attribute of media source then throw // an InvalidStateError exception and abort these steps. if (isRemoved()) { es.throwUninformativeAndGenericDOMException(InvalidStateError); return; } // 5. If the readyState attribute of media source is in the "ended" state then run the following steps: // 5.1. Set the readyState attribute of media source to "open" // 5.2. Queue a task to fire a simple event named sourceopen at media source. m_source->openIfInEndedState(); // Steps 6 & beyond are handled by the private implementation. m_private->append(data->data(), data->length()); }
void NetscapePlugInStreamLoader::didReceiveDataOrBuffer(const char* data, int length, PassRefPtr<SharedBuffer> buffer, long long encodedDataLength, DataPayloadType dataPayloadType) { Ref<NetscapePlugInStreamLoader> protect(*this); m_client->didReceiveData(this, buffer ? buffer->data() : data, buffer ? buffer->size() : length); ResourceLoader::didReceiveDataOrBuffer(data, length, buffer, encodedDataLength, dataPayloadType); }
// static bool InspectorPageAgent::sharedBufferContent(PassRefPtr<SharedBuffer> buffer, const String& textEncodingName, bool withBase64Encode, String* result) { if (withBase64Encode) { *result = base64Encode(buffer->data(), buffer->size()); return true; } return decodeSharedBuffer(buffer, textEncodingName, result); }
JSArrayBufferView::ConstructionContext::ConstructionContext( Structure* structure, PassRefPtr<ArrayBuffer> arrayBuffer, unsigned byteOffset, unsigned length, DataViewTag) : m_structure(structure) , m_vector(static_cast<uint8_t*>(arrayBuffer->data()) + byteOffset) , m_length(length) , m_mode(DataViewMode) , m_butterfly(0) { }
Deprecated::ScriptValue deserializeIDBValueBuffer(DOMRequestState* requestState, PassRefPtr<SharedBuffer> prpBuffer, bool keyIsDefined) { if (prpBuffer) { Vector<uint8_t> value; value.append(prpBuffer->data(), prpBuffer->size()); return deserializeIDBValueBuffer(requestState->exec(), value, keyIsDefined); } return Deprecated::ScriptValue(requestState->exec()->vm(), jsNull()); }
void WebPlatformStrategies::setBufferForType(PassRefPtr<SharedBuffer> buffer, const String& pasteboardType, const String& pasteboardName) { SharedMemory::Handle handle; if (buffer) { RefPtr<SharedMemory> sharedMemoryBuffer = SharedMemory::create(buffer->size()); memcpy(sharedMemoryBuffer->data(), buffer->data(), buffer->size()); sharedMemoryBuffer->createHandle(handle, SharedMemory::ReadOnly); } WebProcess::shared().connection()->send(Messages::WebContext::SetPasteboardBufferForType(pasteboardName, pasteboardType, handle, buffer ? buffer->size() : 0), 0); }
v8::Handle<v8::Object> V8ArrayBuffer::createWrapper(PassRefPtr<ArrayBuffer> impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate) { ASSERT(impl.get()); ASSERT(!DOMDataStore::containsWrapper<V8ArrayBuffer>(impl.get(), isolate)); v8::Handle<v8::Object> wrapper = v8::ArrayBuffer::New(isolate, impl->data(), impl->byteLength()); impl->setDeallocationObserver(V8ArrayBufferDeallocationObserver::instanceTemplate()); V8DOMWrapper::associateObjectWithWrapper<V8ArrayBuffer>(impl, &wrapperTypeInfo, wrapper, isolate); return wrapper; }
static bool decodeSharedBuffer(PassRefPtr<SharedBuffer> buffer, const String& textEncodingName, String* result) { if (buffer) { TextEncoding encoding(textEncodingName); if (!encoding.isValid()) encoding = WindowsLatin1Encoding(); *result = encoding.decode(buffer->data(), buffer->size()); return true; } return false; }
JSArrayBufferView::ConstructionContext::ConstructionContext( VM& vm, Structure* structure, PassRefPtr<ArrayBuffer> arrayBuffer, unsigned byteOffset, unsigned length) : m_structure(structure) , m_vector(static_cast<uint8_t*>(arrayBuffer->data()) + byteOffset) , m_length(length) , m_mode(WastefulTypedArray) { IndexingHeader indexingHeader; indexingHeader.setArrayBuffer(arrayBuffer.get()); m_butterfly = Butterfly::create(vm, 0, 0, 0, true, indexingHeader, 0); }
void SourceBuffer::appendBuffer(PassRefPtr<ArrayBuffer> data, ExceptionState& es) { // Section 3.2 appendBuffer() // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-SourceBuffer-appendBuffer-void-ArrayBufferView-data // 1. If data is null then throw an InvalidAccessError exception and abort these steps. if (!data) { es.throwDOMException(InvalidAccessError); return; } appendBufferInternal(static_cast<const unsigned char*>(data->data()), data->byteLength(), es); }
long WebPlatformStrategies::setBufferForType(PassRefPtr<SharedBuffer> buffer, const String& pasteboardType, const String& pasteboardName) { SharedMemory::Handle handle; if (buffer) { RefPtr<SharedMemory> sharedMemoryBuffer = SharedMemory::create(buffer->size()); memcpy(sharedMemoryBuffer->data(), buffer->data(), buffer->size()); sharedMemoryBuffer->createHandle(handle, SharedMemory::ReadOnly); } uint64_t newChangeCount; WebProcess::shared().parentProcessConnection()->sendSync(Messages::WebContext::SetPasteboardBufferForType(pasteboardName, pasteboardType, handle, buffer ? buffer->size() : 0), Messages::WebContext::SetPasteboardBufferForType::Reply(newChangeCount), 0); return newChangeCount; }
void CachedResource::tryReplaceEncodedData(PassRefPtr<SharedBuffer> newBuffer) { if (!m_data) return; if (!mayTryReplaceEncodedData()) return; ASSERT(m_data->size() == newBuffer->size()); ASSERT(!memcmp(m_data->data(), newBuffer->data(), m_data->size())); m_data->tryReplaceSharedBufferContents(newBuffer.get()); }
long WebPlatformStrategies::setBufferForType(PassRefPtr<SharedBuffer> buffer, const String& pasteboardType, const String& pasteboardName) { SharedMemory::Handle handle; if (buffer) { RefPtr<SharedMemory> sharedMemoryBuffer = SharedMemory::create(buffer->size()); // FIXME: Null check prevents crashing, but it is not great that we will have empty pasteboard content for this type, // because we've already set the types. if (sharedMemoryBuffer) { memcpy(sharedMemoryBuffer->data(), buffer->data(), buffer->size()); sharedMemoryBuffer->createHandle(handle, SharedMemory::ReadOnly); } } uint64_t newChangeCount; WebProcess::singleton().parentProcessConnection()->sendSync(Messages::WebPasteboardProxy::SetPasteboardBufferForType(pasteboardName, pasteboardType, handle, buffer ? buffer->size() : 0), Messages::WebPasteboardProxy::SetPasteboardBufferForType::Reply(newChangeCount), 0); return newChangeCount; }
void SpellChecker::requestCheckingFor(PassRefPtr<SpellCheckRequest> request) { if (!request || !canCheckAsynchronously(request->paragraphRange().get())) return; ASSERT(request->data().sequence() == unrequestedTextCheckingSequence); int sequence = ++m_lastRequestSequence; if (sequence == unrequestedTextCheckingSequence) sequence = ++m_lastRequestSequence; request->setCheckerAndSequence(this, sequence); if (m_timerToProcessQueuedRequest.isActive() || m_processingRequest) { enqueueRequest(request); return; } invokeRequest(request); }
void MediaSource::append(const String& id, PassRefPtr<Uint8Array> data, ExceptionCode& ec) { if (!data.get()) { ec = INVALID_ACCESS_ERR; return; } if (!m_player || m_readyState == closedKeyword()) { ec = INVALID_STATE_ERR; return; } if (m_readyState == endedKeyword()) setReadyState(openKeyword()); if (!m_player->sourceAppend(id, data->data(), data->length())) { ec = SYNTAX_ERR; return; } }
void NetworkResourceLoader::didReceiveBuffer(ResourceHandle* handle, PassRefPtr<SharedBuffer> buffer, int encodedDataLength) { ASSERT_UNUSED(handle, handle == m_handle); // FIXME (NetworkProcess): For the memory cache we'll also need to cache the response data here. // Such buffering will need to be thread safe, as this callback is happening on a background thread. m_bytesReceived += buffer->size(); #if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090 ShareableResource::Handle shareableResourceHandle; tryGetShareableHandleFromSharedBuffer(shareableResourceHandle, buffer.get()); if (!shareableResourceHandle.isNull()) { // Since we're delivering this resource by ourselves all at once, we'll abort the resource handle since we don't need anymore callbacks from ResourceHandle. abortInProgressLoad(); send(Messages::WebResourceLoader::DidReceiveResource(shareableResourceHandle, currentTime())); return; } #endif // __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090 CoreIPC::DataReference dataReference(reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size()); sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedDataLength)); }
static bool saveArchiveResource(xmlTextWriterPtr writer, PassRefPtr<ArchiveResource> resource) { int result = xmlTextWriterStartElement(writer, archiveResourceTag); if (result < 0) { LOGD("saveArchiveResource: Failed to start element."); return false; } if (!saveArchiveResourceField(writer, urlFieldTag, resource->url().string()) || !saveArchiveResourceField(writer, mimeFieldTag, resource->mimeType()) || !saveArchiveResourceField(writer, encodingFieldTag, resource->textEncoding()) || !saveArchiveResourceField(writer, frameFieldTag, resource->frameName()) || !saveArchiveResourceField(writer, dataFieldTag, resource->data())) return false; result = xmlTextWriterEndElement(writer); if (result < 0) { LOGD("saveArchiveResource: Failed to end element."); return false; } return true; }
void HTMLFormElement::scheduleFormSubmission(PassRefPtr<FormSubmission> submission) { ASSERT(submission->method() == FormSubmission::PostMethod || submission->method() == FormSubmission::GetMethod); ASSERT(submission->data()); ASSERT(submission->state()); if (submission->action().isEmpty()) return; if (document().isSandboxed(SandboxForms)) { // FIXME: This message should be moved off the console once a solution to https://bugs.webkit.org/show_bug.cgi?id=103274 exists. document().addConsoleMessage(SecurityMessageSource, ErrorMessageLevel, "Blocked form submission to '" + submission->action().elidedString() + "' because the form's frame is sandboxed and the 'allow-forms' permission is not set."); return; } if (protocolIsJavaScript(submission->action())) { if (!document().contentSecurityPolicy()->allowFormAction(KURL(submission->action()))) return; document().frame()->script().executeScriptIfJavaScriptURL(submission->action()); return; } Frame* targetFrame = document().frame()->loader().findFrameForNavigation(submission->target(), submission->state()->sourceDocument()); if (!targetFrame) { if (!DOMWindow::allowPopUp(document().frame()) && !UserGestureIndicator::processingUserGesture()) return; targetFrame = document().frame(); } else { submission->clearTarget(); } if (!targetFrame->page()) return; submission->setReferrer(document().frame()->loader().outgoingReferrer()); submission->setOrigin(document().frame()->loader().outgoingOrigin()); targetFrame->navigationScheduler().scheduleFormSubmission(submission); }
// static bool InspectorPageAgent::sharedBufferContent(PassRefPtr<SharedBuffer> buffer, const String& textEncodingName, bool withBase64Encode, String* result) { return dataContent(buffer ? buffer->data() : 0, buffer ? buffer->size() : 0, textEncodingName, withBase64Encode, result); }