Implement image-rendering:pixelated for accelerated 2D canvases.

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 16 matching lines @@
 
 #include "config.h"
 #include "core/html/HTMLCanvasElement.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "core/HTMLNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
+#include "core/dom/NodeRenderStyle.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/ImageData.h"
 #include "core/html/canvas/Canvas2DContextAttributes.h"
 #include "core/html/canvas/CanvasRenderingContext2D.h"
 #include "core/html/canvas/WebGLContextAttributes.h"
 #include "core/html/canvas/WebGLContextEvent.h"
 #include "core/html/canvas/WebGLRenderingContext.h"
 #include "core/rendering/RenderHTMLCanvas.h"
 #include "core/rendering/RenderLayer.h"
@@ skipping 58 matching lines @@
     : 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()
 {
     resetDirtyRect();
     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);
 }
 
 RenderObject* HTMLCanvasElement::createRenderer(RenderStyle* style)
 {
+    if (hasImageBuffer())
+        m_imageBuffer->setFilterLevel(style->imageRendering() == ImageRenderingPixelated ? SkPaint::kNone_FilterLevel : SkPaint::kLow_FilterLevel);
     LocalFrame* frame = document().frame();
     if (frame && frame->script().canExecuteScripts(NotAboutToExecuteScript))
         return new RenderHTMLCanvas(this);
     return HTMLElement::createRenderer(style);
 }
 
+void HTMLCanvasElement::didRecalcStyle(StyleRecalcChange)
+{
+    if (!hasImageBuffer())
+        return;
+    m_imageBuffer->setFilterLevel(renderStyle()->imageRendering() == ImageRenderingPixelated ? SkPaint::kNone_FilterLevel : SkPaint::kLow_FilterLevel);

[Justin Novosad, 2014/12/04 15:27:07]

This seems wrong to me. We should always use the computedStyle. Is the bug
caused by the fact that the style is not recomputed when an offscreen canvas is
attached to the DOM? If that is the issue, then the solution should be to make
sure style recalculation are properly triggered at that time.

[jackhou1, 2014/12/05 02:00:58]

Done.

+}
+
 Node::InsertionNotificationRequest HTMLCanvasElement::insertedInto(ContainerNode* node)
 {
     setIsInCanvasSubtree(true);
     return HTMLElement::insertedInto(node);
 }
 
 void HTMLCanvasElement::addObserver(CanvasObserver* observer)
 {
     m_observers.add(observer);
 }
@@ skipping 429 matching lines @@
     m_imageBufferIsClear = true;
 
     if (!canCreateImageBuffer(size()))
         return;
 
     int msaaSampleCount;
     OwnPtr<ImageBufferSurface> surface = createImageBufferSurface(size(), &msaaSampleCount);
     if (!surface->isValid())
         return;
 
+    RenderStyle* style = renderStyle();

[Justin Novosad, 2014/12/04 15:27:07]

Same thing here

[jackhou1, 2014/12/05 02:00:58]

Done.

+    bool pixelated = style && (style->imageRendering() == ImageRenderingPixelated || style->imageRendering() == ImageRenderingOptimizeContrast);
+
     m_imageBuffer = ImageBuffer::create(surface.release());
     m_imageBuffer->setClient(this);
+    m_imageBuffer->setFilterLevel(pixelated ? SkPaint::kNone_FilterLevel : SkPaint::kLow_FilterLevel);
 
     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);
+    m_imageBuffer->context()->setImageInterpolationQuality(pixelated ? InterpolationLow : 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);
     // GraphicsContext's defaults don't always agree with the 2d canvas spec.
     // See CanvasRenderingContext2D::State::State() for more information.
     m_imageBuffer->context()->setMiterLimit(10);
     m_imageBuffer->context()->setStrokeThickness(1);
 #if ENABLE(ASSERT)
@@ skipping 150 matching lines @@
     if (!isPaintable()) {
         *status = InvalidSourceImageStatus;
         return nullptr;
     }
 
     if (!m_context) {
         *status = NormalSourceImageStatus;
         return createTransparentImage(size());
     }
 
+    m_imageBuffer->willAccessPixels();
+
     if (m_context->is3d()) {
         m_context->paintRenderingResultsToCanvas(BackBuffer);
         *status = ExternalSourceImageStatus;
 
         // can't create SkImage from WebGLImageBufferSurface (contains only SkBitmap)
         return buffer()->copyImage(DontCopyBackingStore, Unscaled);
     }
 
     RefPtr<SkImage> image = buffer()->newImageSnapshot();
     if (image) {
         *status = NormalSourceImageStatus;
         return StaticBitmapImage::create(image.release());
     }
 
     *status = InvalidSourceImageStatus;
     return nullptr;
 }
 
 bool HTMLCanvasElement::wouldTaintOrigin(SecurityOrigin*) const
 {
     return !originClean();
 }
 
 FloatSize HTMLCanvasElement::sourceSize() const
 {
     return FloatSize(width(), height());
 }
 
 }