Attachment #49646 for bug #35453

View Details Raw Unified Return to Bug 35453

| Differences between



#include "config.h"
#include "CanvasSurface.h"

#include "AffineTransform.h"
#include "ExceptionCode.h"
#include "FloatRect.h"
#include "GraphicsContext.h"
#include "ImageBuffer.h"
#include "MIMETypeRegistry.h"

namespace WebCore {

// These values come from the WhatWG spec.
const int CanvasSurface::DefaultWidth = 300;
const int CanvasSurface::DefaultHeight = 150;

// Firefox limits width/height to 32767 pixels, but slows down dramatically before it
// reaches that limit. We limit by area instead, giving us larger maximum dimensions,
// in exchange for a smaller maximum canvas size.
const float CanvasSurface::MaxCanvasArea = 32768 * 8192; // Maximum canvas area in CSS pixels

CanvasSurface::CanvasSurface(float pageScaleFactor)
    : m_size(DefaultWidth, DefaultHeight)
    , m_pageScaleFactor(pageScaleFactor)
    , m_originClean(true)
    , m_hasCreatedImageBuffer(false)
{
}

CanvasSurface::~CanvasSurface()
{
}

void CanvasSurface::setSurfaceSize(const IntSize& size)
{
    m_size = size;
    m_hasCreatedImageBuffer = false;
    m_imageBuffer.clear();
}

String CanvasSurface::toDataURL(const String& mimeType, ExceptionCode& ec)
{
    if (!m_originClean) {
        ec = SECURITY_ERR;
        return String();
    }

    if (m_size.isEmpty() || !buffer())
        return String("data:,");

    // FIXME: Make isSupportedImageMIMETypeForEncoding threadsafe (to allow this method to be used on a worker thread).
    if (mimeType.isNull() || !MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType))
        return buffer()->toDataURL("image/png");

    return buffer()->toDataURL(mimeType);
}

void CanvasSurface::willDraw(const FloatRect&)
{
    if (m_imageBuffer)
        m_imageBuffer->clearImage();
}

IntRect CanvasSurface::convertLogicalToDevice(const FloatRect& logicalRect) const
{
    return IntRect(convertLogicalToDevice(logicalRect.location()), convertLogicalToDevice(logicalRect.size()));
}

IntSize CanvasSurface::convertLogicalToDevice(const FloatSize& logicalSize) const
{
    float wf = ceilf(logicalSize.width() * m_pageScaleFactor);
    float hf = ceilf(logicalSize.height() * m_pageScaleFactor);

    if (!(wf >= 1 && hf >= 1 && wf * hf <= MaxCanvasArea))
        return IntSize();

    return IntSize(static_cast<unsigned>(wf), static_cast<unsigned>(hf));
}

IntPoint CanvasSurface::convertLogicalToDevice(const FloatPoint& logicalPos) const
{
    float xf = logicalPos.x() * m_pageScaleFactor;
    float yf = logicalPos.y() * m_pageScaleFactor;

    return IntPoint(static_cast<unsigned>(xf), static_cast<unsigned>(yf));
}

void CanvasSurface::createImageBuffer() const
{
    ASSERT(!m_imageBuffer);

    m_hasCreatedImageBuffer = true;

    FloatSize unscaledSize(width(), height());
    IntSize size = convertLogicalToDevice(unscaledSize);
    if (!size.width() || !size.height())
        return;

    m_imageBuffer = ImageBuffer::create(size);
    // The convertLogicalToDevice MaxCanvasArea check should prevent common cases
    // where ImageBuffer::create() returns 0, however we could still be low on memory.
    if (!m_imageBuffer)
        return;
    m_imageBuffer->context()->scale(FloatSize(size.width() / unscaledSize.width(), size.height() / unscaledSize.height()));
    m_imageBuffer->context()->setShadowsIgnoreTransforms(true);
}

GraphicsContext* CanvasSurface::drawingContext() const
{
    return buffer() ? m_imageBuffer->context() : 0;
}

ImageBuffer* CanvasSurface::buffer() const
{
    if (!m_hasCreatedImageBuffer)
        createImageBuffer();
    return m_imageBuffer.get();
}

AffineTransform CanvasSurface::baseTransform() const
{
    ASSERT(m_hasCreatedImageBuffer);
    FloatSize unscaledSize(width(), height());
    IntSize size = convertLogicalToDevice(unscaledSize);
    AffineTransform transform;
    if (size.width() && size.height())
        transform.scaleNonUniform(size.width() / unscaledSize.width(), size.height() / unscaledSize.height());
    transform.multiply(m_imageBuffer->baseTransform());
    return transform;
}

} // namespace WebCore

Lines 26-39 a/WebCore/dom/CanvasSurface.h_sec1
- a/WebCore/dom/CanvasSurface.h +58 lines
26	#ifndef CanvasSurface_h	26	#ifndef CanvasSurface_h
27	#define CanvasSurface_h	27	#define CanvasSurface_h
28		28
		29	#include "AffineTransform.h"
		30	#include "IntSize.h"
		31
		32	#include <wtf/OwnPtr.h>
29	#include <wtf/Noncopyable.h>	33	#include <wtf/Noncopyable.h>
30		34
31	namespace WebCore {	35	namespace WebCore {
32		36
		37	class AffineTransform;
		38	class FloatPoint;
		39	class FloatRect;
		40	class FloatSize;
		41	class GraphicsContext;
		42	class ImageBuffer;
		43	class IntPoint;
		44	class String;
		45
		46	typedef int ExceptionCode;
		47
33	class CanvasSurface : public Noncopyable {	48	class CanvasSurface : public Noncopyable {
34	public:	49	public:
		50	CanvasSurface(float pageScaleFactor);
		51	virtual ~CanvasSurface();
		52
		53	int width() const { return m_size.width(); }
		54	int height() const { return m_size.height(); }
		55
		56	String toDataURL(const String& mimeType, ExceptionCode&);
		57
		58	const IntSize& size() const { return m_size; }
		59
		60	virtual void willDraw(const FloatRect&);
		61
		62	GraphicsContext* drawingContext() const;
		63
		64	ImageBuffer* buffer() const;
		65
		66	IntRect convertLogicalToDevice(const FloatRect&) const;
		67	IntSize convertLogicalToDevice(const FloatSize&) const;
		68	IntPoint convertLogicalToDevice(const FloatPoint&) const;
		69
		70	void setOriginTainted() { m_originClean = false; }
		71	bool originClean() const { return m_originClean; }
		72
		73	AffineTransform baseTransform() const;
		74
		75	protected:
		76	void setSurfaceSize(const IntSize&);
		77	bool hasCreatedImageBuffer() const { return m_hasCreatedImageBuffer; }
		78
		79	static const int DefaultWidth;
		80	static const int DefaultHeight;
35		81
36	private:	82	private:
		83	void createImageBuffer() const;
		84
		85	static const float MaxCanvasArea;
		86
		87	IntSize m_size;
		88
		89	float m_pageScaleFactor;
		90	bool m_originClean;
		91
		92	// m_createdImageBuffer means we tried to malloc the buffer. We didn't necessarily get it.
		93	mutable bool m_hasCreatedImageBuffer;
		94	mutable OwnPtr<ImageBuffer> m_imageBuffer;
37	};	95	};
38		96
39	} // namespace WebCore	97	} // namespace WebCore



#include "HTMLCanvasElement.h"

#include "CanvasContextAttributes.h"
#include "CanvasGradient.h"
#include "CanvasPattern.h"
#include "CanvasRenderingContext2D.h"
#if ENABLE(3D_CANVAS)    
#include "WebGLContextAttributes.h"
#include "WebGLRenderingContext.h"
#endif
#include "CanvasGradient.h"
#include "CanvasPattern.h"
#include "CanvasStyle.h"
#include "Chrome.h"
#include "Document.h"
#include "ExceptionCode.h"
#include "Frame.h"
#include "GraphicsContext.h"
#include "HTMLNames.h"
#include "ImageBuffer.h"
#include "MIMETypeRegistry.h"
#include "MappedAttribute.h"
#include "Page.h"
#include "RenderHTMLCanvas.h"


using namespace HTMLNames;

// These values come from the WhatWG spec.
static const int defaultWidth = 300;
static const int defaultHeight = 150;

// Firefox limits width/height to 32767 pixels, but slows down dramatically before it 
// reaches that limit. We limit by area instead, giving us larger maximum dimensions,
// in exchange for a smaller maximum canvas size.
const float HTMLCanvasElement::MaxCanvasArea = 32768 * 8192; // Maximum canvas area in CSS pixels

HTMLCanvasElement::HTMLCanvasElement(const QualifiedName& tagName, Document* doc)
    : HTMLElement(tagName, doc)
    , CanvasSurface(doc->frame() ? doc->frame()->page()->chrome()->scaleFactor() : 1)
    , m_observer(0)
    , m_originClean(true)
    , m_ignoreReset(false)
    , m_createdImageBuffer(false)
{
    ASSERT(hasTagName(canvasTag));
}

    setAttribute(widthAttr, String::number(value));
}

String HTMLCanvasElement::toDataURL(const String& mimeType, ExceptionCode& ec)
{
    if (!m_originClean) {
        ec = SECURITY_ERR;
        return String();
    }

    if (m_size.isEmpty() || !buffer())
        return String("data:,");

    if (mimeType.isNull() || !MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType))
        return buffer()->toDataURL("image/png");

    return buffer()->toDataURL(mimeType);
}

CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type, CanvasContextAttributes* attrs)
{
    // A Canvas can either be "2D" or "webgl" but never both. If you request a 2D canvas and the existing


void HTMLCanvasElement::willDraw(const FloatRect& rect)
{
    CanvasSurface::willDraw(rect);

    
    if (RenderBox* ro = renderBox()) {
        FloatRect destRect = ro->contentBoxRect();
        FloatRect r = mapRect(rect, FloatRect(0, 0, size().width(), size().height()), destRect);
        r.intersect(destRect);
        if (m_dirtyRect.contains(r))
            return;

    bool ok;
    int w = getAttribute(widthAttr).toInt(&ok);
    if (!ok)
        w = DefaultWidth;
    int h = getAttribute(heightAttr).toInt(&ok);
    if (!ok)
        h = DefaultHeight;

    IntSize oldSize = size();
    setSurfaceSize(IntSize(w, h));

#if ENABLE(3D_CANVAS)
    if (m_context && m_context->is3d())
        static_cast<WebGLRenderingContext*>(m_context.get())->reshape(width(), height());
#endif

    bool hadImageBuffer = hasCreatedImageBuffer();
    m_createdImageBuffer = false;
    m_imageBuffer.clear();
    if (m_context && m_context->is2d())
        static_cast<CanvasRenderingContext2D*>(m_context.get())->reset();

    if (RenderObject* renderer = this->renderer()) {
        if (m_rendererIsCanvas) {
            if (oldSize != size())
                toRenderHTMLCanvas(renderer)->canvasSizeChanged();
            if (hadImageBuffer)
                renderer->repaint();

    }
#endif

    if (hasCreatedImageBuffer()) {
        ImageBuffer* imageBuffer = buffer();
        if (imageBuffer) {
            Image* image = imageBuffer->image();
            if (image)
                context->drawImage(image, DeviceColorSpace, r);
        }
    }

#if ENABLE(3D_CANVAS)

#endif
}

IntRect HTMLCanvasElement::convertLogicalToDevice(const FloatRect& logicalRect) const
{
    return IntRect(convertLogicalToDevice(logicalRect.location()), convertLogicalToDevice(logicalRect.size()));
}

IntSize HTMLCanvasElement::convertLogicalToDevice(const FloatSize& logicalSize) const
{
    float pageScaleFactor = document()->frame() ? document()->frame()->page()->chrome()->scaleFactor() : 1.0f;
    float wf = ceilf(logicalSize.width() * pageScaleFactor);
    float hf = ceilf(logicalSize.height() * pageScaleFactor);
    
    if (!(wf >= 1 && hf >= 1 && wf * hf <= MaxCanvasArea))
        return IntSize();

    return IntSize(static_cast<unsigned>(wf), static_cast<unsigned>(hf));
}

IntPoint HTMLCanvasElement::convertLogicalToDevice(const FloatPoint& logicalPos) const
{
    float pageScaleFactor = document()->frame() ? document()->frame()->page()->chrome()->scaleFactor() : 1.0f;
    float xf = logicalPos.x() * pageScaleFactor;
    float yf = logicalPos.y() * pageScaleFactor;
    
    return IntPoint(static_cast<unsigned>(xf), static_cast<unsigned>(yf));
}

void HTMLCanvasElement::createImageBuffer() const
{
    ASSERT(!m_imageBuffer);

    m_createdImageBuffer = true;
    
    FloatSize unscaledSize(width(), height());
    IntSize size = convertLogicalToDevice(unscaledSize);
    if (!size.width() || !size.height())
        return;

    m_imageBuffer = ImageBuffer::create(size);
    // The convertLogicalToDevice MaxCanvasArea check should prevent common cases
    // where ImageBuffer::create() returns NULL, however we could still be low on memory.
    if (!m_imageBuffer)
        return;
    m_imageBuffer->context()->scale(FloatSize(size.width() / unscaledSize.width(), size.height() / unscaledSize.height()));
    m_imageBuffer->context()->setShadowsIgnoreTransforms(true);
}

GraphicsContext* HTMLCanvasElement::drawingContext() const
{
    return buffer() ? m_imageBuffer->context() : 0;
}

ImageBuffer* HTMLCanvasElement::buffer() const
{
    if (!m_createdImageBuffer)
        createImageBuffer();
    return m_imageBuffer.get();
}
    
AffineTransform HTMLCanvasElement::baseTransform() const
{
    ASSERT(m_createdImageBuffer);
    FloatSize unscaledSize(width(), height());
    IntSize size = convertLogicalToDevice(unscaledSize);
    AffineTransform transform;
    if (size.width() && size.height())
        transform.scaleNonUniform(size.width() / unscaledSize.width(), size.height() / unscaledSize.height());
    transform.multiply(m_imageBuffer->baseTransform());
    return transform;
}

#if ENABLE(3D_CANVAS)    
bool HTMLCanvasElement::is3D() const
{



#ifndef HTMLCanvasElement_h
#define HTMLCanvasElement_h

#include "AffineTransform.h"
#include "CanvasSurface.h"
#include "FloatRect.h"
#include "HTMLElement.h"


class CanvasContextAttributes;
class CanvasRenderingContext;
class FloatPoint;
class FloatRect;
class FloatSize;
class GraphicsContext;
class HTMLCanvasElement;
class ImageBuffer;
class IntPoint;
class IntSize;

class CanvasObserver {

    HTMLCanvasElement(const QualifiedName&, Document*);
    virtual ~HTMLCanvasElement();

    int width() const { return m_size.width(); }
    int height() const { return m_size.height(); }
    void setWidth(int);
    void setHeight(int);

    String toDataURL(const String& mimeType, ExceptionCode&);

    CanvasRenderingContext* getContext(const String&, CanvasContextAttributes* attributes = 0);

    void setSize(const IntSize& newSize)
    void setSize(const IntSize& size)
    { 
        if (newSize == size())
            return;
        m_ignoreReset = true; 
        setWidth(newSize.width());
        setHeight(newSize.height());
        m_ignoreReset = false;
        reset();
    }

    virtual void willDraw(const FloatRect&);

    void paint(GraphicsContext*, const IntRect&);

    GraphicsContext* drawingContext() const;

    ImageBuffer* buffer() const;

    IntRect convertLogicalToDevice(const FloatRect&) const;
    IntSize convertLogicalToDevice(const FloatSize&) const;
    IntPoint convertLogicalToDevice(const FloatPoint&) const;

    void setOriginTainted() { m_originClean = false; } 
    bool originClean() const { return m_originClean; }

    void setObserver(CanvasObserver* observer) { m_observer = observer; }

    AffineTransform baseTransform() const;

    CanvasRenderingContext* renderingContext() const { return m_context.get(); }

#if ENABLE(3D_CANVAS)    

    virtual void parseMappedAttribute(MappedAttribute*);
    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);

    void createImageBuffer() const;
    void reset();

    static const float MaxCanvasArea;

    bool m_rendererIsCanvas;

    OwnPtr<CanvasRenderingContext> m_context;
    IntSize m_size;    
    CanvasObserver* m_observer;

    bool m_originClean;
    bool m_ignoreReset;
    FloatRect m_dirtyRect;

    // m_createdImageBuffer means we tried to malloc the buffer.  We didn't necessarily get it.
    mutable bool m_createdImageBuffer;
    mutable OwnPtr<ImageBuffer> m_imageBuffer;
};

} //namespace

Return to Bug 35453

Lines 26-31 a/WebCore/dom/CanvasSurface.cpp_sec1
- a/WebCore/dom/CanvasSurface.cpp +126 lines
26	#include "config.h"	26	#include "config.h"
27	#include "CanvasSurface.h"	27	#include "CanvasSurface.h"
28		28
		29	#include "AffineTransform.h"
		30	#include "ExceptionCode.h"
		31	#include "FloatRect.h"
		32	#include "GraphicsContext.h"
		33	#include "ImageBuffer.h"
		34	#include "MIMETypeRegistry.h"
		35
29	namespace WebCore {	36	namespace WebCore {
30		37
		38	// These values come from the WhatWG spec.
		39	const int CanvasSurface::DefaultWidth = 300;
		40	const int CanvasSurface::DefaultHeight = 150;
		41
		42	// Firefox limits width/height to 32767 pixels, but slows down dramatically before it
		43	// reaches that limit. We limit by area instead, giving us larger maximum dimensions,
		44	// in exchange for a smaller maximum canvas size.
		45	const float CanvasSurface::MaxCanvasArea = 32768 * 8192; // Maximum canvas area in CSS pixels
		46
		47	CanvasSurface::CanvasSurface(float pageScaleFactor)
		48	: m_size(DefaultWidth, DefaultHeight)
		49	, m_pageScaleFactor(pageScaleFactor)
		50	, m_originClean(true)
		51	, m_hasCreatedImageBuffer(false)
		52	{
		53	}
		54
		55	CanvasSurface::~CanvasSurface()
		56	{
		57	}
		58
		59	void CanvasSurface::setSurfaceSize(const IntSize& size)
		60	{
		61	m_size = size;
		62	m_hasCreatedImageBuffer = false;
		63	m_imageBuffer.clear();
		64	}
		65
		66	String CanvasSurface::toDataURL(const String& mimeType, ExceptionCode& ec)
		67	{
		68	if (!m_originClean) {
		69	ec = SECURITY_ERR;
		70	return String();
		71	}
		72
		73	if (m_size.isEmpty() \|\| !buffer())
		74	return String("data:,");
		75
		76	// FIXME: Make isSupportedImageMIMETypeForEncoding threadsafe (to allow this method to be used on a worker thread).
		77	if (mimeType.isNull() \|\| !MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType))
		78	return buffer()->toDataURL("image/png");
		79
		80	return buffer()->toDataURL(mimeType);
		81	}
		82
		83	void CanvasSurface::willDraw(const FloatRect&)
		84	{
		85	if (m_imageBuffer)
		86	m_imageBuffer->clearImage();
		87	}
		88
		89	IntRect CanvasSurface::convertLogicalToDevice(const FloatRect& logicalRect) const
		90	{
		91	return IntRect(convertLogicalToDevice(logicalRect.location()), convertLogicalToDevice(logicalRect.size()));
		92	}
		93
		94	IntSize CanvasSurface::convertLogicalToDevice(const FloatSize& logicalSize) const
		95	{
		96	float wf = ceilf(logicalSize.width() * m_pageScaleFactor);
		97	float hf = ceilf(logicalSize.height() * m_pageScaleFactor);
		98
		99	if (!(wf >= 1 && hf >= 1 && wf * hf <= MaxCanvasArea))
		100	return IntSize();
		101
102	return IntSize(static_cast<unsigned>(wf), static_cast<unsigned>(hf));
103	}
104
105	IntPoint CanvasSurface::convertLogicalToDevice(const FloatPoint& logicalPos) const
106	{
107	float xf = logicalPos.x() * m_pageScaleFactor;
108	float yf = logicalPos.y() * m_pageScaleFactor;
109
110	return IntPoint(static_cast<unsigned>(xf), static_cast<unsigned>(yf));
111	}
112
113	void CanvasSurface::createImageBuffer() const
114	{
115	ASSERT(!m_imageBuffer);
116
117	m_hasCreatedImageBuffer = true;
118
119	FloatSize unscaledSize(width(), height());
120	IntSize size = convertLogicalToDevice(unscaledSize);
121	if (!size.width() \|\| !size.height())
122	return;
123
124	m_imageBuffer = ImageBuffer::create(size);
125	// The convertLogicalToDevice MaxCanvasArea check should prevent common cases
126	// where ImageBuffer::create() returns 0, however we could still be low on memory.
127	if (!m_imageBuffer)
128	return;
129	m_imageBuffer->context()->scale(FloatSize(size.width() / unscaledSize.width(), size.height() / unscaledSize.height()));
130	m_imageBuffer->context()->setShadowsIgnoreTransforms(true);
131	}
132
133	GraphicsContext* CanvasSurface::drawingContext() const
134	{
135	return buffer() ? m_imageBuffer->context() : 0;
136	}
137
138	ImageBuffer* CanvasSurface::buffer() const
139	{
140	if (!m_hasCreatedImageBuffer)
141	createImageBuffer();
142	return m_imageBuffer.get();
143	}
144
145	AffineTransform CanvasSurface::baseTransform() const
146	{
147	ASSERT(m_hasCreatedImageBuffer);
148	FloatSize unscaledSize(width(), height());
149	IntSize size = convertLogicalToDevice(unscaledSize);
150	AffineTransform transform;
151	if (size.width() && size.height())
152	transform.scaleNonUniform(size.width() / unscaledSize.width(), size.height() / unscaledSize.height());
153	transform.multiply(m_imageBuffer->baseTransform());
154	return transform;
155	}
156
31	} // namespace WebCore	157	} // namespace WebCore

Lines 28-49 a/WebCore/html/HTMLCanvasElement.cpp_sec1
- a/WebCore/html/HTMLCanvasElement.cpp -118 / +19 lines
28	#include "HTMLCanvasElement.h"	28	#include "HTMLCanvasElement.h"
29		29
30	#include "CanvasContextAttributes.h"	30	#include "CanvasContextAttributes.h"
31	#include "CanvasGradient.h"
32	#include "CanvasPattern.h"
33	#include "CanvasRenderingContext2D.h"	31	#include "CanvasRenderingContext2D.h"
34	#if ENABLE(3D_CANVAS)	32	#if ENABLE(3D_CANVAS)
35	#include "WebGLContextAttributes.h"	33	#include "WebGLContextAttributes.h"
36	#include "WebGLRenderingContext.h"	34	#include "WebGLRenderingContext.h"
37	#endif	35	#endif
		36	#include "CanvasGradient.h"
		37	#include "CanvasPattern.h"
38	#include "CanvasStyle.h"	38	#include "CanvasStyle.h"
39	#include "Chrome.h"	39	#include "Chrome.h"
40	#include "Document.h"	40	#include "Document.h"
41	#include "ExceptionCode.h"
42	#include "Frame.h"	41	#include "Frame.h"
43	#include "GraphicsContext.h"	42	#include "GraphicsContext.h"
44	#include "HTMLNames.h"	43	#include "HTMLNames.h"
45	#include "ImageBuffer.h"	44	#include "ImageBuffer.h"
46	#include "MIMETypeRegistry.h"
47	#include "MappedAttribute.h"	45	#include "MappedAttribute.h"
48	#include "Page.h"	46	#include "Page.h"
49	#include "RenderHTMLCanvas.h"	47	#include "RenderHTMLCanvas.h"
Lines 55-76 namespace WebCore { a/WebCore/html/HTMLCanvasElement.cpp_sec2
55		53
56	using namespace HTMLNames;	54	using namespace HTMLNames;
57		55
58	// These values come from the WhatWG spec.
59	static const int defaultWidth = 300;
60	static const int defaultHeight = 150;
61
62	// Firefox limits width/height to 32767 pixels, but slows down dramatically before it
63	// reaches that limit. We limit by area instead, giving us larger maximum dimensions,
64	// in exchange for a smaller maximum canvas size.
65	const float HTMLCanvasElement::MaxCanvasArea = 32768 * 8192; // Maximum canvas area in CSS pixels
66
67	HTMLCanvasElement::HTMLCanvasElement(const QualifiedName& tagName, Document* doc)	56	HTMLCanvasElement::HTMLCanvasElement(const QualifiedName& tagName, Document* doc)
68	: HTMLElement(tagName, doc)	57	: HTMLElement(tagName, doc)
69	, m_size(defaultWidth, defaultHeight)	58	, CanvasSurface(doc->frame() ? doc->frame()->page()->chrome()->scaleFactor() : 1)
70	, m_observer(0)	59	, m_observer(0)
71	, m_originClean(true)
72	, m_ignoreReset(false)	60	, m_ignoreReset(false)
73	, m_createdImageBuffer(false)
74	{	61	{
75	ASSERT(hasTagName(canvasTag));	62	ASSERT(hasTagName(canvasTag));
76	}	63	}
Lines 133-154 void HTMLCanvasElement::setWidth(int value) a/WebCore/html/HTMLCanvasElement.cpp_sec3
133	setAttribute(widthAttr, String::number(value));	120	setAttribute(widthAttr, String::number(value));
134	}	121	}
135		122
136	String HTMLCanvasElement::toDataURL(const String& mimeType, ExceptionCode& ec)
137	{
138	if (!m_originClean) {
139	ec = SECURITY_ERR;
140	return String();
141	}
142
143	if (m_size.isEmpty() \|\| !buffer())
144	return String("data:,");
145
146	if (mimeType.isNull() \|\| !MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType))
147	return buffer()->toDataURL("image/png");
148
149	return buffer()->toDataURL(mimeType);
150	}
151
152	CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type, CanvasContextAttributes* attrs)	123	CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type, CanvasContextAttributes* attrs)
153	{	124	{
154	// A Canvas can either be "2D" or "webgl" but never both. If you request a 2D canvas and the existing	125	// A Canvas can either be "2D" or "webgl" but never both. If you request a 2D canvas and the existing
Lines 193-204 CanvasRenderingContext* HTMLCanvasElement::getContext(const String& type, Canvas a/WebCore/html/HTMLCanvasElement.cpp_sec4
193		164
194	void HTMLCanvasElement::willDraw(const FloatRect& rect)	165	void HTMLCanvasElement::willDraw(const FloatRect& rect)
195	{	166	{
196	if (m_imageBuffer)	167	CanvasSurface::willDraw(rect);
197	m_imageBuffer->clearImage();	168
198
199	if (RenderBox* ro = renderBox()) {	169	if (RenderBox* ro = renderBox()) {
200	FloatRect destRect = ro->contentBoxRect();	170	FloatRect destRect = ro->contentBoxRect();
201	FloatRect r = mapRect(rect, FloatRect(0, 0, m_size.width(), m_size.height()), destRect);	171	FloatRect r = mapRect(rect, FloatRect(0, 0, size().width(), size().height()), destRect);
202	r.intersect(destRect);	172	r.intersect(destRect);
203	if (m_dirtyRect.contains(r))	173	if (m_dirtyRect.contains(r))
204	return;	174	return;
Lines 219-246 void HTMLCanvasElement::reset() a/WebCore/html/HTMLCanvasElement.cpp_sec5
219	bool ok;	189	bool ok;
220	int w = getAttribute(widthAttr).toInt(&ok);	190	int w = getAttribute(widthAttr).toInt(&ok);
221	if (!ok)	191	if (!ok)
222	w = defaultWidth;	192	w = DefaultWidth;
223	int h = getAttribute(heightAttr).toInt(&ok);	193	int h = getAttribute(heightAttr).toInt(&ok);
224	if (!ok)	194	if (!ok)
225	h = defaultHeight;	195	h = DefaultHeight;
226		196
227	IntSize oldSize = m_size;	197	IntSize oldSize = size();
228	m_size = IntSize(w, h);	198	setSurfaceSize(IntSize(w, h));
229		199
230	#if ENABLE(3D_CANVAS)	200	#if ENABLE(3D_CANVAS)
231	if (m_context && m_context->is3d())	201	if (m_context && m_context->is3d())
232	static_cast<WebGLRenderingContext*>(m_context.get())->reshape(width(), height());	202	static_cast<WebGLRenderingContext*>(m_context.get())->reshape(width(), height());
233	#endif	203	#endif
234		204
235	bool hadImageBuffer = m_createdImageBuffer;	205	bool hadImageBuffer = hasCreatedImageBuffer();
236	m_createdImageBuffer = false;
237	m_imageBuffer.clear();
238	if (m_context && m_context->is2d())	206	if (m_context && m_context->is2d())
239	static_cast<CanvasRenderingContext2D*>(m_context.get())->reset();	207	static_cast<CanvasRenderingContext2D*>(m_context.get())->reset();
240		208
241	if (RenderObject* renderer = this->renderer()) {	209	if (RenderObject* renderer = this->renderer()) {
242	if (m_rendererIsCanvas) {	210	if (m_rendererIsCanvas) {
243	if (oldSize != m_size)	211	if (oldSize != size())
244	toRenderHTMLCanvas(renderer)->canvasSizeChanged();	212	toRenderHTMLCanvas(renderer)->canvasSizeChanged();
245	if (hadImageBuffer)	213	if (hadImageBuffer)
246	renderer->repaint();	214	renderer->repaint();
Lines 267-276 void HTMLCanvasElement::paint(GraphicsContext* context, const IntRect& r) a/WebCore/html/HTMLCanvasElement.cpp_sec6
267	}	235	}
268	#endif	236	#endif
269		237
270	if (m_imageBuffer) {	238	if (hasCreatedImageBuffer()) {
271	Image* image = m_imageBuffer->image();	239	ImageBuffer* imageBuffer = buffer();
272	if (image)	240	if (imageBuffer) {
273	context->drawImage(image, DeviceColorSpace, r);	241	Image* image = imageBuffer->image();
		242	if (image)
		243	context->drawImage(image, DeviceColorSpace, r);
		244	}
274	}	245	}
275		246
276	#if ENABLE(3D_CANVAS)	247	#if ENABLE(3D_CANVAS)
Lines 279-354 void HTMLCanvasElement::paint(GraphicsContext* context, const IntRect& r) a/WebCore/html/HTMLCanvasElement.cpp_sec7
279	#endif	250	#endif
280	}	251	}
281		252
282	IntRect HTMLCanvasElement::convertLogicalToDevice(const FloatRect& logicalRect) const
283	{
284	return IntRect(convertLogicalToDevice(logicalRect.location()), convertLogicalToDevice(logicalRect.size()));
285	}
286
287	IntSize HTMLCanvasElement::convertLogicalToDevice(const FloatSize& logicalSize) const
288	{
289	float pageScaleFactor = document()->frame() ? document()->frame()->page()->chrome()->scaleFactor() : 1.0f;
290	float wf = ceilf(logicalSize.width() * pageScaleFactor);
291	float hf = ceilf(logicalSize.height() * pageScaleFactor);
292
293	if (!(wf >= 1 && hf >= 1 && wf * hf <= MaxCanvasArea))
294	return IntSize();
295
296	return IntSize(static_cast<unsigned>(wf), static_cast<unsigned>(hf));
297	}
298
299	IntPoint HTMLCanvasElement::convertLogicalToDevice(const FloatPoint& logicalPos) const
300	{
301	float pageScaleFactor = document()->frame() ? document()->frame()->page()->chrome()->scaleFactor() : 1.0f;
302	float xf = logicalPos.x() * pageScaleFactor;
303	float yf = logicalPos.y() * pageScaleFactor;
304
305	return IntPoint(static_cast<unsigned>(xf), static_cast<unsigned>(yf));
306	}
307
308	void HTMLCanvasElement::createImageBuffer() const
309	{
310	ASSERT(!m_imageBuffer);
311
312	m_createdImageBuffer = true;
313
314	FloatSize unscaledSize(width(), height());
315	IntSize size = convertLogicalToDevice(unscaledSize);
316	if (!size.width() \|\| !size.height())
317	return;
318
319	m_imageBuffer = ImageBuffer::create(size);
320	// The convertLogicalToDevice MaxCanvasArea check should prevent common cases
321	// where ImageBuffer::create() returns NULL, however we could still be low on memory.
322	if (!m_imageBuffer)
323	return;
324	m_imageBuffer->context()->scale(FloatSize(size.width() / unscaledSize.width(), size.height() / unscaledSize.height()));
325	m_imageBuffer->context()->setShadowsIgnoreTransforms(true);
326	}
327
328	GraphicsContext* HTMLCanvasElement::drawingContext() const
329	{
330	return buffer() ? m_imageBuffer->context() : 0;
331	}
332
333	ImageBuffer* HTMLCanvasElement::buffer() const
334	{
335	if (!m_createdImageBuffer)
336	createImageBuffer();
337	return m_imageBuffer.get();
338	}
339
340	AffineTransform HTMLCanvasElement::baseTransform() const
341	{
342	ASSERT(m_createdImageBuffer);
343	FloatSize unscaledSize(width(), height());
344	IntSize size = convertLogicalToDevice(unscaledSize);
345	AffineTransform transform;
346	if (size.width() && size.height())
347	transform.scaleNonUniform(size.width() / unscaledSize.width(), size.height() / unscaledSize.height());
348	transform.multiply(m_imageBuffer->baseTransform());
349	return transform;
350	}
351
352	#if ENABLE(3D_CANVAS)	253	#if ENABLE(3D_CANVAS)
353	bool HTMLCanvasElement::is3D() const	254	bool HTMLCanvasElement::is3D() const
354	{	255	{

Lines 27-33 a/WebCore/html/HTMLCanvasElement.h_sec1
- a/WebCore/html/HTMLCanvasElement.h -38 / +5 lines
27	#ifndef HTMLCanvasElement_h	27	#ifndef HTMLCanvasElement_h
28	#define HTMLCanvasElement_h	28	#define HTMLCanvasElement_h
29		29
30	#include "AffineTransform.h"
31	#include "CanvasSurface.h"	30	#include "CanvasSurface.h"
32	#include "FloatRect.h"	31	#include "FloatRect.h"
33	#include "HTMLElement.h"	32	#include "HTMLElement.h"
Lines 40-52 namespace WebCore { a/WebCore/html/HTMLCanvasElement.h_sec2
40		39
41	class CanvasContextAttributes;	40	class CanvasContextAttributes;
42	class CanvasRenderingContext;	41	class CanvasRenderingContext;
43	class FloatPoint;
44	class FloatRect;
45	class FloatSize;
46	class GraphicsContext;	42	class GraphicsContext;
47	class HTMLCanvasElement;	43	class HTMLCanvasElement;
48	class ImageBuffer;
49	class IntPoint;
50	class IntSize;	44	class IntSize;
51		45
52	class CanvasObserver {	46	class CanvasObserver {
Lines 63-108 public: a/WebCore/html/HTMLCanvasElement.h_sec3
63	HTMLCanvasElement(const QualifiedName&, Document*);	57	HTMLCanvasElement(const QualifiedName&, Document*);
64	virtual ~HTMLCanvasElement();	58	virtual ~HTMLCanvasElement();
65		59
66	int width() const { return m_size.width(); }
67	int height() const { return m_size.height(); }
68	void setWidth(int);	60	void setWidth(int);
69	void setHeight(int);	61	void setHeight(int);
70		62
71	String toDataURL(const String& mimeType, ExceptionCode&);
72
73	CanvasRenderingContext* getContext(const String&, CanvasContextAttributes* attributes = 0);	63	CanvasRenderingContext* getContext(const String&, CanvasContextAttributes* attributes = 0);
74		64
75	const IntSize& size() const { return m_size; }	65	void setSize(const IntSize& newSize)
76	void setSize(const IntSize& size)
77	{	66	{
78	if (size == m_size)	67	if (newSize == size())
79	return;	68	return;
80	m_ignoreReset = true;	69	m_ignoreReset = true;
81	setWidth(size.width());	70	setWidth(newSize.width());
82	setHeight(size.height());	71	setHeight(newSize.height());
83	m_ignoreReset = false;	72	m_ignoreReset = false;
84	reset();	73	reset();
85	}	74	}
86		75
87	void willDraw(const FloatRect&);	76	virtual void willDraw(const FloatRect&);
88		77
89	void paint(GraphicsContext*, const IntRect&);	78	void paint(GraphicsContext*, const IntRect&);
90		79
91	GraphicsContext* drawingContext() const;
92
93	ImageBuffer* buffer() const;
94
95	IntRect convertLogicalToDevice(const FloatRect&) const;
96	IntSize convertLogicalToDevice(const FloatSize&) const;
97	IntPoint convertLogicalToDevice(const FloatPoint&) const;
98
99	void setOriginTainted() { m_originClean = false; }
100	bool originClean() const { return m_originClean; }
101
102	void setObserver(CanvasObserver* observer) { m_observer = observer; }	80	void setObserver(CanvasObserver* observer) { m_observer = observer; }
103		81
104	AffineTransform baseTransform() const;
105
106	CanvasRenderingContext* renderingContext() const { return m_context.get(); }	82	CanvasRenderingContext* renderingContext() const { return m_context.get(); }
107		83
108	#if ENABLE(3D_CANVAS)	84	#if ENABLE(3D_CANVAS)
Lines 118-141 private: a/WebCore/html/HTMLCanvasElement.h_sec4
118	virtual void parseMappedAttribute(MappedAttribute*);	94	virtual void parseMappedAttribute(MappedAttribute*);
119	virtual RenderObject* createRenderer(RenderArena, RenderStyle);	95	virtual RenderObject* createRenderer(RenderArena, RenderStyle);
120		96
121	void createImageBuffer() const;
122	void reset();	97	void reset();
123		98
124	static const float MaxCanvasArea;
125
126	bool m_rendererIsCanvas;	99	bool m_rendererIsCanvas;
127		100
128	OwnPtr<CanvasRenderingContext> m_context;	101	OwnPtr<CanvasRenderingContext> m_context;
129	IntSize m_size;
130	CanvasObserver* m_observer;	102	CanvasObserver* m_observer;
131		103
132	bool m_originClean;
133	bool m_ignoreReset;	104	bool m_ignoreReset;
134	FloatRect m_dirtyRect;	105	FloatRect m_dirtyRect;
135
136	// m_createdImageBuffer means we tried to malloc the buffer. We didn't necessarily get it.
137	mutable bool m_createdImageBuffer;
138	mutable OwnPtr<ImageBuffer> m_imageBuffer;
139	};	106	};
140		107
141	} //namespace	108	} //namespace