void CanvasRenderingContext2D::drawImage(HTMLImageElement* image, const FloatRect& srcRect, const FloatRect& dstRect, ExceptionCode& ec) { ASSERT(image); ec = 0; FloatRect imageRect = FloatRect(FloatPoint(), size(image)); if (!(imageRect.contains(srcRect) && srcRect.width() >= 0 && srcRect.height() >= 0 && dstRect.width() >= 0 && dstRect.height() >= 0)) { ec = INDEX_SIZE_ERR; return; } if (srcRect.isEmpty() || dstRect.isEmpty()) return; GraphicsContext* c = drawingContext(); if (!c) return; CachedImage* cachedImage = image->cachedImage(); if (!cachedImage) return; if (m_canvas->originClean()) checkOrigin(KURL(cachedImage->url())); FloatRect sourceRect = c->roundToDevicePixels(srcRect); FloatRect destRect = c->roundToDevicePixels(dstRect); willDraw(destRect); c->drawImage(cachedImage->image(), destRect, sourceRect, state().m_globalComposite); }
// FIXME: Why isn't this just another overload of drawImage? Why have a different name? void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement* image, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, const String& compositeOperation) { if (!image) return; CachedImage* cachedImage = image->cachedImage(); if (!cachedImage) return; if (m_canvas->originClean()) checkOrigin(KURL(cachedImage->url())); GraphicsContext* c = drawingContext(); if (!c) return; CompositeOperator op; if (!parseCompositeOperator(compositeOperation, op)) op = CompositeSourceOver; FloatRect destRect = FloatRect(dx, dy, dw, dh); willDraw(destRect); c->drawImage(cachedImage->image(), destRect, FloatRect(sx, sy, sw, sh), op); }
FixedBackgroundImageLayerAndroid::FixedBackgroundImageLayerAndroid(PassRefPtr<RenderStyle> aStyle, int w, int h) : LayerAndroid((RenderLayer*)0) , m_width(w) , m_height(h) { RefPtr<RenderStyle> style = aStyle; FillLayer* layers = style->accessBackgroundLayers(); StyleImage* styleImage = layers->image(); CachedImage* cachedImage = static_cast<StyleCachedImage*>(styleImage)->cachedImage(); WebCore::Image* image = cachedImage->image(); setContentsImage(image->nativeImageForCurrentFrame()); setSize(image->width(), image->height()); setIntrinsicallyComposited(true); SkLength left, top; left = SkLength::convertLength(style->backgroundXPosition()); top = SkLength::convertLength(style->backgroundYPosition()); BackgroundImagePositioning* position = new BackgroundImagePositioning(this); position->setRepeatX(style->backgroundRepeatX() != WebCore::NoRepeatFill); position->setRepeatY(style->backgroundRepeatY() != WebCore::NoRepeatFill); setFixedPosition(position); position->setPosition(left, top); #ifdef DEBUG_COUNT ClassTracker::instance()->increment("FixedBackgroundImageLayerAndroid"); #endif }
static void writeImageToDataObject( DataObjectJava* dataObject, Element* element, const KURL& url) { // Shove image data into a DataObject for use as a file CachedImage* cachedImage = getCachedImage(element); if (!cachedImage || !cachedImage->image() || !cachedImage->isLoaded()) return; SharedBuffer* imageBuffer = cachedImage->image()->data(); if (!imageBuffer || !imageBuffer->size()) return; dataObject->fileContent = imageBuffer; // Determine the filename for the file contents of the image. We try to // use the alt tag if one exists, otherwise we fall back on the suggested // filename in the http header, and finally we resort to using the filename // in the URL. //String title = element->getAttribute(altAttr); //if (title.isEmpty()) // title = cachedImage->response().suggestedFilename(); //TODO: do we need it? dataObject->fileContentFilename = cachedImage->response().suggestedFilename(); }
// FIXME: Why isn't this just another overload of drawImage? Why have a different name? void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement* image, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, const String& compositeOperation) { if (!image) return; CachedImage* cachedImage = image->cachedImage(); if (!cachedImage) return; GraphicsContext* c = drawingContext(); if (!c) return; CompositeOperator op; if (!parseCompositeOperator(compositeOperation, op)) op = CompositeSourceOver; FloatRect destRect = FloatRect(dx, dy, dw, dh); willDraw(destRect); #ifdef __OWB__ c->drawImage(cachedImage->image()->nativeImageForCurrentFrame(), destRect, FloatRect(sx, sy, sw, sh), op); cachedImage->image()->startAnimation(); #else c->drawImage(cachedImage->image(), destRect, FloatRect(sx, sy, sw, sh), op); #endif //__OWB__ }
// FIXME: Why isn't this just another overload of drawImage? Why have a different name? void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement* image, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, const String& compositeOperation) { if (!image) return; CachedImage* cachedImage = image->cachedImage(); if (!cachedImage) return; if (m_canvas->originClean()) checkOrigin(cachedImage->response().url()); if (m_canvas->originClean() && !cachedImage->image()->hasSingleSecurityOrigin()) m_canvas->setOriginTainted(); GraphicsContext* c = drawingContext(); if (!c) return; if (!state().m_invertibleCTM) return; CompositeOperator op; if (!parseCompositeOperator(compositeOperation, op)) op = CompositeSourceOver; FloatRect destRect = FloatRect(dx, dy, dw, dh); willDraw(destRect); c->drawImage(cachedImage->image(), destRect, FloatRect(sx, sy, sw, sh), op); }
void PageSerializer::retrieveResourcesForCSSDeclaration(CSSStyleDeclaration* styleDeclaration) { if (!styleDeclaration) return; if (!styleDeclaration->stylesheet()->isCSSStyleSheet()) return; CSSStyleSheet* cssStyleSheet = static_cast<CSSStyleSheet*>(styleDeclaration->stylesheet()); // The background-image and list-style-image (for ul or ol) are the CSS properties // that make use of images. We iterate to make sure we include any other // image properties there might be. for (unsigned i = 0; i < styleDeclaration->length(); ++i) { // FIXME: It's kind of ridiculous to get the property name and then get // the value out of the name. Ideally we would get the value out of the // property ID, but CSSStyleDeclaration only gives access to property // names, not IDs. RefPtr<CSSValue> cssValue = styleDeclaration->getPropertyCSSValue(styleDeclaration->item(i)); if (!cssValue->isImageValue()) continue; CSSImageValue* imageValue = static_cast<CSSImageValue*>(cssValue.get()); StyleImage* styleImage = imageValue->cachedOrPendingImage(); // Non cached-images are just place-holders and do not contain data. if (!styleImage || !styleImage->isCachedImage()) continue; CachedImage* image = static_cast<StyleCachedImage*>(styleImage)->cachedImage(); KURL url = cssStyleSheet->document()->completeURL(image->url()); addImageToResources(image, url); } }
LayoutUnit RenderImage::computeReplacedLogicalWidth(bool includeMaxWidth) const { // If we've got an explicit width/height assigned, propagate it to the image resource. if (style()->logicalWidth().isFixed() && style()->logicalHeight().isFixed()) { LayoutUnit width = RenderReplaced::computeReplacedLogicalWidth(includeMaxWidth); m_imageResource->setContainerSizeForRenderer(IntSize(width, computeReplacedLogicalHeight())); return width; } IntSize containerSize; if (m_imageResource->imageHasRelativeWidth() || m_imageResource->imageHasRelativeHeight()) { // Propagate the containing block size to the image resource, otherwhise we can't compute our own intrinsic size, if it's relative. RenderObject* containingBlock = isPositioned() ? container() : this->containingBlock(); if (containingBlock->isBox()) { RenderBox* box = toRenderBox(containingBlock); containerSize = IntSize(box->availableWidth(), box->availableHeight()); // Already contains zooming information. } } else { // Propagate the current zoomed image size to the image resource, otherwhise the image size will remain the same on-screen. CachedImage* cachedImage = m_imageResource->cachedImage(); if (cachedImage && cachedImage->image()) { containerSize = cachedImage->image()->size(); // FIXME: Remove unnecessary rounding when layout is off ints: webkit.org/b/63656 containerSize.setWidth(static_cast<LayoutUnit>(containerSize.width() * style()->effectiveZoom())); containerSize.setHeight(static_cast<LayoutUnit>(containerSize.height() * style()->effectiveZoom())); } } if (!containerSize.isEmpty()) { m_imageResource->setContainerSizeForRenderer(containerSize); const_cast<RenderImage*>(this)->updateIntrinsicSizeIfNeeded(containerSize, false); } return RenderReplaced::computeReplacedLogicalWidth(includeMaxWidth); }
void Pasteboard::writeImage(Node* node, const KURL&, const String& title) { ASSERT(node); if (!(node->renderer() && node->renderer()->isImage())) return; RenderImage* renderer = toRenderImage(node->renderer()); CachedImage* cachedImage = renderer->cachedImage(); if (!cachedImage || cachedImage->errorOccurred()) return; Image* image = cachedImage->imageForRenderer(renderer); ASSERT(image); GtkClipboard* clipboard = gtk_clipboard_get_for_display(gdk_display_get_default(), GDK_SELECTION_CLIPBOARD); DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard); KURL url = getURLForImageNode(node); if (!url.isEmpty()) { dataObject->setURL(url, title); dataObject->setMarkup(createMarkup(static_cast<Element*>(node), IncludeNode, 0, ResolveAllURLs)); } GRefPtr<GdkPixbuf> pixbuf = adoptGRef(image->getGdkPixbuf()); dataObject->setImage(pixbuf.get()); PasteboardHelper::defaultPasteboardHelper()->writeClipboardContents(clipboard); }
void ImageLoader::setImageWithoutConsideringPendingLoadEvent(CachedImage* newImage) { ASSERT(m_failedLoadURL.isEmpty()); CachedImage* oldImage = m_image.get(); if (newImage != oldImage) { 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 PageSerializer::retrieveResourcesForProperties(const StyleProperties* styleDeclaration, Document* document) { if (!styleDeclaration) return; // The background-image and list-style-image (for ul or ol) are the CSS properties // that make use of images. We iterate to make sure we include any other // image properties there might be. unsigned propertyCount = styleDeclaration->propertyCount(); for (unsigned i = 0; i < propertyCount; ++i) { RefPtr<CSSValue> cssValue = styleDeclaration->propertyAt(i).value(); if (!cssValue->isImageValue()) continue; StyleImage* styleImage = toCSSImageValue(cssValue.get())->cachedOrPendingImage(); // Non cached-images are just place-holders and do not contain data. if (!styleImage || !styleImage->isCachedImage()) continue; CachedImage* image = toStyleCachedImage(styleImage)->cachedImage(); URL url = document->completeURL(image->url()); addImageToResources(image, 0, url); } }
void Pasteboard::writeImage(Node* node, const KURL&, const String& title) { ASSERT(node); ASSERT(node->renderer()); ASSERT(node->renderer()->isImage()); RenderImage* renderer = static_cast<RenderImage*>(node->renderer()); CachedImage* cachedImage = static_cast<CachedImage*>(renderer->cachedImage()); ASSERT(cachedImage); Image* image = cachedImage->image(); ASSERT(image); // If the image is wrapped in a link, |url| points to the target of the // link. This isn't useful to us, so get the actual image URL. AtomicString urlString; if (node->hasTagName(HTMLNames::imgTag) || node->hasTagName(HTMLNames::inputTag)) urlString = static_cast<Element*>(node)->getAttribute(HTMLNames::srcAttr); #if ENABLE(SVG) else if (node->hasTagName(SVGNames::imageTag)) urlString = static_cast<Element*>(node)->getAttribute(XLinkNames::hrefAttr); #endif else if (node->hasTagName(HTMLNames::embedTag) || node->hasTagName(HTMLNames::objectTag)) { Element* element = static_cast<Element*>(node); urlString = element->getAttribute(element->imageSourceAttributeName()); } KURL url = urlString.isEmpty() ? KURL() : node->document()->completeURL(parseURL(urlString)); NativeImageSkia* bitmap = 0; #if !PLATFORM(CG) bitmap = image->nativeImageForCurrentFrame(); #endif ChromiumBridge::clipboardWriteImage(bitmap, url, title); }
void ImageTokenizer::finish() { if (!m_parserStopped && m_doc->imageElement()) { CachedImage* cachedImage = m_doc->cachedImage(); RefPtr<SharedBuffer> data = m_doc->frame()->loader()->documentLoader()->mainResourceData(); // If this is a multipart image, make a copy of the current part, since the resource data // will be overwritten by the next part. if (m_doc->frame()->loader()->documentLoader()->isLoadingMultipartContent()) data = data->copy(); cachedImage->data(data.release(), true); cachedImage->finish(); cachedImage->setResponse(m_doc->frame()->loader()->documentLoader()->response()); IntSize size = cachedImage->imageSize(m_doc->frame()->pageZoomFactor()); 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(m_doc->url().lastPathComponent()); if (fileName.isEmpty()) fileName = m_doc->url().host(); m_doc->setTitle(imageTitle(fileName, size)); } m_doc->imageChanged(); } m_doc->finishedParsing(); }
void Pasteboard::writeImage(Node* node, const KURL&, const String&) { ASSERT(node); if (!(node->renderer() && node->renderer()->isImage())) return; RenderImage* renderer = static_cast<RenderImage*>(node->renderer()); CachedImage* cachedImage = static_cast<CachedImage*>(renderer->cachedImage()); ASSERT(cachedImage); Image* image = cachedImage->imageForRenderer(renderer); ASSERT(image); clear(); RefPtr<SharedBitmap> sourceBmp = image->nativeImageForCurrentFrame(); if (!sourceBmp) return; IntRect rect(0, 0, sourceBmp->width(), sourceBmp->height()); BitmapInfo bmpInfo; void* pixels; HBITMAP resultBitmap = sourceBmp->clipBitmap(rect, true, bmpInfo, pixels); if (!resultBitmap) return; if (::OpenClipboard(m_owner)) { ::SetClipboardData(CF_BITMAP, resultBitmap); ::CloseClipboard(); } else DeleteObject(resultBitmap); }
void Pasteboard::writeImage(Node* node, const KURL&, const String& title) { ASSERT(node); if (!(node->renderer() && node->renderer()->isImage())) return; RenderImage* renderer = toRenderImage(node->renderer()); CachedImage* cachedImage = renderer->cachedImage(); if (!cachedImage || cachedImage->errorOccurred()) return; Image* image = cachedImage->imageForRenderer(renderer); ASSERT(image); NativeImagePtr bitmap = image->nativeImageForCurrentFrame(); if (!bitmap) return; // If the image is wrapped in a link, |url| points to the target of the // link. This isn't useful to us, so get the actual image URL. AtomicString urlString; if (node->hasTagName(HTMLNames::imgTag) || node->hasTagName(HTMLNames::inputTag)) urlString = static_cast<Element*>(node)->getAttribute(HTMLNames::srcAttr); #if ENABLE(SVG) else if (node->hasTagName(SVGNames::imageTag)) urlString = static_cast<Element*>(node)->getAttribute(XLinkNames::hrefAttr); #endif else if (node->hasTagName(HTMLNames::embedTag) || node->hasTagName(HTMLNames::objectTag)) { Element* element = static_cast<Element*>(node); urlString = element->getAttribute(element->imageSourceAttributeName()); } KURL url = urlString.isEmpty() ? KURL() : node->document()->completeURL(stripLeadingAndTrailingHTMLSpaces(urlString)); PlatformSupport::clipboardWriteImage(bitmap, url, title); }
CachedImage* CachedResourceLoader::requestImage(ResourceRequest& request) { if (Frame* f = frame()) { Settings* settings = f->settings(); if (!f->loader()->client()->allowImages(!settings || settings->areImagesEnabled())) return 0; if (f->loader()->pageDismissalEventBeingDispatched()) { KURL requestURL = request.url(); if (requestURL.isValid() && canRequest(CachedResource::ImageResource, requestURL)) PingLoader::loadImage(f, requestURL); return 0; } } CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request, String())); if (resource) { #ifdef ANDROID_BLOCK_NETWORK_IMAGE resource->setAutoLoadWasPreventedBySettings(!autoLoadImages() || shouldBlockNetworkImage(request.url())); #else resource->setAutoLoadWasPreventedBySettings(!autoLoadImages()); #endif if (autoLoadImages() && resource->stillNeedsLoad()) { #ifdef ANDROID_BLOCK_NETWORK_IMAGE if (shouldBlockNetworkImage(request.url())) { return resource; } #endif resource->setLoading(true); load(resource, true); } } return resource; }
void Assets::loadImg(string imgName) { CachedImage * img = new CachedImage(); img->loadImage(imgName); img->imgName = imgName; Instance()->images.push_back( img ); }
void ClipboardQt::declareAndWriteDragImage(Element* element, const KURL& url, const String& title, Frame* frame) { ASSERT(frame); //WebCore::writeURL(m_writableDataObject.get(), url, title, true, false); if (!m_writableData) m_writableData = new QMimeData; CachedImage* cachedImage = getCachedImage(element); if (!cachedImage || !cachedImage->image() || !cachedImage->isLoaded()) return; QPixmap *pixmap = cachedImage->image()->nativeImageForCurrentFrame(); if (pixmap) m_writableData->setImageData(*pixmap); AtomicString imageURL = element->getAttribute(HTMLNames::srcAttr); if (imageURL.isEmpty()) return; KURL fullURL = frame->document()->completeURL(deprecatedParseURL(imageURL)); if (fullURL.isEmpty()) return; QList<QUrl> urls; urls.append(url); urls.append(fullURL); m_writableData->setText(title); m_writableData->setUrls(urls); #ifndef QT_NO_CLIPBOARD if (!isForDragging()) QApplication::clipboard()->setMimeData(m_writableData); #endif }
void ImageDocumentParser::finish() { if (!isStopped() && document()->imageElement()) { CachedImage* cachedImage = document()->cachedImage(); RefPtr<SharedBuffer> data = document()->frame()->loader()->documentLoader()->mainResourceData(); // If this is a multipart image, make a copy of the current part, since the resource data // will be overwritten by the next part. if (document()->frame()->loader()->documentLoader()->isLoadingMultipartContent()) data = data->copy(); cachedImage->data(data.release(), true); cachedImage->finish(); cachedImage->setResponse(document()->frame()->loader()->documentLoader()->response()); // Report the natural image size in the page title, regardless of zoom // level. IntSize size = cachedImage->imageSize(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()->imageChanged(); } document()->finishedParsing(); }
static void writeImageToDataObject(IDataObject* dataObject, Element* element, const KURL& url) { // Shove image data into a DataObject for use as a file CachedImage* cachedImage = getCachedImage(element); if (!cachedImage || !cachedImage->image() || !cachedImage->isLoaded()) return; SharedBuffer* imageBuffer = cachedImage->image()->data(); if (!imageBuffer || !imageBuffer->size()) return; HGLOBAL imageFileDescriptor = createGlobalImageFileDescriptor(url.string(), element->getAttribute(altAttr), cachedImage); if (!imageFileDescriptor) return; HGLOBAL imageFileContent = createGlobalImageFileContent(imageBuffer); if (!imageFileContent) { GlobalFree(imageFileDescriptor); return; } String fileName = cachedImage->response().suggestedFilename(); HGLOBAL hDropContent = createGlobalHDropContent(url, fileName, imageBuffer); if (!hDropContent) { GlobalFree(hDropContent); return; } writeFileToDataObject(dataObject, imageFileDescriptor, imageFileContent, hDropContent); }
void CanvasRenderingContext2D::drawImage(HTMLImageElement* image, const FloatRect& srcRect, const FloatRect& dstRect, ExceptionCode& ec) { ASSERT(image); ec = 0; FloatRect imageRect = FloatRect(FloatPoint(), size(image)); if (!(imageRect.contains(srcRect) && srcRect.width() >= 0 && srcRect.height() >= 0 && dstRect.width() >= 0 && dstRect.height() >= 0)) { ec = INDEX_SIZE_ERR; return; } if (srcRect.isEmpty() || dstRect.isEmpty()) return; GraphicsContext* c = drawingContext(); if (!c) return; CachedImage* cachedImage = image->cachedImage(); if (!cachedImage) return; FloatRect sourceRect = c->roundToDevicePixels(srcRect); FloatRect destRect = c->roundToDevicePixels(dstRect); willDraw(destRect); #ifdef __OWB__ c->drawImage(cachedImage->image()->nativeImageForCurrentFrame(), destRect, sourceRect, state().m_globalComposite); cachedImage->image()->startAnimation(); #else c->drawImage(cachedImage->image(), destRect, sourceRect, state().m_globalComposite); #endif //__OWB__ }
void DocLoader::setAutoLoadImages(bool enable) { if (enable == m_autoLoadImages) return; m_autoLoadImages = enable; if (!m_autoLoadImages) return; DocumentResourceMap::iterator end = m_documentResources.end(); for (DocumentResourceMap::iterator it = m_documentResources.begin(); it != end; ++it) { CachedResource* resource = it->second.get(); if (resource->type() == CachedResource::ImageResource) { CachedImage* image = const_cast<CachedImage*>(static_cast<const CachedImage*>(resource)); #ifdef ANDROID_BLOCK_NETWORK_IMAGE if (shouldBlockNetworkImage(image->url())) continue; #endif if (image->stillNeedsLoad()) cache()->loader()->load(this, image, true); } } }
static void writeImageToDataObject(DataObject* dataObject, Element* element, const KURL& url) { // Shove image data into a DataObject for use as a file CachedImage* cachedImage = getCachedImage(element); if (!cachedImage || !cachedImage->image() || !cachedImage->isLoaded()) return; SharedBuffer* imageBuffer = cachedImage->image()->data(); if (!imageBuffer || !imageBuffer->size()) return; dataObject->fileContent = imageBuffer; // Determine the filename for the file contents of the image. We try to // use the alt tag if one exists, otherwise we fall back on the suggested // filename in the http header, and finally we resort to using the filename // in the URL. /*String extension = MIMETypeRegistry::getPreferredExtensionForMIMEType( cachedImage->response().mimeType());*/ String extension = "png"; dataObject->fileExtension = extension.isEmpty() ? "" : "." + extension; String title = element->getAttribute(altAttr); if (title.isEmpty()) title = cachedImage->response().suggestedFilename(); //title = ClipboardBal::validateFileName(title, dataObject); dataObject->fileContentFilename = title + dataObject->fileExtension; }
void Pasteboard::writeImage(Element& element, const URL&, const String& title) { if (!(element.renderer() && element.renderer()->isRenderImage())) return; RenderImage* renderer = toRenderImage(element.renderer()); CachedImage* cachedImage = renderer->cachedImage(); if (!cachedImage || cachedImage->errorOccurred()) return; Image* image = cachedImage->imageForRenderer(renderer); ASSERT(image); m_dataObject->clearAll(); URL url = getURLForImageElement(element); if (!url.isEmpty()) { m_dataObject->setURL(url, title); m_dataObject->setMarkup(createMarkup(element, IncludeNode, 0, ResolveAllURLs)); } GRefPtr<GdkPixbuf> pixbuf = adoptGRef(image->getGdkPixbuf()); m_dataObject->setImage(pixbuf.get()); if (m_gtkClipboard) PasteboardHelper::defaultPasteboardHelper()->writeClipboardContents(m_gtkClipboard); }
PassRefPtr<Image> CSSFilterImageValue::image(RenderObject* renderer, const IntSize& size) { if (size.isEmpty()) return 0; CachedResourceLoader* cachedResourceLoader = renderer->document().cachedResourceLoader(); CachedImage* cachedImage = cachedImageForCSSValue(m_imageValue.get(), cachedResourceLoader); if (!cachedImage) return Image::nullImage(); Image* image = cachedImage->imageForRenderer(renderer); if (!image) return Image::nullImage(); // Transform Image into ImageBuffer. OwnPtr<ImageBuffer> texture = ImageBuffer::create(size); if (!texture) return Image::nullImage(); texture->context()->drawImage(image, ColorSpaceDeviceRGB, IntPoint()); RefPtr<FilterEffectRenderer> filterRenderer = FilterEffectRenderer::create(); filterRenderer->setSourceImage(texture.release()); filterRenderer->setSourceImageRect(FloatRect(FloatPoint(), size)); filterRenderer->setFilterRegion(FloatRect(FloatPoint(), size)); // FIXME: SVG Filter don't work at the moment. if (!filterRenderer->build(0, m_filterOperations, true)) return Image::nullImage(); filterRenderer->apply(); m_generatedImage = filterRenderer->output()->copyImage(); return m_generatedImage.release(); }
RenderBox* RenderImage::embeddedContentBox() const { CachedImage* cachedImage = imageResource().cachedImage(); if (cachedImage && is<SVGImage>(cachedImage->image())) return downcast<SVGImage>(*cachedImage->image()).embeddedContentBox(); return nullptr; }
CachedImage* DocLoader::requestImage(const String& url) { CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, url, String())); if (autoLoadImages() && resource && resource->stillNeedsLoad()) { resource->setLoading(true); cache()->loader()->load(this, resource, true); } return resource; }
bool ImageTokenizer::writeRawData(const char* data, int len) { CachedImage* cachedImage = m_doc->cachedImage(); cachedImage->data(m_doc->frame()->loader()->documentLoader()->mainResourceData(), false); m_doc->imageChanged(); return false; }
static Image* getImage(Element* element) { ASSERT(element); CachedImage* cachedImage = getCachedImage(element); // Don't use cachedImage->imageForRenderer() here as that may return BitmapImages for cached SVG Images. // Users of getImage() want access to the SVGImage, in order to figure out the filename extensions, // which would be empty when asking the cached BitmapImages. return (cachedImage && !cachedImage->errorOccurred()) ? cachedImage->image() : 0; }
void HTMLImageLoader::notifyFinished(CachedResource*) { CachedImage* cachedImage = image(); Element* elem = element(); ImageLoader::notifyFinished(cachedImage); if ((cachedImage->errorOccurred() || cachedImage->httpStatusCodeErrorOccurred()) && elem->hasTagName(HTMLNames::objectTag)) static_cast<HTMLObjectElement*>(elem)->renderFallbackContent(); }