TEST(ImageResourceTest, CancelOnDetach) {
KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
ScopedRegisteredURL scopedRegisteredURL(testURL);
ResourceFetcher* fetcher =
ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
// Emulate starting a real load.
ImageResource* cachedImage = ImageResource::create(ResourceRequest(testURL));
cachedImage->setIdentifier(createUniqueIdentifier());
fetcher->startLoad(cachedImage);
memoryCache()->add(cachedImage);
Persistent<MockImageResourceClient> client =
new MockImageResourceClient(cachedImage);
EXPECT_EQ(Resource::Pending, cachedImage->getStatus());
// The load should still be alive, but a timer should be started to cancel the
// load inside removeClient().
client->removeAsClient();
EXPECT_EQ(Resource::Pending, cachedImage->getStatus());
EXPECT_TRUE(memoryCache()->resourceForURL(testURL));
// Trigger the cancel timer, ensure the load was cancelled and the resource
// was evicted from the cache.
blink::testing::runPendingTasks();
EXPECT_EQ(Resource::LoadError, cachedImage->getStatus());
EXPECT_FALSE(memoryCache()->resourceForURL(testURL));
}
void ImageDocumentParser::finish()
{
if (!isStopped() && document()->imageElement() && document()->cachedImage()) {
ImageResource* cachedImage = document()->cachedImage();
cachedImage->finish();
cachedImage->setResponse(document()->frame()->loader().documentLoader()->response());
// Report the natural image size in the page title, regardless of zoom level.
// At a zoom level of 1 the image is guaranteed to have an integer size.
IntSize size = flooredIntSize(cachedImage->imageSizeForLayoutObject(document()->imageElement()->layoutObject(), 1.0f));
if (size.width()) {
// Compute the title, we use the decoded filename of the resource, falling
// back on the (decoded) hostname if there is no path.
String fileName = decodeURLEscapeSequences(document()->url().lastPathComponent());
if (fileName.isEmpty())
fileName = document()->url().host();
document()->setTitle(imageTitle(fileName, size));
}
document()->imageUpdated();
}
if (document())
document()->finishedParsing();
}
void PaintChatWindow::on_pushButtonClear_clicked()
{
//käse tut ned, vermutlich wegen gleichen timestamps
/*
// not the best way to reset the image, because it causes the entire image to be transmitted
// first overwrite with black
ui->paintWidget->fillImage(Qt::black);
updateImage();
// then with white
ui->paintWidget->fillImage(Qt::white);
updateImage();
*/
// andere Lösung:
// sendet viele bytes, weil resource unkomprimiert ist
// tut nicht, vielleicht zu große items?
ui->paintWidget->fillImage(Qt::white);
ImageResource res;
res.fromQImage(ui->paintWidget->getImage());
paintChatService->init(peerId,res);
paintChatService->sendInit(peerId,res);
}
bool HTMLImageElement::wouldTaintOrigin(SecurityOrigin* destinationSecurityOrigin) const
{
ImageResource* image = cachedImage();
if (!image)
return false;
return !image->isAccessAllowed(destinationSecurityOrigin);
}
void ImageLoader::setImageWithoutConsideringPendingLoadEvent(ImageResource* newImage)
{
ASSERT(m_failedLoadURL.isEmpty());
ImageResource* oldImage = m_image.get();
if (newImage != oldImage) {
sourceImageChanged();
m_image = newImage;
if (m_hasPendingBeforeLoadEvent) {
beforeLoadEventSender().cancelEvent(this);
m_hasPendingBeforeLoadEvent = false;
}
if (m_hasPendingLoadEvent) {
loadEventSender().cancelEvent(this);
m_hasPendingLoadEvent = false;
}
if (m_hasPendingErrorEvent) {
errorEventSender().cancelEvent(this);
m_hasPendingErrorEvent = false;
}
m_imageComplete = true;
if (newImage)
newImage->addClient(this);
if (oldImage)
oldImage->removeClient(this);
}
if (RenderImageResource* imageResource = renderImageResource())
imageResource->resetAnimation();
}
void ImageLoader::setImageWithoutConsideringPendingLoadEvent(
ImageResource* newImage) {
DCHECK(m_failedLoadURL.isEmpty());
ImageResource* oldImage = m_image.get();
if (newImage != oldImage) {
m_image = newImage;
if (m_hasPendingLoadEvent) {
loadEventSender().cancelEvent(this);
m_hasPendingLoadEvent = false;
}
if (m_hasPendingErrorEvent) {
errorEventSender().cancelEvent(this);
m_hasPendingErrorEvent = false;
}
m_imageComplete = true;
if (newImage) {
newImage->addObserver(this);
}
if (oldImage) {
oldImage->removeObserver(this);
}
}
if (LayoutImageResource* imageResource = layoutImageResource())
imageResource->resetAnimation();
}
PassRefPtr<AnimatableValue> AnimatableImage::interpolateTo(const AnimatableValue* value, double fraction) const
{
if (fraction <= 0 || fraction >= 1)
return defaultInterpolateTo(this, value, fraction);
RefPtr<CSSValue> fromValue = toCSSValue();
// FIXME: Once cross-fade works on generated image types, remove this check.
if (fromValue->isImageGeneratorValue())
return defaultInterpolateTo(this, value, fraction);
if (!fromValue->isImageValue() && !fromValue->isImageGeneratorValue()) {
if (!m_image->isImageResource())
return defaultInterpolateTo(this, value, fraction);
ImageResource* resource = static_cast<ImageResource*>(m_image->data());
fromValue = CSSImageValue::create(resource->url(), m_image.get());
}
const AnimatableImage* image = toAnimatableImage(value);
RefPtr<CSSValue> toValue = image->toCSSValue();
// FIXME: Once cross-fade works on generated image types, remove this check.
if (toValue->isImageGeneratorValue())
return defaultInterpolateTo(this, value, fraction);
if (!toValue->isImageValue() && !toValue->isImageGeneratorValue()) {
if (!image->m_image->isImageResource())
return defaultInterpolateTo(this, value, fraction);
ImageResource* resource = static_cast<ImageResource*>(image->m_image->data());
toValue = CSSImageValue::create(resource->url(), image->m_image.get());
}
RefPtr<CSSCrossfadeValue> crossfadeValue = CSSCrossfadeValue::create(fromValue, toValue);
crossfadeValue->setPercentage(CSSPrimitiveValue::create(fraction, CSSPrimitiveValue::CSS_NUMBER));
return create(StyleGeneratedImage::create(crossfadeValue.get()).get());
}
void ImageDocumentParser::finish()
{
if (!isStopped() && document()->imageElement() && document()->cachedImage()) {
ImageResource* cachedImage = document()->cachedImage();
DocumentLoader* loader = document()->loader();
cachedImage->setResponse(loader->response());
cachedImage->setLoadFinishTime(loader->timing().responseEnd());
cachedImage->finish();
// Report the natural image size in the page title, regardless of zoom level.
// At a zoom level of 1 the image is guaranteed to have an integer size.
IntSize size = flooredIntSize(cachedImage->imageSizeForLayoutObject(document()->imageElement()->layoutObject(), 1.0f));
if (size.width()) {
// Compute the title, we use the decoded filename of the resource, falling
// back on the (decoded) hostname if there is no path.
String fileName = decodeURLEscapeSequences(document()->url().lastPathComponent());
if (fileName.isEmpty())
fileName = document()->url().host();
document()->setTitle(imageTitle(fileName, size));
}
document()->imageUpdated();
}
// TODO(esprehn): These null checks on Document don't make sense, document()
// will ASSERT if it was null. Do these want to check isDetached() ?
if (document())
document()->finishedParsing();
}
TEST(ImageResourceTest, CancelOnDetach)
{
KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
URLTestHelpers::registerMockedURLLoad(testURL, "cancelTest.html", "text/html");
ResourceFetcher* fetcher = ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
// Emulate starting a real load.
ImageResource* cachedImage = ImageResource::create(ResourceRequest(testURL));
cachedImage->setIdentifier(createUniqueIdentifier());
fetcher->startLoad(cachedImage);
memoryCache()->add(cachedImage);
Persistent<MockImageResourceClient> client = new MockImageResourceClient(cachedImage);
EXPECT_EQ(Resource::Pending, cachedImage->getStatus());
// The load should still be alive, but a timer should be started to cancel the load inside removeClient().
client->removeAsClient();
EXPECT_EQ(Resource::Pending, cachedImage->getStatus());
EXPECT_NE(reinterpret_cast<Resource*>(0), memoryCache()->resourceForURL(testURL));
// Trigger the cancel timer, ensure the load was cancelled and the resource was evicted from the cache.
blink::testing::runPendingTasks();
EXPECT_EQ(Resource::LoadError, cachedImage->getStatus());
EXPECT_EQ(reinterpret_cast<Resource*>(0), memoryCache()->resourceForURL(testURL));
Platform::current()->getURLLoaderMockFactory()->unregisterURL(testURL);
}
FloatSize HTMLImageElement::elementSize() const
{
ImageResource* image = cachedImage();
if (!image)
return FloatSize();
return FloatSize(image->imageSizeForLayoutObject(layoutObject(), 1.0f));
}
static bool containerSizeIsSetForLayoutObject(ImageResource& cachedImage, const LayoutObject* layoutObject)
{
const Image* image = cachedImage.image();
// If a container size has been specified for this layoutObject, then
// imageForLayoutObject() will return the SVGImageForContainer while image()
// will return the underlying SVGImage.
return !image->isSVGImage() || image != cachedImage.imageForLayoutObject(layoutObject);
}
FloatSize HTMLImageElement::sourceSize() const
{
ImageResource* image = cachedImage();
if (!image)
return FloatSize();
LayoutSize size;
size = image->imageSizeForRenderer(renderer(), 1.0f); // FIXME: Not sure about this.
return size;
}
RenderBox* RenderImage::embeddedContentBox() const
{
if (!m_imageResource)
return 0;
ImageResource* cachedImage = m_imageResource->cachedImage();
if (cachedImage && cachedImage->image() && cachedImage->image()->isSVGImage())
return static_cast<SVGImage*>(cachedImage->image())->embeddedContentBox();
return 0;
}
/**
* Returns an image resource.
*
* @param fileName The filename of the image.
*
* @return The image.
*
* @throw ResourceNotLoadedExcpetion
*/
ImageResource* ResourceManager::image(std::string fileName) {
std::string id = ImageResource::createID(fileName);
if (!hasResource(id)) {
ImageResource* res = ImageResource::open(fileName);
insertResource(res->getName(), res);
return res;
} else {
return static_cast<ImageResource*>(getResource(id));
}
}
void LayoutSVGImage::updateImageContainerSize()
{
ImageResource* cachedImage = m_imageResource->cachedImage();
if (!cachedImage || !cachedImage->usesImageContainerSize())
return;
FloatSize imageViewportSize = computeImageViewportSize(*cachedImage);
if (LayoutSize(imageViewportSize) != m_imageResource->imageSize(styleRef().effectiveZoom())
|| !containerSizeIsSetForLayoutObject(*cachedImage, this)) {
m_imageResource->setContainerSizeForLayoutObject(roundedIntSize(imageViewportSize));
}
}
LayoutBox* LayoutImage::embeddedContentBox() const
{
if (!m_imageResource)
return nullptr;
ImageResource* cachedImage = m_imageResource->cachedImage();
if (cachedImage && cachedImage->image() && cachedImage->image()->isSVGImage())
return toSVGImage(cachedImage->image())->embeddedContentBox();
return nullptr;
}
bool checkShapeImageOrigin(Document& document, ImageResource& imageResource)
{
if (imageResource.isAccessAllowed(document.securityOrigin()))
return true;
const KURL& url = imageResource.url();
String urlString = url.isNull() ? "''" : url.elidedString();
document.addConsoleMessage(SecurityMessageSource, ErrorMessageLevel, "Unsafe attempt to load URL " + urlString + ".");
return false;
}
FloatSize HTMLImageElement::defaultDestinationSize() const
{
ImageResource* image = cachedImage();
if (!image)
return FloatSize();
LayoutSize size;
size = image->imageSizeForLayoutObject(layoutObject(), 1.0f);
if (layoutObject() && layoutObject()->isLayoutImage() && image->image() && !image->image()->hasRelativeWidth())
size.scale(toLayoutImage(layoutObject())->imageDevicePixelRatio());
return FloatSize(size);
}
FloatSize HTMLImageElement::defaultDestinationSize() const
{
ImageResource* image = cachedImage();
if (!image)
return FloatSize();
LayoutSize size;
size = image->imageSizeForRenderer(renderer(), 1.0f); // FIXME: Not sure about this.
if (renderer() && renderer()->isRenderImage() && image->image() && !image->image()->hasRelativeWidth())
size.scale(toRenderImage(renderer())->imageDevicePixelRatio());
return size;
}
void PaintChatWindow::updateImage(){
if(paintChatService->receivedInit(peerId)){
ui->paintWidget->fillImage(Qt::white);
ImageResource res;
res.fromQImage(ui->paintWidget->getImage());
paintChatService->init(peerId,res);
}else{
ImageResource res;
res.fromQImage(ui->paintWidget->getImage());
ui->paintWidget->setImage(paintChatService->update(peerId,res).toQImage());
}
}
void HTMLImageLoader::notifyFinished(Resource*)
{
ImageResource* cachedImage = image();
RefPtr<Element> element = this->element();
ImageLoader::notifyFinished(cachedImage);
bool loadError = cachedImage->errorOccurred() || cachedImage->response().httpStatusCode() >= 400;
if (loadError && element->hasTagName(HTMLNames::objectTag))
toHTMLObjectElement(element)->renderFallbackContent();
}
void ImageLoader::updateFromElement(UpdateFromElementBehavior updateBehavior,
ReferrerPolicy referrerPolicy) {
AtomicString imageSourceURL = m_element->imageSourceURL();
m_suppressErrorEvents = (updateBehavior == UpdateSizeChanged);
if (updateBehavior == UpdateIgnorePreviousError)
clearFailedLoadURL();
if (!m_failedLoadURL.isEmpty() && imageSourceURL == m_failedLoadURL)
return;
// Prevent the creation of a ResourceLoader (and therefore a network request)
// for ImageDocument loads. In this case, the image contents have already been
// requested as a main resource and ImageDocumentParser will take care of
// funneling the main resource bytes into m_image, so just create an
// ImageResource to be populated later.
if (m_loadingImageDocument && updateBehavior != UpdateForcedReload) {
setImage(
ImageResource::create(imageSourceToKURL(m_element->imageSourceURL())));
m_image->setStatus(Resource::Pending);
return;
}
// If we have a pending task, we have to clear it -- either we're now loading
// immediately, or we need to reset the task's state.
if (m_pendingTask) {
m_pendingTask->clearLoader();
m_pendingTask.reset();
}
KURL url = imageSourceToKURL(imageSourceURL);
if (shouldLoadImmediately(url)) {
doUpdateFromElement(DoNotBypassMainWorldCSP, updateBehavior, url,
referrerPolicy);
return;
}
// Allow the idiom "img.src=''; img.src='.." to clear down the image before an
// asynchronous load completes.
if (imageSourceURL.isEmpty()) {
ImageResource* image = m_image.get();
if (image) {
image->removeObserver(this);
}
m_image = nullptr;
}
// Don't load images for inactive documents. We don't want to slow down the
// raw HTML parsing case by loading images we don't intend to display.
Document& document = m_element->document();
if (document.isActive())
enqueueImageLoadingMicroTask(updateBehavior, referrerPolicy);
}
ImageResource *ResourceManager::requestImage(const QString &path)
{
QUrl url = resolve(path);
ImageResource *image = find<ImageResource>(url);
if (!image) {
image = new ImageResource(url, this);
mResources.insert(url, image);
mResourceListModel->addResource(image);
}
image->incRef();
return image;
}
/**
* Returns an image resource. The image will be scaled and rotated.
*
* @param fileName The filename of the image.
* @param width The width of the image.
* @param height The height of the image.
* @param keepRatio True if to keep the aspect ratio of the original image.
* It is possible that the width or height of the image will be less than the given values.
* @param angle The angle of the rotation (in degrees).
*
* @return The image.
*
* @throw ResourceNotLoadedExcpetion
*/
ImageResource* ResourceManager::image(std::string fileName, int width,
int height, bool keepRatio, int angle) {
std::string id = ImageResource::createID(fileName, width, height, keepRatio, angle);
if (!hasResource(id)) {
ImageResource* res = image(fileName);
ImageResource* scaled = res->scaleAndRotate(width, height, keepRatio, angle);
free(res);
insertResource(scaled->getName(), scaled);
return scaled;
} else {
return static_cast<ImageResource*>(getResource(id));
}
}
TEST(ImageResourceTest, SVGImage) {
KURL url(ParsedURLString, "http://127.0.0.1:8000/foo");
ImageResource* imageResource = ImageResource::create(ResourceRequest(url));
Persistent<MockImageResourceClient> client =
new MockImageResourceClient(imageResource);
receiveResponse(imageResource, url, "image/svg+xml", svgImage());
EXPECT_FALSE(imageResource->errorOccurred());
ASSERT_TRUE(imageResource->hasImage());
EXPECT_FALSE(imageResource->getImage()->isNull());
EXPECT_EQ(1, client->imageChangedCount());
EXPECT_TRUE(client->notifyFinishedCalled());
EXPECT_FALSE(imageResource->getImage()->isBitmapImage());
}
void CSSImageValue::restoreCachedResourceIfNeeded(Document& document) const
{
if (m_isCachePending || !m_cachedImage || !document.fetcher())
return;
if (document.fetcher()->cachedResource(KURL(ParsedURLString, m_absoluteURL)))
return;
ImageResource* resource = m_cachedImage->cachedImage();
if (!resource)
return;
FetchRequest request(ResourceRequest(m_absoluteURL), m_initiatorName.isEmpty() ? FetchInitiatorTypeNames::css : m_initiatorName, resource->options());
MixedContentChecker::shouldBlockFetch(document.frame(), resource->lastResourceRequest(),
resource->lastResourceRequest().url(), MixedContentChecker::SendReport);
document.fetcher()->requestLoadStarted(resource, request, ResourceFetcher::ResourceLoadingFromCache);
}
void MCommonPixmaps::clear()
{
// release all most used pixmaps
foreach(const PixmapIdentifier & id, mostUsedPixmaps) {
if (toLoadList.contains(id))
continue;
ImageResource *resource = daemon->findImageResource(id.imageId);
resource->releasePixmap(id.size);
}
cpuMonitor.stop();
mostUsedPixmaps.clear();
toLoadList.clear();
requestCounts.clear();
minRequestsForCache = 0;
}
int main(int argc, char *argv[])
{
ImageIO reader("texture.dds");
const auto result = reader.read();
// if (!result.first) ...
const auto &contents = result.second;
for (int index = 0; index < contents.header().imageCount(); ++index) { // read array
for (int level = 0; level < contents.header().mipmapCount(); ++level) { // read mipmaps
ImageResource resource = contents.resource(index, level);
if (resource.type() == ImageResource::Type::Image) {
const QImage image = resource.image();
// ...
} else if (resource.type() == ImageResource::Type::CubeTexture) {
CubeTexture texture = resource.cubeTexture();
// ...
} else if (resource.type() == ImageResource::Type::VolumeTexture) {
VolumeTexture texture = resource.volumeTexture();
// ...
}
}
}
ImageExifMeta exif = contents.exifMeta();
if (!exif.isEmpty()) {
// ...
}
return 0;
}
TEST(ImageResourceTest, CancelOnDecodeError) {
KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
ScopedRegisteredURL scopedRegisteredURL(testURL);
ResourceFetcher* fetcher =
ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
FetchRequest request(testURL, FetchInitiatorInfo());
ImageResource* cachedImage = ImageResource::fetch(request, fetcher);
cachedImage->loader()->didReceiveResponse(
nullptr, WrappedResourceResponse(ResourceResponse(
testURL, "image/jpeg", 18, nullAtom, String())),
nullptr);
cachedImage->loader()->didReceiveData(nullptr, "notactuallyanimage", 18, 18,
18);
EXPECT_EQ(Resource::DecodeError, cachedImage->getStatus());
EXPECT_FALSE(cachedImage->isLoading());
}
static void writeImageToDataObject(DataObject* dataObject, Element* element, const KURL& url)
{
// Shove image data into a DataObject for use as a file
ImageResource* cachedImage = getImageResource(element);
if (!cachedImage || !cachedImage->imageForLayoutObject(element->layoutObject()) || !cachedImage->isLoaded())
return;
SharedBuffer* imageBuffer = cachedImage->imageForLayoutObject(element->layoutObject())->data();
if (!imageBuffer || !imageBuffer->size())
return;
String imageExtension = cachedImage->image()->filenameExtension();
ASSERT(!imageExtension.isEmpty());
// Determine the filename for the file contents of the image.
String filename = cachedImage->response().suggestedFilename();
if (filename.isEmpty())
filename = url.lastPathComponent();
String fileExtension;
if (filename.isEmpty()) {
filename = element->getAttribute(HTMLNames::altAttr);
} else {
// Strip any existing extension. Assume that alt text is usually not a filename.
int extensionIndex = filename.reverseFind('.');
if (extensionIndex != -1) {
fileExtension = filename.substring(extensionIndex + 1);
filename.truncate(extensionIndex);
}
}
if (!fileExtension.isEmpty() && fileExtension != imageExtension) {
String imageMimeType = MIMETypeRegistry::getMIMETypeForExtension(imageExtension);
ASSERT(imageMimeType.startsWith("image/"));
// Use the file extension only if it has imageMimeType: it's untrustworthy otherwise.
if (imageMimeType == MIMETypeRegistry::getMIMETypeForExtension(fileExtension))
imageExtension = fileExtension;
}
imageExtension = "." + imageExtension;
validateFilename(filename, imageExtension);
dataObject->addSharedBuffer(filename + imageExtension, imageBuffer);
}
