void GraphicsContext3D::paintRenderingResultsToCanvas(CanvasRenderingContext* context, DrawingBuffer*)
{
HTMLCanvasElement* canvas = context->canvas();
ImageBuffer* imageBuffer = canvas->buffer();
int rowBytes = m_currentWidth * 4;
int totalBytes = rowBytes * m_currentHeight;
OwnArrayPtr<unsigned char> pixels = adoptArrayPtr(new unsigned char[totalBytes]);
if (!pixels)
return;
readRenderingResults(pixels.get(), totalBytes);
if (!m_attrs.premultipliedAlpha) {
for (int i = 0; i < totalBytes; i += 4) {
// Premultiply alpha.
pixels[i + 0] = std::min(255, pixels[i + 0] * pixels[i + 3] / 255);
pixels[i + 1] = std::min(255, pixels[i + 1] * pixels[i + 3] / 255);
pixels[i + 2] = std::min(255, pixels[i + 2] * pixels[i + 3] / 255);
}
}
paintToCanvas(pixels.get(), m_currentWidth, m_currentHeight,
canvas->width(), canvas->height(), imageBuffer->context()->platformContext());
}
void RenderHTMLCanvas::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
GraphicsContext* context = paintInfo.context;
LayoutRect contentRect = contentBoxRect();
contentRect.moveBy(paintOffset);
LayoutRect paintRect = replacedContentRect();
paintRect.moveBy(paintOffset);
bool clip = !contentRect.contains(paintRect);
if (clip) {
// Not allowed to overflow the content box.
paintInfo.context->save();
paintInfo.context->clip(pixelSnappedIntRect(contentRect));
}
// FIXME: InterpolationNone should be used if ImageRenderingOptimizeContrast is set.
// See bug for more details: crbug.com/353716.
InterpolationQuality interpolationQuality = style()->imageRendering() == ImageRenderingOptimizeContrast ? InterpolationLow : CanvasDefaultInterpolationQuality;
HTMLCanvasElement* canvas = toHTMLCanvasElement(node());
LayoutSize layoutSize = contentRect.size();
if (style()->imageRendering() == ImageRenderingPixelated
&& (layoutSize.width() > canvas->width() || layoutSize.height() > canvas->height() || layoutSize == canvas->size())) {
interpolationQuality = InterpolationNone;
}
InterpolationQuality previousInterpolationQuality = context->imageInterpolationQuality();
context->setImageInterpolationQuality(interpolationQuality);
canvas->paint(context, paintRect);
context->setImageInterpolationQuality(previousInterpolationQuality);
if (clip)
context->restore();
}
virtual nsRegion GetOpaqueRegion(nsDisplayListBuilder* aBuilder,
bool* aSnap) override {
*aSnap = false;
nsHTMLCanvasFrame* f = static_cast<nsHTMLCanvasFrame*>(Frame());
HTMLCanvasElement* canvas =
HTMLCanvasElement::FromContent(f->GetContent());
nsRegion result;
if (canvas->GetIsOpaque()) {
// OK, the entire region painted by the canvas is opaque. But what is
// that region? It's the canvas's "dest rect" (controlled by the
// object-fit/object-position CSS properties), clipped to the container's
// content box (which is what GetBounds() returns). So, we grab those
// rects and intersect them.
nsRect constraintRect = GetBounds(aBuilder, aSnap);
// Need intrinsic size & ratio, for ComputeObjectDestRect:
nsIntSize canvasSize = f->GetCanvasSize();
IntrinsicSize intrinsicSize = IntrinsicSizeFromCanvasSize(canvasSize);
nsSize intrinsicRatio = IntrinsicRatioFromCanvasSize(canvasSize);
const nsRect destRect =
nsLayoutUtils::ComputeObjectDestRect(constraintRect,
intrinsicSize, intrinsicRatio,
f->StylePosition());
return nsRegion(destRect.Intersect(constraintRect));
}
return result;
}
void InspectorCanvasAgent::findFramesWithUninstrumentedCanvases()
{
class NodeVisitor : public WrappedNodeVisitor {
public:
NodeVisitor(Page* page, FramesWithUninstrumentedCanvases& result)
: m_page(page)
, m_framesWithUninstrumentedCanvases(result)
{
}
virtual void visitNode(Node* node) OVERRIDE
{
if (!node->hasTagName(HTMLNames::canvasTag) || !node->document() || !node->document()->frame())
return;
Frame* frame = node->document()->frame();
if (frame->page() != m_page)
return;
HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(node);
if (canvas->renderingContext())
m_framesWithUninstrumentedCanvases.set(frame, true);
}
private:
/* static */ already_AddRefed<ImageBitmap>
ImageBitmap::CreateInternal(nsIGlobalObject* aGlobal, HTMLCanvasElement& aCanvasEl,
const Maybe<IntRect>& aCropRect, ErrorResult& aRv)
{
if (aCanvasEl.Width() == 0 || aCanvasEl.Height() == 0) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return nullptr;
}
RefPtr<SourceSurface> surface = GetSurfaceFromElement(aGlobal, aCanvasEl, aRv);
if (NS_WARN_IF(aRv.Failed())) {
return nullptr;
}
// Crop the source surface if needed.
RefPtr<SourceSurface> croppedSurface;
IntRect cropRect = aCropRect.valueOr(IntRect());
// If the HTMLCanvasElement's rendering context is WebGL, then the snapshot
// we got from the HTMLCanvasElement is a DataSourceSurface which is a copy
// of the rendering context. We handle cropping in this case.
if ((aCanvasEl.GetCurrentContextType() == CanvasContextType::WebGL1 ||
aCanvasEl.GetCurrentContextType() == CanvasContextType::WebGL2) &&
aCropRect.isSome()) {
// The _surface_ must be a DataSourceSurface.
MOZ_ASSERT(surface->GetType() == SurfaceType::DATA,
"The snapshot SourceSurface from WebGL rendering contest is not \
DataSourceSurface.");
RefPtr<DataSourceSurface> dataSurface = surface->GetDataSurface();
croppedSurface = CropAndCopyDataSourceSurface(dataSurface, cropRect);
cropRect.MoveTo(0, 0);
}
JSValue JSHTMLCanvasElement::getContext(ExecState* exec)
{
HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(impl());
const String& contextId = exec->argument(0).toString(exec)->value(exec);
RefPtr<CanvasContextAttributes> attrs;
#if ENABLE(WEBGL)
if (HTMLCanvasElement::is3dType(contextId)) {
get3DContextAttributes(exec, attrs);
if (exec->hadException())
return jsUndefined();
}
#endif
CanvasRenderingContext* context = canvas->getContext(contextId, attrs.get());
if (!context)
return jsNull();
JSValue jsValue = toJS(exec, globalObject(), WTF::getPtr(context));
if (InspectorInstrumentation::canvasAgentEnabled(canvas->document())) {
ScriptObject contextObject(exec, jsValue.getObject());
ScriptObject wrapped;
if (context->is2d())
wrapped = InspectorInstrumentation::wrapCanvas2DRenderingContextForInstrumentation(canvas->document(), contextObject);
#if ENABLE(WEBGL)
else if (context->is3d())
wrapped = InspectorInstrumentation::wrapWebGLRenderingContextForInstrumentation(canvas->document(), contextObject);
#endif
if (!wrapped.hasNoValue())
return wrapped.jsValue();
}
return jsValue;
}
static void heightAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
{
HTMLCanvasElement* imp = V8HTMLCanvasElement::toNative(info.Holder());
int v = toInt32(value);
imp->setHeight(v);
return;
}
bool RenderHTMLCanvas::requiresLayer() const
{
if (RenderReplaced::requiresLayer())
return true;
HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(node());
return canvas && canvas->renderingContext() && canvas->renderingContext()->isAccelerated();
}
PassRefPtr<Image> CSSCanvasValue::image(RenderObject* renderer, const IntSize& /*size*/)
{
ASSERT(clients().contains(renderer));
HTMLCanvasElement* elt = element(renderer->document());
if (!elt || !elt->buffer())
return 0;
return elt->copiedImage();
}
CompositingReasons RenderHTMLCanvas::additionalCompositingReasons() const
{
HTMLCanvasElement* canvas = toHTMLCanvasElement(node());
if (canvas->renderingContext() && canvas->renderingContext()->isAccelerated())
return CompositingReasonCanvas;
return CompositingReasonNone;
}
/* PreTransactionCallback gets called by the Layers code every time the
* WebGL canvas is going to be composited.
*/
static void PreTransactionCallback(void* data)
{
WebGLContextUserData* userdata = static_cast<WebGLContextUserData*>(data);
HTMLCanvasElement* canvas = userdata->mContent;
WebGLContext* context = static_cast<WebGLContext*>(canvas->GetContextAtIndex(0));
// Present our screenbuffer, if needed.
context->PresentScreenBuffer();
}
void V8HTMLCanvasElement::getContextMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
v8::Handle<v8::Object> holder = info.Holder();
v8::Isolate* isolate = info.GetIsolate();
HTMLCanvasElement* impl = V8HTMLCanvasElement::toNative(holder);
TOSTRING_VOID(V8StringResource<>, contextIdResource, info[0]);
String contextId = contextIdResource;
RefPtr<CanvasContextAttributes> attributes = nullptr;
if (contextId == "webgl" || contextId == "experimental-webgl") {
RefPtr<WebGLContextAttributes> webGLAttributes = WebGLContextAttributes::create();
if (info.Length() > 1 && info[1]->IsObject()) {
v8::Handle<v8::Object> jsAttributes = info[1]->ToObject();
v8::Handle<v8::String> alpha = v8AtomicString(isolate, "alpha");
if (jsAttributes->Has(alpha) && !isUndefinedOrNull(jsAttributes->Get(alpha)))
webGLAttributes->setAlpha(jsAttributes->Get(alpha)->BooleanValue());
v8::Handle<v8::String> depth = v8AtomicString(isolate, "depth");
if (jsAttributes->Has(depth) && !isUndefinedOrNull(jsAttributes->Get(depth)))
webGLAttributes->setDepth(jsAttributes->Get(depth)->BooleanValue());
v8::Handle<v8::String> stencil = v8AtomicString(isolate, "stencil");
if (jsAttributes->Has(stencil) && !isUndefinedOrNull(jsAttributes->Get(stencil)))
webGLAttributes->setStencil(jsAttributes->Get(stencil)->BooleanValue());
v8::Handle<v8::String> antialias = v8AtomicString(isolate, "antialias");
if (jsAttributes->Has(antialias) && !isUndefinedOrNull(jsAttributes->Get(antialias)))
webGLAttributes->setAntialias(jsAttributes->Get(antialias)->BooleanValue());
v8::Handle<v8::String> premultipliedAlpha = v8AtomicString(isolate, "premultipliedAlpha");
if (jsAttributes->Has(premultipliedAlpha) && !isUndefinedOrNull(jsAttributes->Get(premultipliedAlpha)))
webGLAttributes->setPremultipliedAlpha(jsAttributes->Get(premultipliedAlpha)->BooleanValue());
v8::Handle<v8::String> preserveDrawingBuffer = v8AtomicString(isolate, "preserveDrawingBuffer");
if (jsAttributes->Has(preserveDrawingBuffer) && !isUndefinedOrNull(jsAttributes->Get(preserveDrawingBuffer)))
webGLAttributes->setPreserveDrawingBuffer(jsAttributes->Get(preserveDrawingBuffer)->BooleanValue());
v8::Handle<v8::String> failIfMajorPerformanceCaveat = v8AtomicString(isolate, "failIfMajorPerformanceCaveat");
if (jsAttributes->Has(failIfMajorPerformanceCaveat) && !isUndefinedOrNull(jsAttributes->Get(failIfMajorPerformanceCaveat)))
webGLAttributes->setFailIfMajorPerformanceCaveat(jsAttributes->Get(failIfMajorPerformanceCaveat)->BooleanValue());
}
attributes = webGLAttributes;
} else {
RefPtr<Canvas2DContextAttributes> canvas2DAttributes = Canvas2DContextAttributes::create();
attributes = canvas2DAttributes;
}
CanvasRenderingContext* result = impl->getContext(contextId, attributes.get());
if (!result) {
v8SetReturnValueNull(info);
return;
}
if (result->is2d()) {
v8::Handle<v8::Value> v8Result = toV8(toCanvasRenderingContext2D(result), info.Holder(), info.GetIsolate());
v8SetReturnValue(info, v8Result);
return;
}
if (result->is3d()) {
v8::Handle<v8::Value> v8Result = toV8(toWebGLRenderingContext(result), info.Holder(), info.GetIsolate());
v8SetReturnValue(info, v8Result);
return;
}
ASSERT_NOT_REACHED();
v8SetReturnValueNull(info);
}
void JSHTMLCanvasElement::markChildren(MarkStack& markStack)
{
Base::markChildren(markStack);
HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(impl());
JSGlobalData& globalData = *Heap::heap(this)->globalData();
markDOMObjectWrapper(markStack, globalData, canvas->renderingContext());
}
void GraphicsContext3DInternal::paintRenderingResultsToCanvas(CanvasRenderingContext* context)
{
HTMLCanvasElement* canvas = context->canvas();
ImageBuffer* imageBuffer = canvas->buffer();
unsigned char* pixels = 0;
#if PLATFORM(SKIA)
const SkBitmap* canvasBitmap = imageBuffer->context()->platformContext()->bitmap();
const SkBitmap* readbackBitmap = 0;
ASSERT(canvasBitmap->config() == SkBitmap::kARGB_8888_Config);
if (canvasBitmap->width() == m_impl->width() && canvasBitmap->height() == m_impl->height()) {
// This is the fastest and most common case. We read back
// directly into the canvas's backing store.
readbackBitmap = canvasBitmap;
m_resizingBitmap.reset();
} else {
// We need to allocate a temporary bitmap for reading back the
// pixel data. We will then use Skia to rescale this bitmap to
// the size of the canvas's backing store.
if (m_resizingBitmap.width() != m_impl->width() || m_resizingBitmap.height() != m_impl->height()) {
m_resizingBitmap.setConfig(SkBitmap::kARGB_8888_Config,
m_impl->width(),
m_impl->height());
if (!m_resizingBitmap.allocPixels())
return;
}
readbackBitmap = &m_resizingBitmap;
}
// Read back the frame buffer.
SkAutoLockPixels bitmapLock(*readbackBitmap);
pixels = static_cast<unsigned char*>(readbackBitmap->getPixels());
#elif PLATFORM(CG)
if (m_renderOutput)
pixels = m_renderOutput;
#else
#error Must port to your platform
#endif
m_impl->readBackFramebuffer(pixels, 4 * m_impl->width() * m_impl->height());
#if PLATFORM(SKIA)
if (m_resizingBitmap.readyToDraw()) {
// We need to draw the resizing bitmap into the canvas's backing store.
SkCanvas canvas(*canvasBitmap);
SkRect dst;
dst.set(SkIntToScalar(0), SkIntToScalar(0), SkIntToScalar(canvasBitmap->width()), SkIntToScalar(canvasBitmap->height()));
canvas.drawBitmapRect(m_resizingBitmap, 0, dst);
}
#elif PLATFORM(CG)
if (m_renderOutput && context->is3d()) {
WebGLRenderingContext* webGLContext = static_cast<WebGLRenderingContext*>(context);
webGLContext->graphicsContext3D()->paintToCanvas(m_renderOutput, m_impl->width(), m_impl->height(), canvas->width(), canvas->height(), imageBuffer->context()->platformContext());
}
#else
#error Must port to your platform
#endif
}
/** DidTransactionCallback gets called by the Layers code everytime the WebGL canvas gets composite,
* so it really is the right place to put actions that have to be performed upon compositing
*/
static void DidTransactionCallback(void* aData)
{
WebGLContextUserData *userdata = static_cast<WebGLContextUserData*>(aData);
HTMLCanvasElement *canvas = userdata->mContent;
WebGLContext *context = static_cast<WebGLContext*>(canvas->GetContextAtIndex(0));
// Mark ourselves as no longer invalidated.
context->MarkContextClean();
context->UpdateLastUseIndex();
}
CompositingReasons RenderHTMLCanvas::additionalCompositingReasons(CompositingTriggerFlags triggers) const
{
if (!(triggers & CanvasTrigger))
return CompositingReasonNone;
HTMLCanvasElement* canvas = toHTMLCanvasElement(node());
if (canvas->renderingContext() && canvas->renderingContext()->isAccelerated())
return CompositingReasonCanvas;
return CompositingReasonNone;
}
JSValue* jsHTMLCanvasElementPrototypeFunctionGetContext(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
if (!thisValue->isObject(&JSHTMLCanvasElement::s_info))
return throwError(exec, TypeError);
JSHTMLCanvasElement* castedThisObj = static_cast<JSHTMLCanvasElement*>(thisValue);
HTMLCanvasElement* imp = static_cast<HTMLCanvasElement*>(castedThisObj->impl());
const UString& contextId = args[0]->toString(exec);
KJS::JSValue* result = toJS(exec, WTF::getPtr(imp->getContext(contextId)));
return result;
}
virtual nsRegion GetOpaqueRegion(nsDisplayListBuilder* aBuilder,
bool* aSnap) {
*aSnap = false;
nsIFrame* f = GetUnderlyingFrame();
HTMLCanvasElement *canvas =
HTMLCanvasElement::FromContent(f->GetContent());
nsRegion result;
if (canvas->GetIsOpaque()) {
result = GetBounds(aBuilder, aSnap);
}
return result;
}
bool RenderLayerCompositor::requiresCompositingForCanvas(RenderObject* renderer) const
{
#if ENABLE(3D_CANVAS)
if (renderer->isCanvas()) {
HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(renderer->node());
return canvas->is3D();
}
#else
UNUSED_PARAM(renderer);
#endif
return false;
}
bool RenderHTMLCanvas::requiresLayer() const
{
if (RenderReplaced::requiresLayer())
return true;
#if ENABLE(3D_CANVAS)
HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(node());
return canvas && canvas->is3D();
#else
return false;
#endif
}
NS_IMETHODIMP
nsSimplePageSequenceFrame::ResetPrintCanvasList()
{
for (int32_t i = mCurrentCanvasList.Length() - 1; i >= 0 ; i--) {
HTMLCanvasElement* canvas = mCurrentCanvasList[i];
canvas->ResetPrintCallback();
}
mCurrentCanvasList.Clear();
mCurrentCanvasListSetup = false;
return NS_OK;
}
JSValue* jsHTMLCanvasElementPrototypeFunctionToDataURL(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList& args)
{
if (!thisValue->isObject(&JSHTMLCanvasElement::s_info))
return throwError(exec, TypeError);
JSHTMLCanvasElement* castedThisObj = static_cast<JSHTMLCanvasElement*>(thisValue);
HTMLCanvasElement* imp = static_cast<HTMLCanvasElement*>(castedThisObj->impl());
ExceptionCode ec = 0;
const UString& type = valueToStringWithUndefinedOrNullCheck(exec, args[0]);
KJS::JSValue* result = jsString(exec, imp->toDataURL(type, ec));
setDOMException(exec, ec);
return result;
}
void JSHTMLCanvasElement::putValueProperty(ExecState* exec, int token, JSValue* value)
{
switch (token) {
case WidthAttrNum: {
HTMLCanvasElement* imp = static_cast<HTMLCanvasElement*>(impl());
imp->setWidth(value->toInt32(exec));
break;
}
case HeightAttrNum: {
HTMLCanvasElement* imp = static_cast<HTMLCanvasElement*>(impl());
imp->setHeight(value->toInt32(exec));
break;
}
}
}
JSValue* JSHTMLCanvasElement::getValueProperty(ExecState* exec, int token) const
{
switch (token) {
case WidthAttrNum: {
HTMLCanvasElement* imp = static_cast<HTMLCanvasElement*>(impl());
return jsNumber(exec, imp->width());
}
case HeightAttrNum: {
HTMLCanvasElement* imp = static_cast<HTMLCanvasElement*>(impl());
return jsNumber(exec, imp->height());
}
case ConstructorAttrNum:
return getConstructor(exec);
}
return 0;
}
void GraphicsContext3D::paintRenderingResultsToCanvas(CanvasRenderingContext* context)
{
HTMLCanvasElement* canvas = context->canvas();
ImageBuffer* imageBuffer = canvas->buffer();
int rowBytes = m_currentWidth * 4;
int totalBytes = rowBytes * m_currentHeight;
OwnArrayPtr<unsigned char> pixels = adoptArrayPtr(new unsigned char[totalBytes]);
if (!pixels)
return;
makeContextCurrent();
bool mustRestoreFBO = false;
if (m_attrs.antialias) {
::glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO);
::glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo);
::glBlitFramebufferEXT(0, 0, m_currentWidth, m_currentHeight, 0, 0, m_currentWidth, m_currentHeight, GL_COLOR_BUFFER_BIT, GL_LINEAR);
::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
mustRestoreFBO = true;
} else {
if (m_boundFBO != m_fbo) {
mustRestoreFBO = true;
::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
}
}
GLint packAlignment = 4;
bool mustRestorePackAlignment = false;
::glGetIntegerv(GL_PACK_ALIGNMENT, &packAlignment);
if (packAlignment > 4) {
::glPixelStorei(GL_PACK_ALIGNMENT, 4);
mustRestorePackAlignment = true;
}
::glReadPixels(0, 0, m_currentWidth, m_currentHeight, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, pixels.get());
if (mustRestorePackAlignment)
::glPixelStorei(GL_PACK_ALIGNMENT, packAlignment);
if (mustRestoreFBO)
::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO);
paintToCanvas(pixels.get(), m_currentWidth, m_currentHeight,
canvas->width(), canvas->height(), imageBuffer->context()->platformContext());
}
JSValue JSHTMLCanvasElement::getContext(ExecState* exec)
{
HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(impl());
const UString& contextId = exec->argument(0).toString(exec)->value(exec);
RefPtr<CanvasContextAttributes> attrs;
#if ENABLE(WEBGL)
if (contextId == "experimental-webgl" || contextId == "webkit-3d") {
attrs = WebGLContextAttributes::create();
WebGLContextAttributes* webGLAttrs = static_cast<WebGLContextAttributes*>(attrs.get());
if (exec->argumentCount() > 1 && exec->argument(1).isObject()) {
JSObject* jsAttrs = exec->argument(1).getObject();
Identifier alpha(exec, "alpha");
if (jsAttrs->hasProperty(exec, alpha))
webGLAttrs->setAlpha(jsAttrs->get(exec, alpha).toBoolean(exec));
Identifier depth(exec, "depth");
if (jsAttrs->hasProperty(exec, depth))
webGLAttrs->setDepth(jsAttrs->get(exec, depth).toBoolean(exec));
Identifier stencil(exec, "stencil");
if (jsAttrs->hasProperty(exec, stencil))
webGLAttrs->setStencil(jsAttrs->get(exec, stencil).toBoolean(exec));
Identifier antialias(exec, "antialias");
if (jsAttrs->hasProperty(exec, antialias))
webGLAttrs->setAntialias(jsAttrs->get(exec, antialias).toBoolean(exec));
Identifier premultipliedAlpha(exec, "premultipliedAlpha");
if (jsAttrs->hasProperty(exec, premultipliedAlpha))
webGLAttrs->setPremultipliedAlpha(jsAttrs->get(exec, premultipliedAlpha).toBoolean(exec));
Identifier preserveDrawingBuffer(exec, "preserveDrawingBuffer");
if (jsAttrs->hasProperty(exec, preserveDrawingBuffer))
webGLAttrs->setPreserveDrawingBuffer(jsAttrs->get(exec, preserveDrawingBuffer).toBoolean(exec));
}
}
#endif
CanvasRenderingContext* context = canvas->getContext(ustringToString(contextId), attrs.get());
if (!context)
return jsNull();
JSValue jsValue = toJS(exec, globalObject(), WTF::getPtr(context));
#if ENABLE(WEBGL)
if (context->is3d() && InspectorInstrumentation::hasFrontends()) {
ScriptObject glContext(exec, jsValue.getObject());
ScriptObject wrapped = InspectorInstrumentation::wrapWebGLRenderingContextForInstrumentation(canvas->document(), glContext);
if (!wrapped.hasNoValue())
return wrapped.jsValue();
}
#endif
return jsValue;
}
v8::Handle<v8::Value> V8HTMLCanvasElement::toDataURLCallback(const v8::Arguments& args)
{
double quality = 1.0;
if (args.Length() > 1) {
if (args[1]->IsNumber())
quality = args[1]->NumberValue();
if (!(0.0 <= quality && quality <= 1.0))
quality = 1.0;
}
v8::Handle<v8::Object> holder = args.Holder();
HTMLCanvasElement* canvas = V8HTMLCanvasElement::toNative(holder);
String type = toWebCoreString(args[0]);
ExceptionCode ec = 0;
String result = canvas->toDataURL(type, &quality, ec);
V8Proxy::setDOMException(ec);
return v8StringOrUndefined(result);
}
void V8HTMLCanvasElement::toDataURLMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
{
v8::Handle<v8::Object> holder = info.Holder();
HTMLCanvasElement* canvas = V8HTMLCanvasElement::toNative(holder);
ExceptionState exceptionState(ExceptionState::ExecutionContext, "toDataURL", "HTMLCanvasElement", info.Holder(), info.GetIsolate());
TOSTRING_VOID(V8StringResource<>, type, info[0]);
double quality;
double* qualityPtr = 0;
if (info.Length() > 1 && info[1]->IsNumber()) {
quality = info[1]->NumberValue();
qualityPtr = &quality;
}
String result = canvas->toDataURL(type, qualityPtr, exceptionState);
exceptionState.throwIfNeeded();
v8SetReturnValueStringOrUndefined(info, result, info.GetIsolate());
}
JSValue* JSHTMLCanvasElementPrototypeFunction::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
{
if (!thisObj->inherits(&JSHTMLCanvasElement::info))
return throwError(exec, TypeError);
HTMLCanvasElement* imp = static_cast<HTMLCanvasElement*>(static_cast<JSHTMLCanvasElement*>(thisObj)->impl());
switch (id) {
case JSHTMLCanvasElement::GetContextFuncNum: {
String contextId = args[0]->toString(exec);
KJS::JSValue* result = toJS(exec, WTF::getPtr(imp->getContext(contextId)));
return result;
}
}
return 0;
}
v8::Handle<v8::Value> V8HTMLCanvasElement::toDataURLCallback(const v8::Arguments& args)
{
v8::Handle<v8::Object> holder = args.Holder();
HTMLCanvasElement* canvas = V8HTMLCanvasElement::toNative(holder);
ExceptionCode ec = 0;
String type = toWebCoreString(args[0]);
double quality;
double* qualityPtr = 0;
if (args.Length() > 1 && args[1]->IsNumber()) {
quality = args[1]->NumberValue();
qualityPtr = &quality;
}
String result = canvas->toDataURL(type, qualityPtr, ec);
setDOMException(ec, args.GetIsolate());
return v8StringOrUndefined(result, args.GetIsolate());
}
