Removing the dependency on GraphicsContext for drawing images in 2D canvas

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 109 matching lines @@
 
 DEFINE_NODE_FACTORY(HTMLCanvasElement)
 
 HTMLCanvasElement::~HTMLCanvasElement()
 {
     v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-m_externallyAllocatedMemory);
 #if !ENABLE(OILPAN)
     for (CanvasObserver* canvasObserver : m_observers)
         canvasObserver->canvasDestroyed(this);
     // Ensure these go away before the ImageBuffer.
-    m_contextStateSaver.clear();
     m_context.clear();
 #endif
 }
 
 void HTMLCanvasElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
 {
     if (name == widthAttr || name == heightAttr)
         reset();
     HTMLElement::parseAttribute(name, value);
 }
@@ skipping 141 matching lines @@
 {
     if (rect.isEmpty())
         return;
     m_imageBufferIsClear = false;
     clearCopiedImage();
     if (layoutObject())
         layoutObject()->setMayNeedPaintInvalidation();
     m_dirtyRect.unite(rect);
     if (m_context && m_context->is2d() && hasImageBuffer())
         buffer()->didDraw(rect);
-    notifyObserversCanvasChanged(m_dirtyRect);
+    notifyObserversCanvasChanged(rect);
 }
 
 void HTMLCanvasElement::didFinalizeFrame()
 {
     if (m_dirtyRect.isEmpty())
         return;
 
     // Propagate the m_dirtyRect accumulated so far to the compositor
     // before restarting with a blank dirty rect.
     FloatRect srcRect(0, 0, size().width(), size().height());
@@ skipping 60 matching lines @@
     bool hadImageBuffer = hasImageBuffer();
 
     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())
         toCanvasRenderingContext2D(m_context.get())->reset();
 
     IntSize oldSize = size();
     IntSize newSize(w, h);
 
     // 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 (hadImageBuffer && oldSize == newSize && m_context && m_context->is2d() && !buffer()->isRecording()) {
         if (!m_imageBufferIsClear) {
@@ skipping 252 matching lines @@
 void HTMLCanvasElement::createImageBuffer()
 {
     createImageBufferInternal(nullptr);
     if (m_didFailToCreateImageBuffer && m_context->is2d())
         toCanvasRenderingContext2D(m_context.get())->loseContext(CanvasRenderingContext2D::SyntheticLostContext);
 }
 
 void HTMLCanvasElement::createImageBufferInternal(PassOwnPtr<ImageBufferSurface> externalSurface)
 {
     ASSERT(!m_imageBuffer);
-    ASSERT(!m_contextStateSaver);
 
     m_didFailToCreateImageBuffer = true;
     m_imageBufferIsClear = true;
 
     if (!canCreateImageBuffer(size()))
         return;
 
     int msaaSampleCount = 0;
     OwnPtr<ImageBufferSurface> surface;
     if (externalSurface) {
@@ skipping 13 matching lines @@
     m_didFailToCreateImageBuffer = false;
 
     updateExternallyAllocatedMemory();
 
     if (is3D()) {
         // Early out for WebGL canvases
         return;
     }
 
     m_imageBuffer->setClient(this);
-    m_imageBuffer->context()->setShouldClampToSourceRect(false);
-    m_imageBuffer->context()->disableAntialiasingOptimizationForHairlineImages();
-    m_imageBuffer->context()->setImageInterpolationQuality(CanvasDefaultInterpolationQuality);
     // Enabling MSAA overrides a request to disable antialiasing. This is true regardless of whether the
     // rendering mode is accelerated or not. For consistency, we don't want to apply AA in accelerated
     // canvases but not in unaccelerated canvases.
     if (!msaaSampleCount && document().settings() && !document().settings()->antialiased2dCanvasEnabled())
-        m_imageBuffer->context()->setShouldAntialias(false);
-#if ENABLE(ASSERT)
-    m_imageBuffer->context()->disableDestructionChecks(); // 2D canvas is allowed to leave context in an unfinalized state.
-#endif
-    m_contextStateSaver = adoptPtr(new GraphicsContextStateSaver(*m_imageBuffer->context()));
+        toCanvasRenderingContext2D(m_context.get())->setShouldAntialias(false);
 
     if (m_context)
         setNeedsCompositingUpdate();
 }
 
 void HTMLCanvasElement::notifySurfaceInvalid()
 {
     if (m_context && m_context->is2d()) {
         CanvasRenderingContext2D* context2d = toCanvasRenderingContext2D(m_context.get());
         context2d->loseContext(CanvasRenderingContext2D::RealLostContext);
@@ skipping 35 matching lines @@
     checkedExternallyAllocatedMemory *= height();
     intptr_t externallyAllocatedMemory;
     if (checkedExternallyAllocatedMemory.safeGet(externallyAllocatedMemory) == CheckedState::DidOverflow)
         externallyAllocatedMemory = std::numeric_limits<intptr_t>::max();
 
     // Subtracting two intptr_t that are known to be positive will never underflow.
     v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(externallyAllocatedMemory - m_externallyAllocatedMemory);
     m_externallyAllocatedMemory = externallyAllocatedMemory;
 }
 
-GraphicsContext* HTMLCanvasElement::drawingContext() const
-{
-    return buffer() ? m_imageBuffer->context() : nullptr;
-}
-
 SkCanvas* HTMLCanvasElement::drawingCanvas() const
 {
     return buffer() ? m_imageBuffer->canvas() : nullptr;
 }
 
 SkCanvas* HTMLCanvasElement::existingDrawingCanvas() const
 {
     if (!hasImageBuffer())
         return nullptr;
 
@@ skipping 40 matching lines @@
         needToUpdate |= m_context->paintRenderingResultsToCanvas(sourceBuffer);
     if (needToUpdate && buffer()) {
         m_copiedImage = buffer()->copyImage(CopyBackingStore, Unscaled);
         updateExternallyAllocatedMemory();
     }
     return m_copiedImage;
 }
 
 void HTMLCanvasElement::discardImageBuffer()
 {
-    m_contextStateSaver.clear(); // uses context owned by m_imageBuffer
     m_imageBuffer.clear();
     m_dirtyRect = FloatRect();
     updateExternallyAllocatedMemory();
 }
 
 void HTMLCanvasElement::clearCopiedImage()
 {
     if (m_copiedImage) {
         m_copiedImage.clear();
         updateExternallyAllocatedMemory();
@@ skipping 70 matching lines @@
 {
     return FloatSize(width(), height());
 }
 
 bool HTMLCanvasElement::isOpaque() const
 {
     return m_context && !m_context->hasAlpha();
 }
 
 } // blink