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)
@@ skipping 33 matching lines @@
     , m_deviceScaleFactor(1.0f)
     , m_trackTextRegion(false)
     , m_accelerated(false)
     , m_printing(false)
     , m_antialiasHairlineImages(false)
 {
     // FIXME: Do some tests to determine how many states are typically used, and allocate
     // several here.
     m_paintStateStack.append(GraphicsContextState::create());
     m_paintState = m_paintStateStack.last().get();
+
+    if (contextDisabled()) {

[f(malita), 2015/03/11 18:20:51]

Would it be a lot of duplication to do this at call sites and just assert here?

[Xianzhu, 2015/03/11 19:40:46]

Looked at several call sites and that seems more complex.

+        DEFINE_STATIC_LOCAL(RefPtr<SkCanvas>, nullCanvas, (adoptRef(SkCreateNullCanvas())));
+        m_canvas = nullCanvas.get();

[f(malita), 2015/03/11 18:20:51]

If we always allocate a (SkNull) canvas when contextDisabled(), I'm guessing we
don't *have to* relocate the asserts below, no? But I do think the new order
makes more sense, so I'm fine with that.

[Xianzhu, 2015/03/11 19:40:46]

Right.
I think the same.

+    }
 }
 
 GraphicsContext::~GraphicsContext()
 {
 #if ENABLE(ASSERT)
     if (!m_disableDestructionChecks) {
         ASSERT(!m_paintStateIndex);
         ASSERT(!m_paintState->saveCount());
         ASSERT(!m_annotationCount);
         ASSERT(!m_layerCount);
@@ skipping 405 matching lines @@
     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 (contextDisabled() || !picture || (picture->cullRect().isEmpty() && cullEmptyPictures))
         return;
 
+    ASSERT(m_canvas);
     m_canvas->drawPicture(picture);
 }
 
 void GraphicsContext::compositePicture(SkPicture* picture, const FloatRect& dest, const FloatRect& src, SkXfermode::Mode op)
 {
-    ASSERT(m_canvas);
     if (contextDisabled() || !picture)
         return;
+    ASSERT(m_canvas);
 
     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())));
@@ skipping 173 matching lines @@
     drawLooperBuilder->addShadow(shadowOffset, shadowBlur, shadowColor,
         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;
+    ASSERT(m_canvas);
 
     StrokeStyle penStyle = strokeStyle();
     if (penStyle == NoStroke)
         return;
 
     FloatPoint p1 = point1;
     FloatPoint p2 = point2;
     bool isVerticalLine = (p1.x() == p2.x());
     int width = roundf(strokeThickness());
 
@@ skipping 313 matching lines @@
     const FloatRect* src, SkXfermode::Mode op)
 {
     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;
+    ASSERT(m_canvas);
 
     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;
 
+    ASSERT(m_canvas);
     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;
+    ASSERT(m_canvas);
 
     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;
+    ASSERT(m_canvas);
 
     m_canvas->drawImageRect(image, src, dst, paint);
 }
 
 void GraphicsContext::drawOval(const SkRect& oval, const SkPaint& paint)
 {
-    ASSERT(m_canvas);
     if (contextDisabled())
         return;
+    ASSERT(m_canvas);
 
     m_canvas->drawOval(oval, paint);
 }
 
 void GraphicsContext::drawPath(const SkPath& path, const SkPaint& paint)
 {
-    ASSERT(m_canvas);
     if (contextDisabled())
         return;
+    ASSERT(m_canvas);
 
     m_canvas->drawPath(path, paint);
 }
 
 void GraphicsContext::drawRect(const SkRect& rect, const SkPaint& paint)
 {
-    ASSERT(m_canvas);
     if (contextDisabled())
         return;
+    ASSERT(m_canvas);
 
     m_canvas->drawRect(rect, paint);
 }
 
 void GraphicsContext::drawRRect(const SkRRect& rrect, const SkPaint& paint)
 {
-    ASSERT(m_canvas);
     if (contextDisabled())
         return;
+    ASSERT(m_canvas);
 
     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;
+    ASSERT(m_canvas);
 
     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;
+    ASSERT(m_canvas);
 
     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;
+    ASSERT(m_canvas);
 
     m_canvas->drawTextBlob(blob, origin.x(), origin.y(), paint);
 
     SkRect bounds = blob->bounds();
     bounds.offset(origin);
     didDrawTextInRect(bounds);
 }
 
 void GraphicsContext::fillPath(const Path& pathToFill)
 {
@@ skipping 29 matching lines @@
 
     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;
+    ASSERT(m_canvas);
 
     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;
+    ASSERT(m_canvas);
 
     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);
@@ skipping 134 matching lines @@
 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;
+    ASSERT(m_canvas);
 
     m_canvas->clipRect(rect, op, aa == AntiAliased);
 }
 
 void GraphicsContext::clipPath(const SkPath& path, AntiAliasingMode aa, SkRegion::Op op)
 {
-    ASSERT(m_canvas);
     if (contextDisabled())
         return;
+    ASSERT(m_canvas);
 
     m_canvas->clipPath(path, op, aa == AntiAliased);
 }
 
 void GraphicsContext::clipRRect(const SkRRect& rect, AntiAliasingMode aa, SkRegion::Op op)
 {
-    ASSERT(m_canvas);
     if (contextDisabled())
         return;
+    ASSERT(m_canvas);
 
     m_canvas->clipRRect(rect, op, aa == AntiAliased);
 }
 
 void GraphicsContext::rotate(float angleInRadians)
 {
-    ASSERT(m_canvas);
     if (contextDisabled())
         return;
+    ASSERT(m_canvas);
 
     m_canvas->rotate(WebCoreFloatToSkScalar(angleInRadians * (180.0f / 3.14159265f)));
 }
 
 void GraphicsContext::translate(float x, float y)
 {
-    ASSERT(m_canvas);
     if (contextDisabled())
         return;
+    ASSERT(m_canvas);
 
     if (!x && !y)
         return;
 
     m_canvas->translate(WebCoreFloatToSkScalar(x), WebCoreFloatToSkScalar(y));
 }
 
 void GraphicsContext::scale(float x, float y)
 {
-    ASSERT(m_canvas);
     if (contextDisabled())
         return;
+    ASSERT(m_canvas);
 
     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;
+    ASSERT(m_canvas);
 
     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;
+    ASSERT(m_canvas);
 
     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;
+    ASSERT(m_canvas);
 
     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();
 
@@ skipping 316 matching lines @@
         // being returned from computeInterpolationQuality.
         resampling = InterpolationLow;
     }
     resampling = limitInterpolationQuality(this, resampling);
     paint->setFilterLevel(static_cast<SkPaint::FilterLevel>(resampling));
 
     return initialSaveCount;
 }
 
 } // namespace blink