void RTCDataChannel::send(PassRefPtr<DOMArrayBuffer> prpData, ExceptionState& exceptionState)
{
if (m_readyState != ReadyStateOpen) {
throwNotOpenException(exceptionState);
return;
}
RefPtr<DOMArrayBuffer> data = prpData;
size_t dataLength = data->byteLength();
if (!dataLength)
return;
if (!m_handler->sendRawData(static_cast<const char*>((data->data())), dataLength)) {
// FIXME: This should not throw an exception but instead forcefully close the data channel.
throwCouldNotSendDataException(exceptionState);
}
}
void ResourceLoader::didReceiveDataOrBuffer(const char* data, unsigned length, PassRefPtr<SharedBuffer> prpBuffer, long long encodedDataLength, DataPayloadType dataPayloadType)
{
// This method should only get data+length *OR* a SharedBuffer.
ASSERT(!prpBuffer || (!data && !length));
// Protect this in this delegate method since the additional processing can do
// anything including possibly derefing this; one example of this is Radar 3266216.
Ref<ResourceLoader> protect(*this);
RefPtr<SharedBuffer> buffer = prpBuffer;
addDataOrBuffer(data, length, buffer.get(), dataPayloadType);
// FIXME: If we get a resource with more than 2B bytes, this code won't do the right thing.
// However, with today's computers and networking speeds, this won't happen in practice.
// Could be an issue with a giant local file.
if (m_options.sendLoadCallbacks() == SendCallbacks && m_frame)
frameLoader()->notifier().didReceiveData(this, buffer ? buffer->data() : data, buffer ? buffer->size() : length, static_cast<int>(encodedDataLength));
}
PassRefPtr<WebCLBuffer> WebCLContext::createBuffer(unsigned memFlags, unsigned sizeInBytes, DOMArrayBufferView* hostPtr, ExceptionState& es)
{
RefPtr<DOMArrayBuffer> buffer;
if (hostPtr) {
if (hostPtr->byteLength() < sizeInBytes) {
es.throwWebCLException(WebCLException::InvalidHostPtr, WebCLException::invalidHostPTRMessage);
return nullptr;
}
if (!hostPtr->buffer()) {
es.throwWebCLException(WebCLException::InvalidHostPtr, WebCLException::invalidHostPTRMessage);
return nullptr;
}
buffer = hostPtr->buffer();
}
return createBufferBase(memFlags, sizeInBytes, buffer ? buffer->data() : nullptr, es);
}
String WebFrame::source() const
{
if (!m_coreFrame)
return String();
Document* document = m_coreFrame->document();
if (!document)
return String();
TextResourceDecoder* decoder = document->decoder();
if (!decoder)
return String();
DocumentLoader* documentLoader = m_coreFrame->loader().activeDocumentLoader();
if (!documentLoader)
return String();
RefPtr<ResourceBuffer> mainResourceData = documentLoader->mainResourceData();
if (!mainResourceData)
return String();
return decoder->encoding().decode(mainResourceData->data(), mainResourceData->size());
}
TEST(AnimatedWebPTests, truncatedInBetweenFrame) {
std::unique_ptr<ImageDecoder> decoder = createDecoder();
RefPtr<SharedBuffer> fullData =
readFile("/LayoutTests/images/resources/invalid-animated-webp4.webp");
ASSERT_TRUE(fullData.get());
RefPtr<SharedBuffer> data =
SharedBuffer::create(fullData->data(), fullData->size() - 1);
decoder->setData(data.get(), false);
ImageFrame* frame = decoder->frameBufferAtIndex(1);
ASSERT_TRUE(frame);
EXPECT_EQ(ImageFrame::FrameComplete, frame->getStatus());
frame = decoder->frameBufferAtIndex(2);
ASSERT_TRUE(frame);
EXPECT_EQ(ImageFrame::FramePartial, frame->getStatus());
EXPECT_TRUE(decoder->failed());
}
void InspectorResourceAgent::resourceContent(ErrorString* errorString, Frame* frame, const KURL& url, String* result)
{
if (!frame) {
*errorString = "No frame to get resource content for";
return;
}
String textEncodingName;
RefPtr<SharedBuffer> buffer = InspectorResourceAgent::resourceData(frame, url, &textEncodingName);
if (buffer) {
TextEncoding encoding(textEncodingName);
if (!encoding.isValid())
encoding = WindowsLatin1Encoding();
*result = encoding.decode(buffer->data(), buffer->size());
return;
}
*errorString = "No resource with given URL found";
}
PassRefPtr<ArrayBuffer> SharedBuffer::createArrayBuffer() const
{
RefPtr<ArrayBuffer> arrayBuffer = ArrayBuffer::createUninitialized(static_cast<unsigned>(size()), sizeof(char));
const char* segment = 0;
unsigned position = 0;
while (unsigned segmentSize = getSomeData(segment, position)) {
memcpy(static_cast<char*>(arrayBuffer->data()) + position, segment, segmentSize);
position += segmentSize;
}
if (position != arrayBuffer->byteLength()) {
ASSERT_NOT_REACHED();
// Don't return the incomplete ArrayBuffer.
return 0;
}
return arrayBuffer.release();
}
TEST(GIFImageDecoderTest, allDataReceivedTruncation)
{
OwnPtr<GIFImageDecoder> decoder = createDecoder();
RefPtr<SharedBuffer> data = readFile("/LayoutTests/fast/images/resources/animated.gif");
ASSERT_TRUE(data.get());
ASSERT_GE(data->size(), 10u);
RefPtr<SharedBuffer> tempData = SharedBuffer::create(data->data(), data->size() - 10);
decoder->setData(tempData.get(), true);
EXPECT_EQ(2u, decoder->frameCount());
EXPECT_FALSE(decoder->failed());
decoder->frameBufferAtIndex(0);
EXPECT_FALSE(decoder->failed());
decoder->frameBufferAtIndex(1);
EXPECT_TRUE(decoder->failed());
}
/**
* webkit_web_data_source_get_data:
* @data_source: a #WebKitWebDataSource
*
* Returns the raw data that represents the the frame's content.The data will
* be incomplete until the data has finished loading. Returns %NULL if the web
* frame hasn't loaded any data. Use webkit_web_data_source_is_loading to test
* if data source is in the process of loading.
*
* Return value: (transfer none): a #GString which contains the raw
* data that represents the @data_source or %NULL if the @data_source
* hasn't loaded any data.
*
* Since: 1.1.14
*/
GString* webkit_web_data_source_get_data(WebKitWebDataSource* webDataSource)
{
g_return_val_if_fail(WEBKIT_IS_WEB_DATA_SOURCE(webDataSource), NULL);
WebKitWebDataSourcePrivate* priv = webDataSource->priv;
RefPtr<SharedBuffer> mainResourceData = priv->loader->mainResourceData();
if (!mainResourceData)
return NULL;
if (priv->data) {
g_string_free(priv->data, TRUE);
priv->data = NULL;
}
priv->data = g_string_new_len(mainResourceData->data(), mainResourceData->size());
return priv->data;
}
PassRefPtr<ImageData> GraphicsContext3D::paintRenderingResultsToImageData(DrawingBuffer*)
{
// Reading premultiplied alpha would involve unpremultiplying, which is
// lossy.
if (m_attrs.premultipliedAlpha)
return 0;
RefPtr<ImageData> imageData = ImageData::create(IntSize(m_currentWidth, m_currentHeight));
unsigned char* pixels = imageData->data()->data();
int totalBytes = 4 * m_currentWidth * m_currentHeight;
readRenderingResults(pixels, totalBytes);
// Convert to RGBA.
for (int i = 0; i < totalBytes; i += 4)
std::swap(pixels[i], pixels[i + 2]);
return imageData.release();
}
String ImageBuffer::toDataURL(const String& mimeType, const double* quality, CoordinateSystem) const
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
if (context().isAcceleratedContext())
flushContext();
RetainPtr<CFStringRef> uti = utiFromMIMEType(mimeType);
ASSERT(uti);
RefPtr<Uint8ClampedArray> premultipliedData;
RetainPtr<CGImageRef> image;
if (CFEqual(uti.get(), jpegUTI())) {
// JPEGs don't have an alpha channel, so we have to manually composite on top of black.
premultipliedData = getPremultipliedImageData(IntRect(IntPoint(0, 0), logicalSize()));
if (!premultipliedData)
return "data:,";
RetainPtr<CGDataProviderRef> dataProvider;
dataProvider = adoptCF(CGDataProviderCreateWithData(0, premultipliedData->data(), 4 * logicalSize().width() * logicalSize().height(), 0));
if (!dataProvider)
return "data:,";
image = adoptCF(CGImageCreate(logicalSize().width(), logicalSize().height(), 8, 32, 4 * logicalSize().width(),
deviceRGBColorSpaceRef(), kCGBitmapByteOrderDefault | kCGImageAlphaNoneSkipLast,
dataProvider.get(), 0, false, kCGRenderingIntentDefault));
} else if (m_resolutionScale == 1) {
image = copyNativeImage(CopyBackingStore);
image = createCroppedImageIfNecessary(image.get(), internalSize());
} else {
image = copyNativeImage(DontCopyBackingStore);
RetainPtr<CGContextRef> context = adoptCF(CGBitmapContextCreate(0, logicalSize().width(), logicalSize().height(), 8, 4 * logicalSize().width(), deviceRGBColorSpaceRef(), kCGImageAlphaPremultipliedLast));
CGContextSetBlendMode(context.get(), kCGBlendModeCopy);
CGContextClipToRect(context.get(), CGRectMake(0, 0, logicalSize().width(), logicalSize().height()));
FloatSize imageSizeInUserSpace = scaleSizeToUserSpace(logicalSize(), m_data.backingStoreSize, internalSize());
CGContextDrawImage(context.get(), CGRectMake(0, 0, imageSizeInUserSpace.width(), imageSizeInUserSpace.height()), image.get());
image = adoptCF(CGBitmapContextCreateImage(context.get()));
}
return CGImageToDataURL(image.get(), mimeType, quality);
}
void FEDropShadow::platformApplySoftware()
{
FilterEffect* in = inputEffect(0);
ImageBuffer* resultImage = createImageBufferResult();
if (!resultImage)
return;
Filter& filter = this->filter();
FloatSize blurRadius(2 * filter.applyHorizontalScale(m_stdX), 2 * filter.applyVerticalScale(m_stdY));
blurRadius.scale(filter.filterScale());
FloatSize offset(filter.applyHorizontalScale(m_dx), filter.applyVerticalScale(m_dy));
FloatRect drawingRegion = drawingRegionOfInputImage(in->absolutePaintRect());
FloatRect drawingRegionWithOffset(drawingRegion);
drawingRegionWithOffset.move(offset);
ImageBuffer* sourceImage = in->asImageBuffer();
if (!sourceImage)
return;
GraphicsContext& resultContext = resultImage->context();
resultContext.setAlpha(m_shadowOpacity);
resultContext.drawImageBuffer(*sourceImage, drawingRegionWithOffset);
resultContext.setAlpha(1);
ShadowBlur contextShadow(blurRadius, offset, m_shadowColor);
// TODO: Direct pixel access to ImageBuffer would avoid copying the ImageData.
IntRect shadowArea(IntPoint(), resultImage->internalSize());
RefPtr<Uint8ClampedArray> srcPixelArray = resultImage->getPremultipliedImageData(shadowArea, ImageBuffer::BackingStoreCoordinateSystem);
contextShadow.blurLayerImage(srcPixelArray->data(), shadowArea.size(), 4 * shadowArea.size().width());
resultImage->putByteArray(Premultiplied, srcPixelArray.get(), shadowArea.size(), shadowArea, IntPoint(), ImageBuffer::BackingStoreCoordinateSystem);
resultContext.setCompositeOperation(CompositeSourceIn);
resultContext.fillRect(FloatRect(FloatPoint(), absolutePaintRect().size()), m_shadowColor);
resultContext.setCompositeOperation(CompositeDestinationOver);
resultImage->context().drawImageBuffer(*sourceImage, drawingRegion);
}
void FileReaderLoader::didReceiveData(const char* data, int dataLength)
{
ASSERT(data);
ASSERT(dataLength > 0);
// Bail out if we already encountered an error.
if (m_errorCode)
return;
int length = dataLength;
unsigned remainingBufferSpace = m_totalBytes - m_bytesLoaded;
if (length > static_cast<long long>(remainingBufferSpace)) {
// If the buffer has hit maximum size, it can't be grown any more.
if (m_totalBytes >= std::numeric_limits<unsigned>::max()) {
failed(FileError::NOT_READABLE_ERR);
return;
}
if (m_variableLength) {
unsigned long long newLength = m_totalBytes * 2;
if (newLength > std::numeric_limits<unsigned>::max())
newLength = std::numeric_limits<unsigned>::max();
RefPtr<ArrayBuffer> newData =
ArrayBuffer::create(static_cast<unsigned>(newLength), 1);
memcpy(static_cast<char*>(newData->data()), static_cast<char*>(m_rawData->data()), m_bytesLoaded);
m_rawData = newData;
m_totalBytes = static_cast<unsigned>(newLength);
} else
length = remainingBufferSpace;
}
if (length <= 0)
return;
memcpy(static_cast<char*>(m_rawData->data()) + m_bytesLoaded, data, length);
m_bytesLoaded += length;
m_isRawDataConverted = false;
if (m_client)
m_client->didReceiveData();
}
PassRefPtr<Uint8ClampedArray> getImageData(const IntRect& rect, const ImageBufferData& imageData, const IntSize& size)
{
float area = 4.0f * rect.width() * rect.height();
if (area > static_cast<float>(std::numeric_limits<int>::max()))
return 0;
RefPtr<Uint8ClampedArray> result = Uint8ClampedArray::createUninitialized(rect.width() * rect.height() * 4);
QImage::Format format = (multiplied == Unmultiplied) ? QImage::Format_RGBA8888 : QImage::Format_RGBA8888_Premultiplied;
QImage image(result->data(), rect.width(), rect.height(), format);
if (rect.x() < 0 || rect.y() < 0 || rect.maxX() > size.width() || rect.maxY() > size.height())
image.fill(0);
// Let drawImage deal with the conversion.
QPainter p(&image);
p.setCompositionMode(QPainter::CompositionMode_Source);
p.drawImage(QPoint(0,0), imageData.m_impl->toQImage(), rect);
return result.release();
}
TEST(ArrayBufferBuilderTest, ToArrayBuffer)
{
const char data1[] = "HelloWorld";
size_t data1Size = sizeof(data1) - 1;
const char data2[] = "GoodbyeWorld";
size_t data2Size = sizeof(data2) - 1;
ArrayBufferBuilder builder(1024);
builder.append(data1, data1Size);
builder.append(data2, data2Size);
const char expected[] = "HelloWorldGoodbyeWorld";
size_t expectedSize = sizeof(expected) - 1;
RefPtr<ArrayBuffer> result = builder.toArrayBuffer();
ASSERT_EQ(data1Size + data2Size, result->byteLength());
ASSERT_EQ(expectedSize, result->byteLength());
EXPECT_EQ(0, memcmp(expected, result->data(), expectedSize));
}
void RTCDataChannel::send(PassRefPtr<ArrayBuffer> prpData, ExceptionCode& ec)
{
if (m_readyState != ReadyStateOpen) {
ec = INVALID_STATE_ERR;
return;
}
RefPtr<ArrayBuffer> data = prpData;
size_t dataLength = data->byteLength();
if (!dataLength)
return;
const char* dataPointer = static_cast<const char*>(data->data());
if (!m_handler->sendRawData(dataPointer, dataLength)) {
// FIXME: Decide what the right exception here is.
ec = SYNTAX_ERR;
}
}
PassRefPtr<ImageData> ImageData::create(unsigned sw, unsigned sh, ExceptionCode& ec)
{
if (!sw || !sh) {
ec = INDEX_SIZE_ERR;
return nullptr;
}
Checked<int, RecordOverflow> dataSize = 4;
dataSize *= sw;
dataSize *= sh;
if (dataSize.hasOverflowed()) {
ec = TypeError;
return nullptr;
}
IntSize size(sw, sh);
RefPtr<ImageData> data = adoptRef(new ImageData(size));
data->data()->zeroFill();
return data.release();
}
// Reproduce a crash that used to happen for a specific file with specific sequence of method calls.
TEST(AnimatedWebPTests, reproCrash)
{
OwnPtr<WEBPImageDecoder> decoder = createDecoder();
RefPtr<SharedBuffer> fullData = readFile("/LayoutTests/fast/images/resources/invalid_vp8_vp8x.webp");
ASSERT_TRUE(fullData.get());
// Parse partial data up to which error in bitstream is not detected.
const size_t partialSize = 32768;
ASSERT_GT(fullData->size(), partialSize);
RefPtr<SharedBuffer> data = SharedBuffer::create(fullData->data(), partialSize);
decoder->setData(data.get(), false);
EXPECT_EQ(1u, decoder->frameCount());
// Parse full data now. The error in bitstream should now be detected.
decoder->setData(fullData.get(), true);
EXPECT_EQ(0u, decoder->frameCount());
ImageFrame* frame = decoder->frameBufferAtIndex(0);
EXPECT_FALSE(frame);
EXPECT_EQ(cAnimationLoopOnce, decoder->repetitionCount());
}
// This function will be changed to abstract virtual when all filters are landed.
bool FilterEffect::platformApplyOpenCL()
{
if (!FilterContextOpenCL::context())
return false;
unsigned size = m_inputEffects.size();
for (unsigned i = 0; i < size; ++i) {
FilterEffect* in = m_inputEffects.at(i).get();
// Software code path expects that at least one of the following fileds is valid.
if (!in->m_imageBufferResult && !in->m_unmultipliedImageResult && !in->m_premultipliedImageResult)
in->asImageBuffer();
}
platformApplySoftware();
ImageBuffer* sourceImage = asImageBuffer();
if (sourceImage) {
RefPtr<Uint8ClampedArray> sourceImageData = sourceImage->getUnmultipliedImageData(IntRect(IntPoint(), sourceImage->internalSize()));
createOpenCLImageResult(sourceImageData->data());
}
return true;
}
String HTMLCanvasElement::toDataURLInternal(const String& mimeType, const double* quality, bool isSaving) const
{
if (m_size.isEmpty() || !buffer())
return String("data:,");
String encodingMimeType = toEncodingMimeType(mimeType);
// Try to get ImageData first, as that may avoid lossy conversions.
RefPtr<ImageData> imageData = getImageData();
if (imageData)
return ImageDataToDataURL(ImageDataBuffer(imageData->size(), imageData->data()), encodingMimeType, quality);
if (m_context && m_context->is3d()) {
toWebGLRenderingContext(m_context.get())->setSavingImage(isSaving);
m_context->paintRenderingResultsToCanvas();
toWebGLRenderingContext(m_context.get())->setSavingImage(false);
}
return buffer()->toDataURL(encodingMimeType, quality);
}
void SubresourceLoader::didReceiveDataOrBuffer(const char* data, int length, PassRefPtr<SharedBuffer> prpBuffer, long long encodedDataLength, DataPayloadType dataPayloadType)
{
if (m_resource->response().httpStatusCode() >= 400 && !m_resource->shouldIgnoreHTTPStatusCodeErrors())
return;
ASSERT(!m_resource->resourceToRevalidate());
ASSERT(!m_resource->errorOccurred());
ASSERT(m_state == Initialized);
// Reference the object in this method since the additional processing can do
// anything including removing the last reference to this object; one example of this is 3266216.
Ref<SubresourceLoader> protect(*this);
RefPtr<SharedBuffer> buffer = prpBuffer;
ResourceLoader::didReceiveDataOrBuffer(data, length, buffer, encodedDataLength, dataPayloadType);
if (!m_loadingMultipartContent) {
if (ResourceBuffer* resourceData = this->resourceData())
m_resource->addDataBuffer(resourceData);
else
m_resource->addData(buffer ? buffer->data() : data, buffer ? buffer->size() : length);
}
}
void Body::didFinishLoading()
{
if (!executionContext() || executionContext()->activeDOMObjectsAreStopped())
return;
if (m_streamAccessed) {
didFinishLoadingViaStream(m_loader->arrayBufferResult().get());
m_resolver.clear();
m_stream->close();
return;
}
switch (m_responseType) {
case ResponseAsArrayBuffer:
m_resolver->resolve(m_loader->arrayBufferResult());
break;
case ResponseAsBlob: {
ASSERT(blobDataHandle()->size() == kuint64max);
OwnPtr<BlobData> blobData = BlobData::create();
RefPtr<DOMArrayBuffer> buffer = m_loader->arrayBufferResult();
blobData->appendBytes(buffer->data(), buffer->byteLength());
const size_t length = blobData->length();
m_resolver->resolve(Blob::create(BlobDataHandle::create(blobData.release(), length)));
break;
}
case ResponseAsFormData:
ASSERT_NOT_REACHED();
break;
case ResponseAsJSON:
resolveJSON(m_loader->stringResult());
break;
case ResponseAsText:
m_resolver->resolve(m_loader->stringResult());
break;
default:
ASSERT_NOT_REACHED();
}
m_resolver.clear();
m_stream->close();
}
void FECustomFilter::platformApplySoftware()
{
ByteArray* dstPixelArray = createPremultipliedImageResult();
if (!dstPixelArray)
return;
FilterEffect* in = inputEffect(0);
IntRect effectDrawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
RefPtr<ByteArray> srcPixelArray = in->asPremultipliedImage(effectDrawingRect);
IntSize newContextSize(effectDrawingRect.size());
bool hadContext = m_context;
if (!m_context)
initializeContext(newContextSize);
if (!hadContext || m_contextSize != newContextSize)
resizeContext(newContextSize);
// Do not draw the filter if the input image cannot fit inside a single GPU texture.
if (m_inputTexture->tiles().numTilesX() != 1 || m_inputTexture->tiles().numTilesY() != 1)
return;
// The shader had compiler errors. We cannot draw anything.
if (!m_shader->isInitialized())
return;
m_context->clearColor(0, 0, 0, 0);
m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT | GraphicsContext3D::DEPTH_BUFFER_BIT);
bindProgramAndBuffers(srcPixelArray.get());
m_context->drawElements(GraphicsContext3D::TRIANGLES, m_mesh->indicesCount(), GraphicsContext3D::UNSIGNED_SHORT, 0);
m_drawingBuffer->commit();
RefPtr<ImageData> imageData = m_context->paintRenderingResultsToImageData(m_drawingBuffer.get());
ByteArray* gpuResult = imageData->data()->data();
ASSERT(gpuResult->length() == dstPixelArray->length());
memcpy(dstPixelArray->data(), gpuResult->data(), gpuResult->length());
}
void FEDropShadow::platformApplySoftware()
{
FilterEffect* in = inputEffect(0);
ImageBuffer* resultImage = createImageBufferResult();
if (!resultImage)
return;
Filter* filter = this->filter();
FloatSize blurRadius(filter->applyHorizontalScale(m_stdX), filter->applyVerticalScale(m_stdY));
FloatSize offset(filter->applyHorizontalScale(m_dx), filter->applyVerticalScale(m_dy));
FloatRect drawingRegion = drawingRegionOfInputImage(in->absolutePaintRect());
FloatRect drawingRegionWithOffset(drawingRegion);
drawingRegionWithOffset.move(offset);
ImageBuffer* sourceImage = in->asImageBuffer();
ASSERT(sourceImage);
GraphicsContext* resultContext = resultImage->context();
ASSERT(resultContext);
resultContext->setAlpha(m_shadowOpacity);
resultContext->drawImageBuffer(sourceImage, ColorSpaceDeviceRGB, drawingRegionWithOffset);
resultContext->setAlpha(1);
ShadowBlur contextShadow(blurRadius, offset, m_shadowColor, ColorSpaceDeviceRGB);
// TODO: Direct pixel access to ImageBuffer would avoid copying the ImageData.
IntRect shadowArea(IntPoint(), resultImage->size());
RefPtr<ByteArray> srcPixelArray = resultImage->getPremultipliedImageData(shadowArea);
contextShadow.blurLayerImage(srcPixelArray->data(), shadowArea.size(), 4 * shadowArea.size().width());
resultImage->putPremultipliedImageData(srcPixelArray.get(), shadowArea.size(), shadowArea, IntPoint());
resultContext->setCompositeOperation(CompositeSourceIn);
resultContext->fillRect(FloatRect(FloatPoint(), absolutePaintRect().size()), m_shadowColor, ColorSpaceDeviceRGB);
resultContext->setCompositeOperation(CompositeDestinationOver);
resultImage->context()->drawImageBuffer(sourceImage, ColorSpaceDeviceRGB, drawingRegion);
}
const String& Page::userStyleSheet() const
{
if (m_userStyleSheetPath.isEmpty()) {
ASSERT(m_userStyleSheet.isEmpty());
return m_userStyleSheet;
}
time_t modTime;
if (!getFileModificationTime(m_userStyleSheetPath, modTime)) {
// The stylesheet either doesn't exist, was just deleted, or is
// otherwise unreadable. If we've read the stylesheet before, we should
// throw away that data now as it no longer represents what's on disk.
m_userStyleSheet = String();
return m_userStyleSheet;
}
// If the stylesheet hasn't changed since the last time we read it, we can
// just return the old data.
if (m_didLoadUserStyleSheet && modTime <= m_userStyleSheetModificationTime)
return m_userStyleSheet;
m_didLoadUserStyleSheet = true;
m_userStyleSheet = String();
m_userStyleSheetModificationTime = modTime;
// FIXME: It would be better to load this asynchronously to avoid blocking
// the process, but we will first need to create an asynchronous loading
// mechanism that is not tied to a particular Frame. We will also have to
// determine what our behavior should be before the stylesheet is loaded
// and what should happen when it finishes loading, especially with respect
// to when the load event fires, when Document::close is called, and when
// layout/paint are allowed to happen.
RefPtr<SharedBuffer> data = SharedBuffer::createWithContentsOfFile(m_userStyleSheetPath);
if (!data)
return m_userStyleSheet;
m_userStyleSheet = TextResourceDecoder::create("text/css")->decode(data->data(), data->size());
return m_userStyleSheet;
}
void FEColorMatrix::apply()
{
if (hasResult())
return;
FilterEffect* in = inputEffect(0);
in->apply();
if (!in->hasResult())
return;
ImageBuffer* resultImage = createImageBufferResult();
if (!resultImage)
return;
resultImage->context()->drawImageBuffer(in->asImageBuffer(), ColorSpaceDeviceRGB, drawingRegionOfInputImage(in->absolutePaintRect()));
IntRect imageRect(IntPoint(), absolutePaintRect().size());
RefPtr<ImageData> imageData = resultImage->getUnmultipliedImageData(imageRect);
ByteArray* pixelArray = imageData->data()->data();
switch (m_type) {
case FECOLORMATRIX_TYPE_UNKNOWN:
break;
case FECOLORMATRIX_TYPE_MATRIX:
effectType<FECOLORMATRIX_TYPE_MATRIX>(pixelArray, m_values);
break;
case FECOLORMATRIX_TYPE_SATURATE:
effectType<FECOLORMATRIX_TYPE_SATURATE>(pixelArray, m_values);
break;
case FECOLORMATRIX_TYPE_HUEROTATE:
effectType<FECOLORMATRIX_TYPE_HUEROTATE>(pixelArray, m_values);
break;
case FECOLORMATRIX_TYPE_LUMINANCETOALPHA:
effectType<FECOLORMATRIX_TYPE_LUMINANCETOALPHA>(pixelArray, m_values);
setIsAlphaImage(true);
break;
}
resultImage->putUnmultipliedImageData(imageData.get(), imageRect, IntPoint());
}
String InspectorResource::sourceString() const
{
if (!m_xmlHttpResponseText.isNull())
return String(m_xmlHttpResponseText);
RefPtr<SharedBuffer> buffer;
String textEncodingName;
if (m_requestURL == m_loader->requestURL()) {
buffer = m_loader->mainResourceData();
textEncodingName = m_frame->document()->inputEncoding();
} else {
CachedResource* cachedResource = m_frame->document()->docLoader()->cachedResource(requestURL());
if (!cachedResource)
return String();
if (cachedResource->isPurgeable()) {
// If the resource is purgeable then make it unpurgeable to get
// get its data. This might fail, in which case we return an
// empty String.
// FIXME: should we do something else in the case of a purged
// resource that informs the user why there is no data in the
// inspector?
if (!cachedResource->makePurgeable(false))
return String();
}
buffer = cachedResource->data();
textEncodingName = cachedResource->encoding();
}
if (!buffer)
return String();
TextEncoding encoding(textEncodingName);
if (!encoding.isValid())
encoding = WindowsLatin1Encoding();
return encoding.decode(buffer->data(), buffer->size());
}
bool InspectorPageAgent::cachedResourceContent(CachedResource* cachedResource, String* result, bool* base64Encoded)
{
bool hasZeroSize;
bool prepared = prepareCachedResourceBuffer(cachedResource, &hasZeroSize);
if (!prepared)
return false;
ResourceType type = cachedResourceType(*cachedResource);
*base64Encoded = type != StylesheetResource && type != ScriptResource;
if (*base64Encoded) {
RefPtr<SharedBuffer> buffer = hasZeroSize ? SharedBuffer::create() : cachedResource->data();
if (!buffer)
return false;
*result = base64Encode(buffer->data(), buffer->size());
return true;
}
if (cachedResource) {
switch (cachedResource->type()) {
case CachedResource::CSSStyleSheet:
*result = static_cast<CachedCSSStyleSheet*>(cachedResource)->sheetText();
return true;
case CachedResource::Script:
*result = static_cast<CachedScript*>(cachedResource)->script();
return true;
default:
if (hasZeroSize) {
*result = "";
return true;
}
return decodeSharedBuffer(cachedResource->data(), cachedResource->encoding(), result);
}
}
return false;
}
void WebResourceLoadStatisticsStore::writeEncoderToDisk(KeyedEncoder& encoder, const String& label) const
{
RefPtr<SharedBuffer> rawData = encoder.finishEncoding();
if (!rawData)
return;
String resourceLog = persistentStoragePath(label);
if (resourceLog.isEmpty())
return;
if (!m_storagePath.isEmpty())
makeAllDirectories(m_storagePath);
auto handle = openFile(resourceLog, OpenForWrite);
if (!handle)
return;
int64_t writtenBytes = writeToFile(handle, rawData->data(), rawData->size());
closeFile(handle);
if (writtenBytes != static_cast<int64_t>(rawData->size()))
WTFLogAlways("WebResourceLoadStatisticsStore: We only wrote %d out of %d bytes to disk", static_cast<unsigned>(writtenBytes), rawData->size());
}
PassRefPtr<ImageData> ImageData::create(unsigned width, unsigned height, ExceptionState& exceptionState)
{
if (!RuntimeEnabledFeatures::imageDataConstructorEnabled()) {
exceptionState.throwTypeError("Illegal constructor");
return nullptr;
}
if (!width || !height) {
exceptionState.throwDOMException(IndexSizeError, String::format("The source %s is zero or not a number.", width ? "height" : "width"));
return nullptr;
}
Checked<unsigned, RecordOverflow> dataSize = 4;
dataSize *= width;
dataSize *= height;
if (dataSize.hasOverflowed()) {
exceptionState.throwDOMException(IndexSizeError, "The requested image size exceeds the supported range.");
return nullptr;
}
RefPtr<ImageData> imageData = adoptRef(new ImageData(IntSize(width, height)));
imageData->data()->zeroFill();
return imageData.release();
}
