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