Remove support for -webkit-canvas and Document.getCSSCanvasContext.

third_party/WebKit/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 86 matching lines @@
 PassRefPtr<Image> createTransparentImage(const IntSize& size)
 {
     ASSERT(canCreateImageBuffer(size));
     RefPtr<SkSurface> surface = adoptRef(SkSurface::NewRasterN32Premul(size.width(), size.height()));
     surface->getCanvas()->clear(SK_ColorTRANSPARENT);
     return StaticBitmapImage::create(adoptRef(surface->newImageSnapshot()));
 }
 
 } // namespace
 
-DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(CanvasObserver);
-
 inline HTMLCanvasElement::HTMLCanvasElement(Document& document)
     : HTMLElement(canvasTag, document)
     , DocumentVisibilityObserver(document)
     , m_size(DefaultWidth, DefaultHeight)
     , m_ignoreReset(false)
-    , m_accelerationDisabled(false)
     , m_externallyAllocatedMemory(0)
     , m_originClean(true)
     , m_didFailToCreateImageBuffer(false)
     , m_imageBufferIsClear(false)
 {
     setHasCustomStyleCallbacks();
 }
 
 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_context.clear();
 #endif
 }
 
 WebThread* HTMLCanvasElement::getToBlobThreadInstance()
 {
     DEFINE_STATIC_LOCAL(OwnPtr<WebThread>, s_toBlobThread, ());
     if (!s_toBlobThread) {
         s_toBlobThread = adoptPtr(Platform::current()->createThread("Async toBlob"));
@@ skipping 33 matching lines @@
         m_imageBuffer->setFilterQuality(filterQuality);
     }
 }
 
 Node::InsertionNotificationRequest HTMLCanvasElement::insertedInto(ContainerNode* node)
 {
     setIsInCanvasSubtree(true);
     return HTMLElement::insertedInto(node);
 }
 
-void HTMLCanvasElement::addObserver(CanvasObserver* observer)
-{
-    m_observers.add(observer);
-}
-
-void HTMLCanvasElement::removeObserver(CanvasObserver* observer)
-{
-    m_observers.remove(observer);
-}
-
 void HTMLCanvasElement::setHeight(int value)
 {
     setIntegralAttribute(heightAttr, value);
 }
 
 void HTMLCanvasElement::setWidth(int value)
 {
     setIntegralAttribute(widthAttr, value);
 }
 
@@ skipping 87 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(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 36 matching lines @@
                 mappedDirtyRect.move(-lb->contentBoxOffset());
             }
             m_imageBuffer->finalizeFrame(mappedDirtyRect);
         } else {
             m_imageBuffer->finalizeFrame(m_dirtyRect);
         }
     }
     ASSERT(m_dirtyRect.isEmpty());
 }
 
-void HTMLCanvasElement::notifyObserversCanvasChanged(const FloatRect& rect)
-{
-    for (CanvasObserver* canvasObserver : m_observers)
-        canvasObserver->canvasChanged(this, rect);
-}
-
 void HTMLCanvasElement::reset()
 {
     if (m_ignoreReset)
         return;
 
     m_dirtyRect = FloatRect();
 
     bool ok;
     bool hadImageBuffer = hasImageBuffer();
 
@@ skipping 30 matching lines @@
         if (layoutObject->isCanvas()) {
             if (oldSize != size()) {
                 toLayoutHTMLCanvas(layoutObject)->canvasSizeChanged();
                 if (layoutBox() && layoutBox()->hasAcceleratedCompositing())
                     layoutBox()->contentChanged(CanvasChanged);
             }
             if (hadImageBuffer)
                 layoutObject->setShouldDoFullPaintInvalidation();
         }
     }
-
-    for (CanvasObserver* canvasObserver : m_observers)
-        canvasObserver->canvasResized(this);
 }
 
 bool HTMLCanvasElement::paintsIntoCanvasBuffer() const
 {
     ASSERT(m_context);
 
     if (!m_context->isAccelerated())
         return true;
 
     if (layoutBox() && layoutBox()->hasAcceleratedCompositing())
@@ skipping 196 matching lines @@
     if (document().settings() && document().settings()->disableReadingFromCanvas())
         return false;
     return m_originClean;
 }
 
 bool HTMLCanvasElement::shouldAccelerate(const IntSize& size) const
 {
     if (m_context && !m_context->is2d())
         return false;
 
-    if (m_accelerationDisabled)
-        return false;
-
     if (RuntimeEnabledFeatures::forceDisplayList2dCanvasEnabled())
         return false;
 
     Settings* settings = document().settings();
     if (!settings || !settings->accelerated2dCanvasEnabled())
         return false;
 
     int canvasPixelCount = size.width() * size.height();
 
     if (RuntimeEnabledFeatures::displayList2dCanvasEnabled()) {
@@ skipping 42 matching lines @@
     return true;
 }
 
 PassOwnPtr<ImageBufferSurface> HTMLCanvasElement::createImageBufferSurface(const IntSize& deviceSize, int* msaaSampleCount)
 {
     OpacityMode opacityMode = !m_context || m_context->hasAlpha() ? NonOpaque : Opaque;
 
     *msaaSampleCount = 0;
     if (is3D()) {
         // If 3d, but the use of the canvas will be for non-accelerated content
-        // (such as -webkit-canvas, then then make a non-accelerated
-        // ImageBuffer. This means copying the internal Image will require a
-        // pixel readback, but that is unavoidable in this case.
-        // FIXME: Actually, avoid setting m_accelerationDisabled at all when
-        // doing GPU-based rasterization.
-        if (m_accelerationDisabled)
-            return adoptPtr(new UnacceleratedImageBufferSurface(deviceSize, opacityMode));
+        // then make a non-accelerated ImageBuffer. This means copying the internal
+        // Image will require a pixel readback, but that is unavoidable in this case.
         return adoptPtr(new AcceleratedImageBufferSurface(deviceSize, opacityMode));
     }
 
     if (shouldAccelerate(deviceSize)) {
         if (document().settings())
             *msaaSampleCount = document().settings()->accelerated2dCanvasMSAASampleCount();
         OwnPtr<ImageBufferSurface> surface = adoptPtr(new Canvas2DImageBufferSurface(deviceSize, *msaaSampleCount, opacityMode, Canvas2DLayerBridge::EnableAcceleration));
         if (surface->isValid())
             return surface.release();
     }
@@ skipping 264 matching lines @@
 {
     return FloatSize(width(), height());
 }
 
 bool HTMLCanvasElement::isOpaque() const
 {
     return m_context && !m_context->hasAlpha();
 }
 
 } // blink