gecko-dev/dom/canvas/ImageBitmapRenderingContext.cpp
Jeff Gilbert 5b753da289 Bug 1470325 - s/FooBinding/Foo_Binding/g - r=qdot
MozReview-Commit-ID: JtTcLL5OPF0
2018-06-26 17:05:01 -07:00

306 lines
7.4 KiB
C++

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "ImageBitmapRenderingContext.h"
#include "mozilla/dom/ImageBitmapRenderingContextBinding.h"
#include "ImageContainer.h"
#include "ImageLayers.h"
namespace mozilla {
namespace dom {
ImageBitmapRenderingContext::ImageBitmapRenderingContext()
: mWidth(0)
, mHeight(0)
{
}
ImageBitmapRenderingContext::~ImageBitmapRenderingContext()
{
RemovePostRefreshObserver();
}
JSObject*
ImageBitmapRenderingContext::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return ImageBitmapRenderingContext_Binding::Wrap(aCx, this, aGivenProto);
}
already_AddRefed<layers::Image>
ImageBitmapRenderingContext::ClipToIntrinsicSize()
{
if (!mImage) {
return nullptr;
}
// If image is larger than canvas intrinsic size, clip it to the intrinsic size.
RefPtr<gfx::SourceSurface> surface;
RefPtr<layers::Image> result;
if (mWidth < mImage->GetSize().width ||
mHeight < mImage->GetSize().height) {
surface = MatchWithIntrinsicSize();
} else {
surface = mImage->GetAsSourceSurface();
}
if (!surface) {
return nullptr;
}
result = new layers::SourceSurfaceImage(gfx::IntSize(mWidth, mHeight), surface);
return result.forget();
}
void
ImageBitmapRenderingContext::TransferImageBitmap(ImageBitmap& aImageBitmap)
{
TransferFromImageBitmap(aImageBitmap);
}
void
ImageBitmapRenderingContext::TransferFromImageBitmap(ImageBitmap& aImageBitmap)
{
Reset();
mImage = aImageBitmap.TransferAsImage();
if (!mImage) {
return;
}
Redraw(gfxRect(0, 0, mWidth, mHeight));
}
NS_IMETHODIMP
ImageBitmapRenderingContext::SetDimensions(int32_t aWidth, int32_t aHeight)
{
mWidth = aWidth;
mHeight = aHeight;
return NS_OK;
}
NS_IMETHODIMP
ImageBitmapRenderingContext::InitializeWithDrawTarget(nsIDocShell* aDocShell,
NotNull<gfx::DrawTarget*> aTarget)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
already_AddRefed<DataSourceSurface>
ImageBitmapRenderingContext::MatchWithIntrinsicSize()
{
RefPtr<SourceSurface> surface = mImage->GetAsSourceSurface();
RefPtr<DataSourceSurface> temp =
Factory::CreateDataSourceSurface(IntSize(mWidth, mHeight), surface->GetFormat());
if (!temp) {
return nullptr;
}
DataSourceSurface::ScopedMap map(temp, DataSourceSurface::READ_WRITE);
if (!map.IsMapped()) {
return nullptr;
}
RefPtr<DrawTarget> dt =
Factory::CreateDrawTargetForData(gfxPlatform::GetPlatform()->GetSoftwareBackend(),
map.GetData(),
temp->GetSize(),
map.GetStride(),
temp->GetFormat());
if (!dt || !dt->IsValid()) {
gfxWarning() << "ImageBitmapRenderingContext::MatchWithIntrinsicSize failed";
return nullptr;
}
dt->ClearRect(Rect(0, 0, mWidth, mHeight));
dt->CopySurface(surface,
IntRect(0, 0, surface->GetSize().width,
surface->GetSize().height),
IntPoint(0, 0));
return temp.forget();
}
mozilla::UniquePtr<uint8_t[]>
ImageBitmapRenderingContext::GetImageBuffer(int32_t* aFormat)
{
*aFormat = 0;
if (!mImage) {
return nullptr;
}
RefPtr<SourceSurface> surface = mImage->GetAsSourceSurface();
RefPtr<DataSourceSurface> data = surface->GetDataSurface();
if (!data) {
return nullptr;
}
if (data->GetSize() != IntSize(mWidth, mHeight)) {
data = MatchWithIntrinsicSize();
if (!data) {
return nullptr;
}
}
*aFormat = imgIEncoder::INPUT_FORMAT_HOSTARGB;
return SurfaceToPackedBGRA(data);
}
NS_IMETHODIMP
ImageBitmapRenderingContext::GetInputStream(const char* aMimeType,
const char16_t* aEncoderOptions,
nsIInputStream** aStream)
{
nsCString enccid("@mozilla.org/image/encoder;2?type=");
enccid += aMimeType;
nsCOMPtr<imgIEncoder> encoder = do_CreateInstance(enccid.get());
if (!encoder) {
return NS_ERROR_FAILURE;
}
int32_t format = 0;
UniquePtr<uint8_t[]> imageBuffer = GetImageBuffer(&format);
if (!imageBuffer) {
return NS_ERROR_FAILURE;
}
return ImageEncoder::GetInputStream(mWidth, mHeight, imageBuffer.get(), format,
encoder, aEncoderOptions, aStream);
}
already_AddRefed<mozilla::gfx::SourceSurface>
ImageBitmapRenderingContext::GetSurfaceSnapshot(gfxAlphaType* const aOutAlphaType)
{
if (!mImage) {
return nullptr;
}
if (aOutAlphaType) {
*aOutAlphaType = (GetIsOpaque() ? gfxAlphaType::Opaque : gfxAlphaType::Premult);
}
RefPtr<SourceSurface> surface = mImage->GetAsSourceSurface();
if (surface->GetSize() != IntSize(mWidth, mHeight)) {
return MatchWithIntrinsicSize();
}
return surface.forget();
}
void
ImageBitmapRenderingContext::SetOpaqueValueFromOpaqueAttr(bool aOpaqueAttrValue)
{
// ignored
}
bool
ImageBitmapRenderingContext::GetIsOpaque()
{
return false;
}
NS_IMETHODIMP
ImageBitmapRenderingContext::Reset()
{
if (mCanvasElement) {
mCanvasElement->InvalidateCanvas();
}
mImage = nullptr;
return NS_OK;
}
already_AddRefed<Layer>
ImageBitmapRenderingContext::GetCanvasLayer(nsDisplayListBuilder* aBuilder,
Layer* aOldLayer,
LayerManager* aManager)
{
if (!mImage) {
// No DidTransactionCallback will be received, so mark the context clean
// now so future invalidations will be dispatched.
MarkContextClean();
return nullptr;
}
RefPtr<ImageLayer> imageLayer;
if (aOldLayer) {
imageLayer = static_cast<ImageLayer*>(aOldLayer);
} else {
imageLayer = aManager->CreateImageLayer();
}
RefPtr<ImageContainer> imageContainer = imageLayer->GetContainer();
if (!imageContainer) {
imageContainer = LayerManager::CreateImageContainer();
imageLayer->SetContainer(imageContainer);
}
AutoTArray<ImageContainer::NonOwningImage, 1> imageList;
RefPtr<layers::Image> image = ClipToIntrinsicSize();
if (!image) {
return nullptr;
}
imageList.AppendElement(ImageContainer::NonOwningImage(image));
imageContainer->SetCurrentImages(imageList);
return imageLayer.forget();
}
void
ImageBitmapRenderingContext::MarkContextClean()
{
}
NS_IMETHODIMP
ImageBitmapRenderingContext::Redraw(const gfxRect& aDirty)
{
if (!mCanvasElement) {
return NS_OK;
}
mozilla::gfx::Rect rect = ToRect(aDirty);
mCanvasElement->InvalidateCanvasContent(&rect);
return NS_OK;
}
NS_IMETHODIMP
ImageBitmapRenderingContext::SetIsIPC(bool aIsIPC)
{
return NS_OK;
}
void
ImageBitmapRenderingContext::DidRefresh()
{
}
void
ImageBitmapRenderingContext::MarkContextCleanForFrameCapture()
{
}
bool
ImageBitmapRenderingContext::IsContextCleanForFrameCapture()
{
return true;
}
NS_IMPL_CYCLE_COLLECTING_ADDREF(ImageBitmapRenderingContext)
NS_IMPL_CYCLE_COLLECTING_RELEASE(ImageBitmapRenderingContext)
NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ImageBitmapRenderingContext,
mCanvasElement,
mOffscreenCanvas)
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ImageBitmapRenderingContext)
NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
NS_INTERFACE_MAP_ENTRY(nsICanvasRenderingContextInternal)
NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_END
}
}