2D Canvas: Refactor code re-attempting to allocate an imageBuffer.

Source/core/html/HTMLCanvasElement.cpp

 /*
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 55 matching lines @@
 //In Skia, we will also limit width/height to 32767.
 static const float MaxSkiaDim = 32767.0F; // Maximum width/height in CSS pixels.
 
 HTMLCanvasElement::HTMLCanvasElement(const QualifiedName& tagName, Document& document)
     : HTMLElement(tagName, document)
     , m_size(DefaultWidth, DefaultHeight)
     , m_rendererIsCanvas(false)
     , m_ignoreReset(false)
     , m_deviceScaleFactor(1)
     , m_originClean(true)
-    , m_hasCreatedImageBuffer(false)
     , m_didClearImageBuffer(false)
     , m_accelerationDisabled(false)
     , m_externallyAllocatedMemory(0)
 {
     ASSERT(hasTagName(canvasTag));
     ScriptWrappable::init(this);
 }
 
 PassRefPtr<HTMLCanvasElement> HTMLCanvasElement::create(Document& document)
 {
@@ skipping 144 matching lines @@
     for (HashSet<CanvasObserver*>::iterator it = m_observers.begin(); it != end; ++it)
         (*it)->canvasChanged(this, rect);
 }
 
 void HTMLCanvasElement::reset()
 {
     if (m_ignoreReset)
         return;
 
     bool ok;
-    bool hadImageBuffer = hasCreatedImageBuffer();
+    bool hadImageBuffer = m_imageBuffer.get();
 
     int w = getAttribute(widthAttr).toInt(&ok);
     if (!ok || w < 0)
         w = DefaultWidth;
 
     int h = getAttribute(heightAttr).toInt(&ok);
     if (!ok || h < 0)
         h = DefaultHeight;
 
     if (m_contextStateSaver) {
         // Reset to the initial graphics context state.
         m_contextStateSaver->restore();
         m_contextStateSaver->save();
     }
 
     if (m_context && m_context->is2d()) {
         CanvasRenderingContext2D* context2D = static_cast<CanvasRenderingContext2D*>(m_context.get());
         context2D->reset();
     }
 
     IntSize oldSize = size();
     IntSize newSize(w, h);
     float newDeviceScaleFactor = 1;
 
     // If the size of an existing buffer matches, we can just clear it instead of reallocating.
     // This optimization is only done for 2D canvases for now.
-    if (m_hasCreatedImageBuffer && oldSize == newSize && m_deviceScaleFactor == newDeviceScaleFactor && m_context && m_context->is2d()) {
+    if (m_imageBuffer && oldSize == newSize && m_deviceScaleFactor == newDeviceScaleFactor && m_context && m_context->is2d()) {
         if (!m_didClearImageBuffer)
             clearImageBuffer();
         return;
     }
 
     m_deviceScaleFactor = newDeviceScaleFactor;
 
     setSurfaceSize(newSize);
 
     if (m_context && m_context->is3d() && oldSize != size())
@@ skipping 37 matching lines @@
 
     if (context->paintingDisabled())
         return;
 
     if (m_context) {
         if (!paintsIntoCanvasBuffer() && !document().printing())
             return;
         m_context->paintRenderingResultsToCanvas();
     }
 
-    if (hasCreatedImageBuffer()) {
-        ImageBuffer* imageBuffer = buffer();
-        if (imageBuffer) {
-            CompositeOperator compositeOperator = !m_context || m_context->hasAlpha() ? CompositeSourceOver : CompositeCopy;
-            if (m_presentedImage)
-                context->drawImage(m_presentedImage.get(), pixelSnappedIntRect(r), compositeOperator, DoNotRespectImageOrientation, useLowQualityScale);
-            else
-                context->drawImageBuffer(imageBuffer, pixelSnappedIntRect(r), compositeOperator, BlendModeNormal, useLowQualityScale);
-        }
+    ImageBuffer* imageBuffer = buffer();
+    if (imageBuffer) {
+        CompositeOperator compositeOperator = !m_context || m_context->hasAlpha() ? CompositeSourceOver : CompositeCopy;
+        if (m_presentedImage)
+            context->drawImage(m_presentedImage.get(), pixelSnappedIntRect(r), compositeOperator, DoNotRespectImageOrientation, useLowQualityScale);
+        else
+            context->drawImageBuffer(imageBuffer, pixelSnappedIntRect(r), compositeOperator, BlendModeNormal, useLowQualityScale);
     }
 
     if (is3D())
         static_cast<WebGLRenderingContext*>(m_context.get())->markLayerComposited();
 }
 
 bool HTMLCanvasElement::is3D() const
 {
     return m_context && m_context->is3d();
 }
 
 void HTMLCanvasElement::makePresentationCopy()
 {
     if (!m_presentedImage) {
         // The buffer contains the last presented data, so save a copy of it.
         m_presentedImage = buffer()->copyImage(CopyBackingStore, Unscaled);
     }
 }
 
 void HTMLCanvasElement::clearPresentationCopy()
 {
     m_presentedImage.clear();
 }
 
 void HTMLCanvasElement::setSurfaceSize(const IntSize& size)
 {
     m_size = size;
-    m_hasCreatedImageBuffer = false;
     m_contextStateSaver.clear();
     m_imageBuffer.clear();
     setExternallyAllocatedMemory(0);
     clearCopiedImage();
 }
 
 String HTMLCanvasElement::toEncodingMimeType(const String& mimeType)
 {
     String lowercaseMimeType = mimeType.lower();
 
@@ skipping 98 matching lines @@
     if (!WebKit::Platform::current()->canAccelerate2dCanvas())
         return false;
 
     return true;
 }
 
 void HTMLCanvasElement::createImageBuffer()
 {
     ASSERT(!m_imageBuffer);
 
-    m_hasCreatedImageBuffer = true;
     m_didClearImageBuffer = true;
 
     FloatSize logicalSize = size();
     FloatSize deviceSize = convertLogicalToDevice(logicalSize);
     if (!deviceSize.isExpressibleAsIntSize())
         return;
 
     if (deviceSize.width() * deviceSize.height() > MaxCanvasArea)
         return;
 
@@ skipping 34 matching lines @@
     m_externallyAllocatedMemory = externallyAllocatedMemory;
 }
 
 GraphicsContext* HTMLCanvasElement::drawingContext() const
 {
     return buffer() ? m_imageBuffer->context() : 0;
 }
 
 GraphicsContext* HTMLCanvasElement::existingDrawingContext() const
 {
-    if (!m_hasCreatedImageBuffer)
+    if (!m_imageBuffer)
         return 0;
 
     return drawingContext();
 }
 
 ImageBuffer* HTMLCanvasElement::buffer() const
 {
-    if (!m_hasCreatedImageBuffer)
+    if (!m_imageBuffer)
         const_cast<HTMLCanvasElement*>(this)->createImageBuffer();
     return m_imageBuffer.get();
 }
 
 Image* HTMLCanvasElement::copiedImage() const
 {
     if (!m_copiedImage && buffer()) {
         if (m_context)
             m_context->paintRenderingResultsToCanvas();
         m_copiedImage = buffer()->copyImage(CopyBackingStore, Unscaled);
     }
     return m_copiedImage.get();
 }
 
 void HTMLCanvasElement::clearImageBuffer()
 {
-    ASSERT(m_hasCreatedImageBuffer);
+    ASSERT(m_imageBuffer);
     ASSERT(!m_didClearImageBuffer);
     ASSERT(m_context);
 
     m_didClearImageBuffer = true;
 
     if (m_context->is2d()) {
         CanvasRenderingContext2D* context2D = static_cast<CanvasRenderingContext2D*>(m_context.get());
         // No need to undo transforms/clip/etc. because we are called right after the context is reset.
         context2D->clearRect(0, 0, width(), height());
     }
 }
 
 void HTMLCanvasElement::clearCopiedImage()
 {
     m_copiedImage.clear();
     m_didClearImageBuffer = false;
 }
 
 AffineTransform HTMLCanvasElement::baseTransform() const
 {
-    ASSERT(m_hasCreatedImageBuffer);
+    ASSERT(m_imageBuffer);
     FloatSize unscaledSize = size();
     FloatSize deviceSize = convertLogicalToDevice(unscaledSize);
     IntSize size(deviceSize.width(), deviceSize.height());
     AffineTransform transform;
     if (size.width() && size.height())
         transform.scaleNonUniform(size.width() / unscaledSize.width(), size.height() / unscaledSize.height());
     return m_imageBuffer->baseTransform() * transform;
 }
 
 }