Revert of Fix ASSERT(m_canvas) failures when contextDisabled()

Source/platform/graphics/GraphicsContext.cpp

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google Inc. 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.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 35 matching lines @@
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/effects/SkBlurMaskFilter.h"
 #include "third_party/skia/include/effects/SkCornerPathEffect.h"
 #include "third_party/skia/include/effects/SkDropShadowImageFilter.h"
 #include "third_party/skia/include/effects/SkLumaColorFilter.h"
 #include "third_party/skia/include/effects/SkMatrixImageFilter.h"
 #include "third_party/skia/include/effects/SkPictureImageFilter.h"
 #include "third_party/skia/include/gpu/GrRenderTarget.h"
 #include "third_party/skia/include/gpu/GrTexture.h"
-#include "third_party/skia/include/utils/SkNullCanvas.h"
 #include "wtf/Assertions.h"
 #include "wtf/MathExtras.h"
 
 namespace blink {
 
 class GraphicsContext::RecordingState {
     WTF_MAKE_FAST_ALLOCATED;
     WTF_MAKE_NONCOPYABLE(RecordingState);
 public:
     static PassOwnPtr<RecordingState> Create(SkCanvas* canvas, const SkMatrix& matrix)
     {
         return adoptPtr(new RecordingState(canvas, matrix));
     }
 
     SkPictureRecorder& recorder() { return m_recorder; }
     SkCanvas* canvas() const { return m_savedCanvas; }
     const SkMatrix& matrix() const { return m_savedMatrix; }
 
 private:
     explicit RecordingState(SkCanvas* canvas, const SkMatrix& matrix)
         : m_savedCanvas(canvas)
         , m_savedMatrix(matrix)
     { }
 
     SkPictureRecorder m_recorder;
     SkCanvas* m_savedCanvas;
     const SkMatrix m_savedMatrix;
 };
 
-static SkCanvas* nullCanvas()
-{
-    DEFINE_STATIC_LOCAL(RefPtr<SkCanvas>, nullCanvas, (adoptRef(SkCreateNullCanvas())));
-    return nullCanvas.get();
-}
-
 GraphicsContext::GraphicsContext(SkCanvas* canvas, DisplayItemList* displayItemList, DisabledMode disableContextOrPainting)
     : m_canvas(canvas)
     , m_displayItemList(displayItemList)
     , m_clipRecorderStack(0)
     , m_paintStateStack()
     , m_paintStateIndex(0)
     , m_annotationMode(0)
     , m_layerCount(0)
 #if ENABLE(ASSERT)
     , m_annotationCount(0)
@@ skipping 27 matching lines @@
 #endif
 }
 
 void GraphicsContext::resetCanvas(SkCanvas* canvas)
 {
     m_canvas = canvas;
 }
 
 void GraphicsContext::save()
 {
+    if (contextDisabled())
+        return;
+
     m_paintState->incrementSaveCount();
 
     ASSERT(m_canvas);
     m_canvas->save();
 }
 
 void GraphicsContext::restore()
 {
+    if (contextDisabled())
+        return;
+
     if (!m_paintStateIndex && !m_paintState->saveCount()) {
         WTF_LOG_ERROR("ERROR void GraphicsContext::restore() stack is empty");
         return;
     }
 
     if (m_paintState->saveCount()) {
         m_paintState->decrementSaveCount();
     } else {
         m_paintStateIndex--;
         m_paintState = m_paintStateStack[m_paintStateIndex].get();
@@ skipping 12 matching lines @@
     ASSERT(m_paintStateStack.size() > m_paintStateIndex);
     for (unsigned i = 0; i <= m_paintStateIndex; ++i)
         count += m_paintStateStack[i]->saveCount();
 
     return count;
 }
 #endif
 
 void GraphicsContext::saveLayer(const SkRect* bounds, const SkPaint* paint)
 {
+    if (contextDisabled())
+        return;
+
     ASSERT(m_canvas);
+
     m_canvas->saveLayer(bounds, paint);
 }
 
 void GraphicsContext::restoreLayer()
 {
+    if (contextDisabled())
+        return;
+
     ASSERT(m_canvas);
+
     m_canvas->restore();
 }
 
 void GraphicsContext::beginAnnotation(const AnnotationList& annotations)
 {
+    if (contextDisabled())
+        return;
+
     ASSERT(m_canvas);
 
     canvas()->beginCommentGroup("GraphicsContextAnnotation");
 
     AnnotationList::const_iterator end = annotations.end();
     for (AnnotationList::const_iterator it = annotations.begin(); it != end; ++it)
         canvas()->addComment(it->first, it->second.ascii().data());
 
 #if ENABLE(ASSERT)
     ++m_annotationCount;
 #endif
 }
 
 void GraphicsContext::endAnnotation()
 {
+    if (contextDisabled())
+        return;
+
     ASSERT(m_canvas);
     ASSERT(m_annotationCount > 0);
     canvas()->endCommentGroup();
 
 #if ENABLE(ASSERT)
     --m_annotationCount;
 #endif
 }
 
 #if ENABLE(ASSERT)
 void GraphicsContext::setInDrawingRecorder(bool val)
 {
     // Nested drawing recorers are not allowed.
     ASSERT(!val || !m_inDrawingRecorder);
     m_inDrawingRecorder = val;
 }
 #endif
 
 void GraphicsContext::setStrokePattern(PassRefPtr<Pattern> pattern, float alpha)
 {
+    if (contextDisabled())
+        return;
+
     ASSERT(pattern);
     if (!pattern) {
         setStrokeColor(Color::black);
         return;
     }
 
     mutableState()->setStrokePattern(pattern, alpha);
 }
 
 void GraphicsContext::setStrokeGradient(PassRefPtr<Gradient> gradient, float alpha)
 {
+    if (contextDisabled())
+        return;
+
     ASSERT(gradient);
     if (!gradient) {
         setStrokeColor(Color::black);
         return;
     }
     mutableState()->setStrokeGradient(gradient, alpha);
 }
 
 void GraphicsContext::setFillPattern(PassRefPtr<Pattern> pattern, float alpha)
 {
+    if (contextDisabled())
+        return;
+
     ASSERT(pattern);
     if (!pattern) {
         setFillColor(Color::black);
         return;
     }
 
     mutableState()->setFillPattern(pattern, alpha);
 }
 
 void GraphicsContext::setFillGradient(PassRefPtr<Gradient> gradient, float alpha)
 {
+    if (contextDisabled())
+        return;
+
     ASSERT(gradient);
     if (!gradient) {
         setFillColor(Color::black);
         return;
     }
 
     mutableState()->setFillGradient(gradient, alpha);
 }
 
 void GraphicsContext::setShadow(const FloatSize& offset, float blur, const Color& color,
     DrawLooperBuilder::ShadowTransformMode shadowTransformMode,
     DrawLooperBuilder::ShadowAlphaMode shadowAlphaMode, ShadowMode shadowMode)
 {
+    if (contextDisabled())
+        return;
+
     OwnPtr<DrawLooperBuilder> drawLooperBuilder = DrawLooperBuilder::create();
     if (!color.alpha()) {
         if (shadowMode == DrawShadowOnly) {
             // shadow only, but there is no shadow: use an empty draw looper to disable rendering of the source primitive
             setDrawLooper(drawLooperBuilder.release());
             return;
         }
         clearShadow();
         return;
     }
@@ skipping 12 matching lines @@
         // These constants are from RadiusToSigma() from DrawLooperBuilder.cpp.
         const SkScalar sigma = 0.288675f * blur + 0.5f;
         SkDropShadowImageFilter::ShadowMode dropShadowMode = shadowMode == DrawShadowAndForeground ? SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode : SkDropShadowImageFilter::kDrawShadowOnly_ShadowMode;
         RefPtr<SkImageFilter> filter = adoptRef(SkDropShadowImageFilter::Create(offset.width(), offset.height(), sigma, sigma, skColor, dropShadowMode));
         setDropShadowImageFilter(filter);
     }
 }
 
 void GraphicsContext::setDrawLooper(PassOwnPtr<DrawLooperBuilder> drawLooperBuilder)
 {
+    if (contextDisabled())
+        return;
+
     mutableState()->setDrawLooper(drawLooperBuilder->detachDrawLooper());
 }
 
 void GraphicsContext::clearDrawLooper()
 {
+    if (contextDisabled())
+        return;
+
     mutableState()->clearDrawLooper();
 }
 
 void GraphicsContext::setDropShadowImageFilter(PassRefPtr<SkImageFilter> imageFilter)
 {
+    if (contextDisabled())
+        return;
+
     mutableState()->setDropShadowImageFilter(imageFilter);
 }
 
 void GraphicsContext::clearDropShadowImageFilter()
 {
+    if (contextDisabled())
+        return;
+
     mutableState()->clearDropShadowImageFilter();
 }
 
 bool GraphicsContext::hasShadow() const
 {
     return !!immutableState()->drawLooper() || !!immutableState()->dropShadowImageFilter();
 }
 
 bool GraphicsContext::getTransformedClipBounds(FloatRect* bounds) const
 {
+    if (contextDisabled())
+        return false;
     ASSERT(m_canvas);
     SkIRect skIBounds;
     if (!m_canvas->getClipDeviceBounds(&skIBounds))
         return false;
     SkRect skBounds = SkRect::Make(skIBounds);
     *bounds = FloatRect(skBounds);
     return true;
 }
 
 SkMatrix GraphicsContext::getTotalMatrix() const
 {
     // FIXME: this is a hack to avoid changing all call sites of getTotalMatrix() to not use this method.
     // The code needs to be cleand up after Slimming Paint is launched.
     if (RuntimeEnabledFeatures::slimmingPaintEnabled())
         return SkMatrix::I();
 
-    if (!m_canvas)
+    if (contextDisabled() || !m_canvas)
         return SkMatrix::I();
 
     ASSERT(m_canvas);
 
     if (!isRecording())
         return m_canvas->getTotalMatrix();
 
     SkMatrix totalMatrix = m_recordingStateStack.last()->matrix();
     totalMatrix.preConcat(m_canvas->getTotalMatrix());
 
     return totalMatrix;
 }
 
 void GraphicsContext::setCompositeOperation(SkXfermode::Mode xferMode)
 {
+    if (contextDisabled())
+        return;
     mutableState()->setCompositeOperation(xferMode);
 }
 
 SkXfermode::Mode GraphicsContext::compositeOperation() const
 {
     return immutableState()->compositeOperation();
 }
 
 CompositeOperator GraphicsContext::compositeOperationDeprecated() const
 {
@@ skipping 10 matching lines @@
     GraphicsContextState* stateToSet = mutableState();
 
     // We only support one active color filter at the moment. If (when) this becomes a problem,
     // we should switch to using color filter chains (Skia work in progress).
     ASSERT(!stateToSet->colorFilter());
     stateToSet->setColorFilter(WebCoreColorFilterToSkiaColorFilter(colorFilter));
 }
 
 bool GraphicsContext::readPixels(const SkImageInfo& info, void* pixels, size_t rowBytes, int x, int y)
 {
+    if (contextDisabled())
+        return false;
+
     ASSERT(m_canvas);
     return m_canvas->readPixels(info, pixels, rowBytes, x, y);
 }
 
 void GraphicsContext::setMatrix(const SkMatrix& matrix)
 {
+    if (contextDisabled())
+        return;
+
     ASSERT(m_canvas);
+
     m_canvas->setMatrix(matrix);
 }
 
 void GraphicsContext::concat(const SkMatrix& matrix)
 {
+    if (contextDisabled())
+        return;
+
     if (matrix.isIdentity())
         return;
 
     ASSERT(m_canvas);
 
     m_canvas->concat(matrix);
 }
 
 void GraphicsContext::beginTransparencyLayer(float opacity, const FloatRect* bounds)
 {
     beginLayer(opacity, immutableState()->compositeOperation(), bounds);
 }
 
 void GraphicsContext::beginLayer(float opacity, SkXfermode::Mode xfermode, const FloatRect* bounds, ColorFilter colorFilter, SkImageFilter* imageFilter)
 {
+    if (contextDisabled())
+        return;
+
     SkPaint layerPaint;
     layerPaint.setAlpha(static_cast<unsigned char>(opacity * 255));
     layerPaint.setXfermodeMode(xfermode);
     layerPaint.setColorFilter(WebCoreColorFilterToSkiaColorFilter(colorFilter).get());
     layerPaint.setImageFilter(imageFilter);
 
     if (bounds) {
         SkRect skBounds = WebCoreFloatRectToSKRect(*bounds);
         saveLayer(&skBounds, &layerPaint);
     } else {
         saveLayer(0, &layerPaint);
     }
 
     ++m_layerCount;
 }
 
 void GraphicsContext::endLayer()
 {
+    if (contextDisabled())
+        return;
+
     restoreLayer();
 
     ASSERT(m_layerCount > 0);
     --m_layerCount;
 }
 
 void GraphicsContext::beginRecording(const FloatRect& bounds, uint32_t recordFlags)
 {
+    if (contextDisabled())
+        return;
+
     m_recordingStateStack.append(
         RecordingState::Create(m_canvas, getTotalMatrix()));
-    m_canvas = contextDisabled() ? nullCanvas() : m_recordingStateStack.last()->recorder().beginRecording(bounds, 0, recordFlags);
+    m_canvas = m_recordingStateStack.last()->recorder().beginRecording(bounds, 0, recordFlags);
 }
 
 PassRefPtr<const SkPicture> GraphicsContext::endRecording()
 {
+    if (contextDisabled())
+        return nullptr;
+
     ASSERT(!m_recordingStateStack.isEmpty());
     RecordingState* recording = m_recordingStateStack.last().get();
-    RefPtr<const SkPicture> picture;
-    if (!contextDisabled()) {
-        picture = adoptRef(recording->recorder().endRecordingAsPicture());
-        ASSERT(picture);
-    }
+    RefPtr<const SkPicture> picture = adoptRef(recording->recorder().endRecordingAsPicture());
+    m_canvas = recording->canvas();
 
-    m_canvas = recording->canvas();
     m_recordingStateStack.removeLast();
 
+    ASSERT(picture);
     return picture.release();
 }
 
 bool GraphicsContext::isRecording() const
 {
     return !m_recordingStateStack.isEmpty();
 }
 
 void GraphicsContext::drawPicture(const SkPicture* picture)
 {
     ASSERT(m_canvas);
 
     // FIXME: SP currently builds empty-bounds pictures in some cases. This is a temp
     // workaround, but the problem should be fixed: empty-bounds pictures are going to be culled
     // on playback anyway.
     bool cullEmptyPictures = !RuntimeEnabledFeatures::slimmingPaintEnabled();
-    if (!picture || (picture->cullRect().isEmpty() && cullEmptyPictures))
+    if (contextDisabled() || !picture || (picture->cullRect().isEmpty() && cullEmptyPictures))
         return;
 
     m_canvas->drawPicture(picture);
 }
 
 void GraphicsContext::compositePicture(SkPicture* picture, const FloatRect& dest, const FloatRect& src, SkXfermode::Mode op)
 {
     ASSERT(m_canvas);
-    if (!picture)
+    if (contextDisabled() || !picture)
         return;
 
     SkPaint picturePaint;
     picturePaint.setXfermodeMode(op);
     m_canvas->save();
     SkRect sourceBounds = WebCoreFloatRectToSKRect(src);
     SkRect skBounds = WebCoreFloatRectToSKRect(dest);
     SkMatrix pictureTransform;
     pictureTransform.setRectToRect(sourceBounds, skBounds, SkMatrix::kFill_ScaleToFit);
     m_canvas->concat(pictureTransform);
     RefPtr<SkPictureImageFilter> pictureFilter = adoptRef(SkPictureImageFilter::CreateForLocalSpace(picture, sourceBounds, static_cast<SkPaint::FilterLevel>(imageInterpolationQuality())));
     picturePaint.setImageFilter(pictureFilter.get());
     m_canvas->saveLayer(&sourceBounds, &picturePaint);
     m_canvas->restore();
     m_canvas->restore();
 }
 
 void GraphicsContext::fillPolygon(size_t numPoints, const FloatPoint* points, const Color& color,
     bool shouldAntialias)
 {
+    if (contextDisabled())
+        return;
+
     ASSERT(numPoints > 2);
 
     SkPath path;
     setPathFromPoints(&path, numPoints, points);
 
     SkPaint paint(immutableState()->fillPaint());
     paint.setAntiAlias(shouldAntialias);
     paint.setColor(color.rgb());
 
     drawPath(path, paint);
@@ skipping 47 matching lines @@
     // Inner rect
     paint.setAlpha(128);
     paint.setStrokeWidth(paint.getStrokeWidth() * 0.5f);
     drawRRect(rrect, paint);
 #endif
 }
 
 void GraphicsContext::drawFocusRing(const Path& focusRingPath, int width, int offset, const Color& color)
 {
     // FIXME: Implement support for offset.
+    if (contextDisabled())
+        return;
+
     drawFocusRingPath(focusRingPath.skPath(), color, width);
 }
 
 void GraphicsContext::drawFocusRing(const Vector<IntRect>& rects, int width, int offset, const Color& color)
 {
+    if (contextDisabled())
+        return;
+
     unsigned rectCount = rects.size();
     if (!rectCount)
         return;
 
     SkRegion focusRingRegion;
     const int outset = focusRingOutset(offset);
     for (unsigned i = 0; i < rectCount; i++) {
         SkIRect r = rects[i];
         r.inset(-outset, -outset);
         focusRingRegion.op(r, SkRegion::kUnion_Op);
@@ skipping 17 matching lines @@
     if (shadowSpread < 0)
         bounds.inflate(-shadowSpread);
 
     IntRect offsetBounds = bounds;
     offsetBounds.move(-shadowOffset);
     return unionRect(bounds, offsetBounds);
 }
 
 void GraphicsContext::drawInnerShadow(const FloatRoundedRect& rect, const Color& shadowColor, const IntSize shadowOffset, int shadowBlur, int shadowSpread, Edges clippedEdges)
 {
+    if (contextDisabled())
+        return;
+
     FloatRect holeRect(rect.rect());
     holeRect.inflate(-shadowSpread);
 
     if (holeRect.isEmpty()) {
         if (rect.isRounded())
             fillRoundedRect(rect, shadowColor);
         else
             fillRect(rect.rect(), shadowColor);
         return;
     }
@@ skipping 34 matching lines @@
         DrawLooperBuilder::ShadowRespectsTransforms, DrawLooperBuilder::ShadowIgnoresAlpha);
     setDrawLooper(drawLooperBuilder.release());
     fillRectWithRoundedHole(outerRect, roundedHole, fillColor);
     restore();
     clearDrawLooper();
 }
 
 void GraphicsContext::drawLine(const IntPoint& point1, const IntPoint& point2)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
 
     StrokeStyle penStyle = strokeStyle();
     if (penStyle == NoStroke)
         return;
 
     FloatPoint p1 = point1;
     FloatPoint p2 = point2;
     bool isVerticalLine = (p1.x() == p2.x());
     int width = roundf(strokeThickness());
 
@@ skipping 25 matching lines @@
     }
 
     adjustLineToPixelBoundaries(p1, p2, width, penStyle);
     SkPoint pts[2] = { p1.data(), p2.data() };
 
     m_canvas->drawPoints(SkCanvas::kLines_PointMode, 2, pts, paint);
 }
 
 void GraphicsContext::drawLineForDocumentMarker(const FloatPoint& pt, float width, DocumentMarkerLineStyle style)
 {
+    if (contextDisabled())
+        return;
+
     // Use 2x resources for a device scale factor of 1.5 or above.
     int deviceScaleFactor = m_deviceScaleFactor > 1.5f ? 2 : 1;
 
     // Create the pattern we'll use to draw the underline.
     int index = style == DocumentMarkerGrammarLineStyle ? 1 : 0;
     static SkBitmap* misspellBitmap1x[2] = { 0, 0 };
     static SkBitmap* misspellBitmap2x[2] = { 0, 0 };
     SkBitmap** misspellBitmap = deviceScaleFactor == 2 ? misspellBitmap2x : misspellBitmap1x;
     if (!misspellBitmap[index]) {
 #if OS(MACOSX)
@@ skipping 107 matching lines @@
         save();
         scale(0.5, 0.5);
     }
     drawRect(rect, paint);
     if (deviceScaleFactor == 2)
         restore();
 }
 
 void GraphicsContext::drawLineForText(const FloatPoint& pt, float width, bool printing)
 {
+    if (contextDisabled())
+        return;
+
     if (width <= 0)
         return;
 
     SkPaint paint;
     switch (strokeStyle()) {
     case NoStroke:
     case SolidStroke:
     case DoubleStroke:
     case WavyStroke: {
         int thickness = SkMax32(static_cast<int>(strokeThickness()), 1);
@@ skipping 17 matching lines @@
         return;
     }
     }
 
     ASSERT_NOT_REACHED();
 }
 
 // Draws a filled rectangle with a stroked border.
 void GraphicsContext::drawRect(const IntRect& rect)
 {
+    if (contextDisabled())
+        return;
+
     ASSERT(!rect.isEmpty());
     if (rect.isEmpty())
         return;
 
     SkRect skRect = rect;
     int fillcolorNotTransparent = immutableState()->fillColor().rgb() & 0xFF000000;
     if (fillcolorNotTransparent)
         drawRect(skRect, immutableState()->fillPaint());
 
     if (immutableState()->strokeData().style() != NoStroke
         && immutableState()->strokeColor().alpha()) {
         // Stroke a width: 1 inset border
         SkPaint paint(immutableState()->fillPaint());
         paint.setColor(effectiveStrokeColor());
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setStrokeWidth(1);
 
         skRect.inset(0.5f, 0.5f);
         drawRect(skRect, paint);
     }
 }
 
 void GraphicsContext::drawText(const Font& font, const TextRunPaintInfo& runInfo, const FloatPoint& point)
 {
+    if (contextDisabled())
+        return;
+
     font.drawText(this, runInfo, point);
 }
 
 void GraphicsContext::drawEmphasisMarks(const Font& font, const TextRunPaintInfo& runInfo, const AtomicString& mark, const FloatPoint& point)
 {
+    if (contextDisabled())
+        return;
+
     font.drawEmphasisMarks(this, runInfo, mark, point);
 }
 
 void GraphicsContext::drawBidiText(const Font& font, const TextRunPaintInfo& runInfo, const FloatPoint& point, Font::CustomFontNotReadyAction customFontNotReadyAction)
 {
+    if (contextDisabled())
+        return;
+
     font.drawBidiText(this, runInfo, point, customFontNotReadyAction);
 }
 
 void GraphicsContext::drawHighlightForText(const Font& font, const TextRun& run, const FloatPoint& point, int h, const Color& backgroundColor, int from, int to)
 {
+    if (contextDisabled())
+        return;
+
     fillRect(font.selectionRectForText(run, point, h, from, to), backgroundColor);
 }
 
 void GraphicsContext::drawImage(Image* image, const IntPoint& p, SkXfermode::Mode op, RespectImageOrientationEnum shouldRespectImageOrientation)
 {
     if (!image)
         return;
     drawImage(image, FloatRect(IntRect(p, image->size())), FloatRect(FloatPoint(), FloatSize(image->size())), op, shouldRespectImageOrientation);
 }
 
 void GraphicsContext::drawImage(Image* image, const IntRect& r, SkXfermode::Mode op, RespectImageOrientationEnum shouldRespectImageOrientation)
 {
     if (!image)
         return;
     drawImage(image, FloatRect(r), FloatRect(FloatPoint(), FloatSize(image->size())), op, shouldRespectImageOrientation);
 }
 
 void GraphicsContext::drawImage(Image* image, const FloatRect& dest)
 {
     if (!image)
         return;
     drawImage(image, dest, FloatRect(IntRect(IntPoint(), image->size())));
 }
 
 void GraphicsContext::drawImage(Image* image, const FloatRect& dest, const FloatRect& src, SkXfermode::Mode op, RespectImageOrientationEnum shouldRespectImageOrientation)
 {
-    if (!image)
+    if (contextDisabled() || !image)
         return;
     image->draw(this, dest, src, op, shouldRespectImageOrientation);
 }
 
 void GraphicsContext::drawTiledImage(Image* image, const IntRect& destRect, const IntPoint& srcPoint, const IntSize& tileSize, SkXfermode::Mode op, const IntSize& repeatSpacing)
 {
-    if (!image)
+    if (contextDisabled() || !image)
         return;
     image->drawTiled(this, destRect, srcPoint, tileSize, op, repeatSpacing);
 }
 
 void GraphicsContext::drawTiledImage(Image* image, const IntRect& dest, const IntRect& srcRect,
     const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, SkXfermode::Mode op)
 {
-    if (!image)
+    if (contextDisabled() || !image)
         return;
 
     if (hRule == Image::StretchTile && vRule == Image::StretchTile) {
         // Just do a scale.
         drawImage(image, dest, srcRect, op);
         return;
     }
 
     image->drawTiled(this, dest, srcRect, tileScaleFactor, hRule, vRule, op);
 }
 
 void GraphicsContext::drawImageBuffer(ImageBuffer* image, const FloatRect& dest,
     const FloatRect* src, SkXfermode::Mode op)
 {
-    if (!image)
+    if (contextDisabled() || !image)
         return;
 
     image->draw(this, dest, src, op);
 }
 
 void GraphicsContext::writePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes, int x, int y)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
 
     m_canvas->writePixels(info, pixels, rowBytes, x, y);
 }
 
 void GraphicsContext::drawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
     const SkRect& dst, const SkPaint* paint)
 {
     ASSERT(m_canvas);
     // Textures are bound to the blink main-thread GrContext, which can not be
     // used on the compositor raster thread.
     // FIXME: Mailbox support would make this possible in the GPU-raster case.
     ASSERT(!isRecording() || !bitmap.getTexture());
+    if (contextDisabled())
+        return;
 
     SkCanvas::DrawBitmapRectFlags flags =
         immutableState()->shouldClampToSourceRect() ? SkCanvas::kNone_DrawBitmapRectFlag : SkCanvas::kBleed_DrawBitmapRectFlag;
 
     m_canvas->drawBitmapRectToRect(bitmap, src, dst, paint, flags);
 }
 
 void GraphicsContext::drawImage(const SkImage* image, SkScalar left, SkScalar top, const SkPaint* paint)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
+
     m_canvas->drawImage(image, left, top, paint);
 }
 
 void GraphicsContext::drawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst, const SkPaint* paint)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
+
     m_canvas->drawImageRect(image, src, dst, paint);
 }
 
 void GraphicsContext::drawOval(const SkRect& oval, const SkPaint& paint)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
+
     m_canvas->drawOval(oval, paint);
 }
 
 void GraphicsContext::drawPath(const SkPath& path, const SkPaint& paint)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
+
     m_canvas->drawPath(path, paint);
 }
 
 void GraphicsContext::drawRect(const SkRect& rect, const SkPaint& paint)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
+
     m_canvas->drawRect(rect, paint);
 }
 
 void GraphicsContext::drawRRect(const SkRRect& rrect, const SkPaint& paint)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
+
     m_canvas->drawRRect(rrect, paint);
 }
 
 void GraphicsContext::drawPosText(const void* text, size_t byteLength,
     const SkPoint pos[], const SkRect& textRect, const SkPaint& paint)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
+
     m_canvas->drawPosText(text, byteLength, pos, paint);
     didDrawTextInRect(textRect);
 }
 
 void GraphicsContext::drawPosTextH(const void* text, size_t byteLength,
     const SkScalar xpos[], SkScalar constY, const SkRect& textRect, const SkPaint& paint)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
+
     m_canvas->drawPosTextH(text, byteLength, xpos, constY, paint);
     didDrawTextInRect(textRect);
 }
 
 void GraphicsContext::drawTextBlob(const SkTextBlob* blob, const SkPoint& origin, const SkPaint& paint)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
+
     m_canvas->drawTextBlob(blob, origin.x(), origin.y(), paint);
 
     SkRect bounds = blob->bounds();
     bounds.offset(origin);
     didDrawTextInRect(bounds);
 }
 
 void GraphicsContext::fillPath(const Path& pathToFill)
 {
-    if (pathToFill.isEmpty())
+    if (contextDisabled() || pathToFill.isEmpty())
         return;
 
     // Use const_cast and temporarily modify the fill type instead of copying the path.
     SkPath& path = const_cast<SkPath&>(pathToFill.skPath());
     SkPath::FillType previousFillType = path.getFillType();
 
     SkPath::FillType temporaryFillType = WebCoreWindRuleToSkFillType(immutableState()->fillRule());
     path.setFillType(temporaryFillType);
 
     drawPath(path, immutableState()->fillPaint());
 
     path.setFillType(previousFillType);
 }
 
 void GraphicsContext::fillRect(const FloatRect& rect)
 {
+    if (contextDisabled())
+        return;
+
     SkRect r = rect;
 
     drawRect(r, immutableState()->fillPaint());
 }
 
 void GraphicsContext::fillRect(const FloatRect& rect, const Color& color)
 {
+    if (contextDisabled())
+        return;
+
     SkRect r = rect;
     SkPaint paint = immutableState()->fillPaint();
     paint.setColor(color.rgb());
     drawRect(r, paint);
 }
 
 void GraphicsContext::fillBetweenRoundedRects(const FloatRect& outer, const FloatSize& outerTopLeft, const FloatSize& outerTopRight, const FloatSize& outerBottomLeft, const FloatSize& outerBottomRight,
     const FloatRect& inner, const FloatSize& innerTopLeft, const FloatSize& innerTopRight, const FloatSize& innerBottomLeft, const FloatSize& innerBottomRight, const Color& color)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
 
     SkVector outerRadii[4];
     SkVector innerRadii[4];
     setRadii(outerRadii, outerTopLeft, outerTopRight, outerBottomRight, outerBottomLeft);
     setRadii(innerRadii, innerTopLeft, innerTopRight, innerBottomRight, innerBottomLeft);
 
     SkRRect rrOuter;
     SkRRect rrInner;
     rrOuter.setRectRadii(outer, outerRadii);
     rrInner.setRectRadii(inner, innerRadii);
 
     SkPaint paint(immutableState()->fillPaint());
     paint.setColor(color.rgb());
 
     m_canvas->drawDRRect(rrOuter, rrInner, paint);
 }
 
 void GraphicsContext::fillBetweenRoundedRects(const FloatRoundedRect& outer, const FloatRoundedRect& inner, const Color& color)
 {
     fillBetweenRoundedRects(outer.rect(), outer.radii().topLeft(), outer.radii().topRight(), outer.radii().bottomLeft(), outer.radii().bottomRight(),
         inner.rect(), inner.radii().topLeft(), inner.radii().topRight(), inner.radii().bottomLeft(), inner.radii().bottomRight(), color);
 }
 
 void GraphicsContext::fillRoundedRect(const FloatRect& rect, const FloatSize& topLeft, const FloatSize& topRight,
     const FloatSize& bottomLeft, const FloatSize& bottomRight, const Color& color)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
 
     if (topLeft.width() + topRight.width() > rect.width()
             || bottomLeft.width() + bottomRight.width() > rect.width()
             || topLeft.height() + bottomLeft.height() > rect.height()
             || topRight.height() + bottomRight.height() > rect.height()) {
         // Not all the radii fit, return a rect. This matches the behavior of
         // Path::createRoundedRectangle. Without this we attempt to draw a round
         // shadow for a square box.
         // FIXME: this fallback code is wrong, and also duplicates related code in FloatRoundedRect::constrainRadii, Path and SKRRect.
         fillRect(rect, color);
         return;
     }
 
     SkVector radii[4];
     setRadii(radii, topLeft, topRight, bottomRight, bottomLeft);
 
     SkRRect rr;
     rr.setRectRadii(rect, radii);
 
     SkPaint paint(immutableState()->fillPaint());
     paint.setColor(color.rgb());
 
     m_canvas->drawRRect(rr, paint);
 }
 
 void GraphicsContext::fillEllipse(const FloatRect& ellipse)
 {
+    if (contextDisabled())
+        return;
+
     SkRect rect = ellipse;
     drawOval(rect, immutableState()->fillPaint());
 }
 
 void GraphicsContext::strokePath(const Path& pathToStroke)
 {
-    if (pathToStroke.isEmpty())
+    if (contextDisabled() || pathToStroke.isEmpty())
         return;
 
     const SkPath& path = pathToStroke.skPath();
     drawPath(path, immutableState()->strokePaint());
 }
 
 void GraphicsContext::strokeRect(const FloatRect& rect)
 {
     strokeRect(rect, strokeThickness());
 }
 
 void GraphicsContext::strokeRect(const FloatRect& rect, float lineWidth)
 {
+    if (contextDisabled())
+        return;
+
     SkPaint paint(immutableState()->strokePaint());
     paint.setStrokeWidth(WebCoreFloatToSkScalar(lineWidth));
     // Reset the dash effect to account for the width
     immutableState()->strokeData().setupPaintDashPathEffect(&paint, 0);
     // strokerect has special rules for CSS when the rect is degenerate:
     // if width==0 && height==0, do nothing
     // if width==0 || height==0, then just draw line for the other dimension
     SkRect r(rect);
     bool validW = r.width() > 0;
     bool validH = r.height() > 0;
     if (validW && validH) {
         drawRect(r, paint);
     } else if (validW || validH) {
         // we are expected to respect the lineJoin, so we can't just call
         // drawLine -- we have to create a path that doubles back on itself.
         SkPath path;
         path.moveTo(r.fLeft, r.fTop);
         path.lineTo(r.fRight, r.fBottom);
         path.close();
         drawPath(path, paint);
     }
 }
 
 void GraphicsContext::strokeEllipse(const FloatRect& ellipse)
 {
+    if (contextDisabled())
+        return;
+
     drawOval(ellipse, immutableState()->strokePaint());
 }
 
 void GraphicsContext::clipRoundedRect(const FloatRoundedRect& rect, SkRegion::Op regionOp)
 {
+    if (contextDisabled())
+        return;
+
     if (!rect.isRounded()) {
         clipRect(rect.rect(), NotAntiAliased, regionOp);
         return;
     }
 
     SkVector radii[4];
     FloatRoundedRect::Radii wkRadii = rect.radii();
     setRadii(radii, wkRadii.topLeft(), wkRadii.topRight(), wkRadii.bottomRight(), wkRadii.bottomLeft());
 
     SkRRect r;
     r.setRectRadii(rect.rect(), radii);
 
     clipRRect(r, AntiAliased, regionOp);
 }
 
 void GraphicsContext::clipOut(const Path& pathToClip)
 {
+    if (contextDisabled())
+        return;
+
     // Use const_cast and temporarily toggle the inverse fill type instead of copying the path.
     SkPath& path = const_cast<SkPath&>(pathToClip.skPath());
     path.toggleInverseFillType();
     clipPath(path, AntiAliased);
     path.toggleInverseFillType();
 }
 
 void GraphicsContext::clipPath(const Path& pathToClip, WindRule clipRule, AntiAliasingMode antiAliasingMode)
 {
+    if (contextDisabled())
+        return;
+
     // Use const_cast and temporarily modify the fill type instead of copying the path.
     SkPath& path = const_cast<SkPath&>(pathToClip.skPath());
     SkPath::FillType previousFillType = path.getFillType();
 
     SkPath::FillType temporaryFillType = WebCoreWindRuleToSkFillType(clipRule);
     path.setFillType(temporaryFillType);
     clipPath(path, antiAliasingMode);
 
     path.setFillType(previousFillType);
 }
 
 void GraphicsContext::clipPolygon(size_t numPoints, const FloatPoint* points, bool antialiased)
 {
+    if (contextDisabled())
+        return;
+
     ASSERT(numPoints > 2);
 
     SkPath path;
     setPathFromPoints(&path, numPoints, points);
     clipPath(path, antialiased ? AntiAliased : NotAntiAliased);
 }
 
 void GraphicsContext::clipOutRoundedRect(const FloatRoundedRect& rect)
 {
+    if (contextDisabled())
+        return;
+
     clipRoundedRect(rect, SkRegion::kDifference_Op);
 }
 
 void GraphicsContext::clipRect(const SkRect& rect, AntiAliasingMode aa, SkRegion::Op op)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
+
     m_canvas->clipRect(rect, op, aa == AntiAliased);
 }
 
 void GraphicsContext::clipPath(const SkPath& path, AntiAliasingMode aa, SkRegion::Op op)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
+
     m_canvas->clipPath(path, op, aa == AntiAliased);
 }
 
 void GraphicsContext::clipRRect(const SkRRect& rect, AntiAliasingMode aa, SkRegion::Op op)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
+
     m_canvas->clipRRect(rect, op, aa == AntiAliased);
 }
 
 void GraphicsContext::rotate(float angleInRadians)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
+
     m_canvas->rotate(WebCoreFloatToSkScalar(angleInRadians * (180.0f / 3.14159265f)));
 }
 
 void GraphicsContext::translate(float x, float y)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
 
     if (!x && !y)
         return;
 
     m_canvas->translate(WebCoreFloatToSkScalar(x), WebCoreFloatToSkScalar(y));
 }
 
 void GraphicsContext::scale(float x, float y)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
 
     if (x == 1.0f && y == 1.0f)
         return;
 
     m_canvas->scale(WebCoreFloatToSkScalar(x), WebCoreFloatToSkScalar(y));
 }
 
 void GraphicsContext::setURLForRect(const KURL& link, const IntRect& destRect)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
 
     SkAutoDataUnref url(SkData::NewWithCString(link.string().utf8().data()));
     SkAnnotateRectWithURL(m_canvas, destRect, url.get());
 }
 
 void GraphicsContext::setURLFragmentForRect(const String& destName, const IntRect& rect)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
 
     SkAutoDataUnref skDestName(SkData::NewWithCString(destName.utf8().data()));
     SkAnnotateLinkToDestination(m_canvas, rect, skDestName.get());
 }
 
 void GraphicsContext::addURLTargetAtPoint(const String& name, const IntPoint& pos)
 {
     ASSERT(m_canvas);
+    if (contextDisabled())
+        return;
 
     SkAutoDataUnref nameData(SkData::NewWithCString(name.utf8().data()));
     SkAnnotateNamedDestination(m_canvas, SkPoint::Make(pos.x(), pos.y()), nameData);
 }
 
 AffineTransform GraphicsContext::getCTM() const
 {
+    if (contextDisabled())
+        return AffineTransform();
+
     SkMatrix m = getTotalMatrix();
     return AffineTransform(SkScalarToDouble(m.getScaleX()),
                            SkScalarToDouble(m.getSkewY()),
                            SkScalarToDouble(m.getSkewX()),
                            SkScalarToDouble(m.getScaleY()),
                            SkScalarToDouble(m.getTranslateX()),
                            SkScalarToDouble(m.getTranslateY()));
 }
 
 void GraphicsContext::concatCTM(const AffineTransform& affine)
 {
     concat(affineTransformToSkMatrix(affine));
 }
 
 void GraphicsContext::setCTM(const AffineTransform& affine)
 {
     setMatrix(affineTransformToSkMatrix(affine));
 }
 
 void GraphicsContext::fillRect(const FloatRect& rect, const Color& color, SkXfermode::Mode op)
 {
+    if (contextDisabled())
+        return;
+
     SkXfermode::Mode previousOperation = compositeOperation();
     setCompositeOperation(op);
     fillRect(rect, color);
     setCompositeOperation(previousOperation);
 }
 
 void GraphicsContext::fillRoundedRect(const FloatRoundedRect& rect, const Color& color)
 {
+    if (contextDisabled())
+        return;
+
     if (rect.isRounded())
         fillRoundedRect(rect.rect(), rect.radii().topLeft(), rect.radii().topRight(), rect.radii().bottomLeft(), rect.radii().bottomRight(), color);
     else
         fillRect(rect.rect(), color);
 }
 
 void GraphicsContext::fillRectWithRoundedHole(const FloatRect& rect, const FloatRoundedRect& roundedHoleRect, const Color& color)
 {
+    if (contextDisabled())
+        return;
+
     Path path;
     path.addRect(rect);
 
     if (!roundedHoleRect.radii().isZero())
         path.addRoundedRect(roundedHoleRect);
     else
         path.addRect(roundedHoleRect.rect());
 
     WindRule oldFillRule = fillRule();
     Color oldFillColor = fillColor();
 
     setFillRule(RULE_EVENODD);
     setFillColor(color);
 
     fillPath(path);
 
     setFillRule(oldFillRule);
     setFillColor(oldFillColor);
 }
 
 void GraphicsContext::clearRect(const FloatRect& rect)
 {
+    if (contextDisabled())
+        return;
+
     SkRect r = rect;
     SkPaint paint(immutableState()->fillPaint());
     paint.setXfermodeMode(SkXfermode::kClear_Mode);
     drawRect(r, paint);
 }
 
 void GraphicsContext::adjustLineToPixelBoundaries(FloatPoint& p1, FloatPoint& p2, float strokeWidth, StrokeStyle penStyle)
 {
     // For odd widths, we add in 0.5 to the appropriate x/y so that the float arithmetic
     // works out.  For example, with a border width of 3, WebKit will pass us (y1+y2)/2, e.g.,
@@ skipping 235 matching lines @@
         // being returned from computeInterpolationQuality.
         resampling = InterpolationLow;
     }
     resampling = limitInterpolationQuality(this, resampling);
     paint->setFilterLevel(static_cast<SkPaint::FilterLevel>(resampling));
 
     return initialSaveCount;
 }
 
 } // namespace blink