Create a GraphicsContext from a DisplayList.

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 117 matching lines @@
     , m_disabledState(disableContextOrPainting)
     , m_deviceScaleFactor(1.0f)
     , m_regionTrackingMode(RegionTrackingDisabled)
     , m_trackTextRegion(false)
     , m_accelerated(false)
     , m_isCertainlyOpaque(true)
     , m_printing(false)
     , m_antialiasHairlineImages(false)
     , m_shouldSmoothFonts(true)
 {
-    ASSERT(canvas);
-
     // 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();
 }
 
 GraphicsContext::~GraphicsContext()
 {
 #if ENABLE(ASSERT)
     if (!m_disableDestructionChecks) {
         ASSERT(!m_paintStateIndex);
         ASSERT(!m_paintState->saveCount());
         ASSERT(!m_annotationCount);
         ASSERT(!m_layerCount);
         ASSERT(m_recordingStateStack.isEmpty());
         ASSERT(m_canvasStateStack.isEmpty());
     }
 #endif
 }
 
 void GraphicsContext::resetCanvas(SkCanvas* canvas)
 {
-    ASSERT(canvas);
     m_canvas = canvas;
     m_trackedRegion.reset();
 }
 
 void GraphicsContext::setRegionTrackingMode(RegionTrackingMode mode)
 {
     m_regionTrackingMode = mode;
     if (mode == RegionTrackingOpaque)
         m_trackedRegion.setTrackedRegionType(RegionTracker::Opaque);
     else if (mode == RegionTrackingOverwrite)
         m_trackedRegion.setTrackedRegionType(RegionTracker::Overwrite);
 }
 
 void GraphicsContext::save()
 {
     if (contextDisabled())
         return;
 
     m_paintState->incrementSaveCount();
 
-    m_canvasStateStack.append(CanvasSaveState(m_pendingCanvasSave, m_canvas->getSaveCount()));
-    m_pendingCanvasSave = true;
+    if (m_canvas) {
+        m_canvasStateStack.append(CanvasSaveState(m_pendingCanvasSave, m_canvas->getSaveCount()));
+        m_pendingCanvasSave = true;
+    }
 }
 
 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();
     }
 
-    CanvasSaveState savedState = m_canvasStateStack.last();
-    m_canvasStateStack.removeLast();
-    m_pendingCanvasSave = savedState.m_pendingSave;
-    m_canvas->restoreToCount(savedState.m_restoreCount);
+    if (m_canvas) {
+        ASSERT(m_canvasStateStack.size() > 0);
+        CanvasSaveState savedState = m_canvasStateStack.last();
+        m_canvasStateStack.removeLast();
+        m_pendingCanvasSave = savedState.m_pendingSave;
+        m_canvas->restoreToCount(savedState.m_restoreCount);
+    }
 }
 
 void GraphicsContext::saveLayer(const SkRect* bounds, const SkPaint* paint)
 {
     if (contextDisabled())
         return;
 
+    ASSERT(m_canvas);
+
     realizeCanvasSave();
 
     m_canvas->saveLayer(bounds, paint);
     if (regionTrackingEnabled())
         m_trackedRegion.pushCanvasLayer(paint);
 }
 
 void GraphicsContext::restoreLayer()
 {
     if (contextDisabled())
         return;
 
+    ASSERT(m_canvas);
+
     m_canvas->restore();
     if (regionTrackingEnabled())
         m_trackedRegion.popCanvasLayer(this);
 }
 
 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
 }
 
 void GraphicsContext::setStrokePattern(PassRefPtr<Pattern> pattern)
 {
@@ skipping 85 matching lines @@
 
 bool GraphicsContext::hasShadow() const
 {
     return !!immutableState()->drawLooper();
 }
 
 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
 {
-    if (contextDisabled())
+    if (contextDisabled() || !m_canvas)
         return SkMatrix::I();
 
+    ASSERT(m_canvas);
+
     if (!isRecording())
         return m_canvas->getTotalMatrix();
 
     const RecordingState& recordingState = m_recordingStateStack.last();
     SkMatrix totalMatrix = recordingState.m_savedMatrix;
     totalMatrix.preConcat(m_canvas->getTotalMatrix());
 
     return totalMatrix;
 }
 
 void GraphicsContext::adjustTextRenderMode(SkPaint* paint) const
 {
     if (contextDisabled())
         return;
 
     if (!paint->isLCDRenderText())
         return;
 
     paint->setLCDRenderText(couldUseLCDRenderedText());
 }
 
 bool GraphicsContext::couldUseLCDRenderedText() const
 {
+    ASSERT(m_canvas);
     // Our layers only have a single alpha channel. This means that subpixel
     // rendered text cannot be composited correctly when the layer is
     // collapsed. Therefore, subpixel text is contextDisabled when we are drawing
     // onto a layer.
     if (contextDisabled() || m_canvas->isDrawingToLayer() || !isCertainlyOpaque())
         return false;
 
     return shouldSmoothFonts();
 }
 
@@ skipping 17 matching lines @@
     // 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);
     realizeCanvasSave();
 
     m_canvas->setMatrix(matrix);
 }
 
 void GraphicsContext::concat(const SkMatrix& matrix)
 {
     if (contextDisabled())
         return;
 
     if (matrix.isIdentity())
         return;
 
+    ASSERT(m_canvas);
     realizeCanvasSave();
 
     m_canvas->concat(matrix);
 }
 
 void GraphicsContext::beginTransparencyLayer(float opacity, const FloatRect* bounds)
 {
     beginLayer(opacity, immutableState()->compositeOperator(), bounds);
 }
 
@@ skipping 30 matching lines @@
     ASSERT(m_layerCount > 0);
 #if ENABLE(ASSERT)
     --m_layerCount;
 #endif
 }
 
 void GraphicsContext::beginRecording(const FloatRect& bounds, uint32_t recordFlags)
 {
     RefPtr<DisplayList> displayList = DisplayList::create(bounds);
 
-    SkPictureRecorder* recorder = 0;
-
     SkCanvas* savedCanvas = m_canvas;
     SkMatrix savedMatrix = getTotalMatrix();
+    SkPictureRecorder* recorder = 0;
 
     if (!contextDisabled()) {
         FloatRect bounds = displayList->bounds();
         IntSize recordingSize = enclosingIntRect(bounds).size();
         recorder = new SkPictureRecorder;
         m_canvas = recorder->beginRecording(recordingSize.width(), recordingSize.height(), 0, recordFlags);
 
         // We want the bounds offset mapped to (0, 0), such that the display list content
         // is fully contained within the SkPictureRecord's bounds.
         if (!toFloatSize(bounds.location()).isZero()) {
@@ skipping 22 matching lines @@
 }
 
 bool GraphicsContext::isRecording() const
 {
     return !m_recordingStateStack.isEmpty();
 }
 
 void GraphicsContext::drawDisplayList(DisplayList* displayList)
 {
     ASSERT(displayList);
+    ASSERT(m_canvas);
 
     if (contextDisabled() || displayList->bounds().isEmpty())
         return;
 
     bool performClip = !displayList->clip().isEmpty();
     bool performTransform = !displayList->transform().isIdentity();
     if (performClip || performTransform) {
         save();
         if (performTransform)
             concat(displayList->transform());
@@ skipping 184 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;
 
     StrokeStyle penStyle = strokeStyle();
     if (penStyle == NoStroke)
         return;
 
     FloatPoint p1 = point1;
     FloatPoint p2 = point2;
     bool isVerticalLine = (p1.x() == p2.x());
@@ skipping 356 matching lines @@
     const FloatRect* src, CompositeOperator op, WebBlendMode blendMode)
 {
     if (contextDisabled() || !image)
         return;
 
     image->draw(this, dest, src, op, blendMode);
 }
 
 void GraphicsContext::drawPicture(PassRefPtr<SkPicture> picture, const FloatRect& dest, const FloatRect& src, CompositeOperator op, WebBlendMode blendMode)
 {
+    ASSERT(m_canvas);
     if (contextDisabled() || !picture)
         return;
 
     SkMatrix ctm = m_canvas->getTotalMatrix();
     SkRect deviceDest;
     ctm.mapRect(&deviceDest, dest);
     SkRect sourceBounds = WebCoreFloatRectToSKRect(src);
 
     RefPtr<SkPictureImageFilter> pictureFilter = adoptRef(SkPictureImageFilter::Create(picture.get(), sourceBounds));
     SkMatrix layerScale;
     layerScale.setScale(deviceDest.width() / src.width(), deviceDest.height() / src.height());
     RefPtr<SkMatrixImageFilter> matrixFilter = adoptRef(SkMatrixImageFilter::Create(layerScale, SkPaint::kLow_FilterLevel, pictureFilter.get()));
     SkPaint picturePaint;
     picturePaint.setXfermodeMode(WebCoreCompositeToSkiaComposite(op, blendMode));
     picturePaint.setImageFilter(matrixFilter.get());
     SkRect layerBounds = SkRect::MakeWH(std::max(deviceDest.width(), sourceBounds.width()), std::max(deviceDest.height(), sourceBounds.height()));
     m_canvas->save();
     m_canvas->resetMatrix();
     m_canvas->translate(deviceDest.x(), deviceDest.y());
     m_canvas->saveLayer(&layerBounds, &picturePaint);
     m_canvas->restore();
     m_canvas->restore();
 }
 
 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);
 
     if (regionTrackingEnabled()) {
         SkRect rect = SkRect::MakeXYWH(x, y, info.width(), info.height());
         SkPaint paint;
 
         paint.setXfermodeMode(SkXfermode::kSrc_Mode);
@@ skipping 13 matching lines @@
 
     if (!bitmap.getTexture()) {
         SkAutoLockPixels alp(bitmap);
         if (bitmap.getPixels())
             writePixels(bitmap.info(), bitmap.getPixels(), bitmap.rowBytes(), x, y);
     }
 }
 
 void GraphicsContext::drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top, const SkPaint* paint)
 {
+    ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     m_canvas->drawBitmap(bitmap, left, top, paint);
 
     if (regionTrackingEnabled()) {
         SkRect rect = SkRect::MakeXYWH(left, top, bitmap.width(), bitmap.height());
         m_trackedRegion.didDrawRect(this, rect, *paint, &bitmap);
     }
 }
 
 void GraphicsContext::drawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
     const SkRect& dst, const SkPaint* paint)
 {
+    ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     SkCanvas::DrawBitmapRectFlags flags =
         immutableState()->shouldClampToSourceRect() ? SkCanvas::kNone_DrawBitmapRectFlag : SkCanvas::kBleed_DrawBitmapRectFlag;
 
     m_canvas->drawBitmapRectToRect(bitmap, src, dst, paint, flags);
 
     if (regionTrackingEnabled())
         m_trackedRegion.didDrawRect(this, dst, *paint, &bitmap);
 }
 
 void GraphicsContext::drawOval(const SkRect& oval, const SkPaint& paint)
 {
+    ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     m_canvas->drawOval(oval, paint);
 
     if (regionTrackingEnabled())
         m_trackedRegion.didDrawBounded(this, oval, paint);
 }
 
 void GraphicsContext::drawPath(const SkPath& path, const SkPaint& paint)
 {
+    ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     m_canvas->drawPath(path, paint);
 
     if (regionTrackingEnabled())
         m_trackedRegion.didDrawPath(this, path, paint);
 }
 
 void GraphicsContext::drawRect(const SkRect& rect, const SkPaint& paint)
 {
+    ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     m_canvas->drawRect(rect, paint);
 
     if (regionTrackingEnabled())
         m_trackedRegion.didDrawRect(this, rect, paint, 0);
 }
 
 void GraphicsContext::drawRRect(const SkRRect& rrect, const SkPaint& paint)
 {
+    ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     m_canvas->drawRRect(rrect, paint);
 
     if (regionTrackingEnabled())
         m_trackedRegion.didDrawBounded(this, rrect.rect(), paint);
 }
 
 void GraphicsContext::didDrawRect(const SkRect& rect, const SkPaint& paint, const SkBitmap* bitmap)
 {
     if (contextDisabled())
         return;
 
     if (regionTrackingEnabled())
         m_trackedRegion.didDrawRect(this, rect, paint, bitmap);
 }
 
 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);
 
     // FIXME: compute bounds for positioned text.
     if (regionTrackingEnabled())
         m_trackedRegion.didDrawUnbounded(this, paint, RegionTracker::FillOrStroke);
 }
 
 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);
 
     // FIXME: compute bounds for positioned text.
     if (regionTrackingEnabled())
         m_trackedRegion.didDrawUnbounded(this, paint, RegionTracker::FillOrStroke);
 }
 
 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);
 
     // FIXME: use bounds here if it helps performance.
@@ skipping 33 matching lines @@
     if (contextDisabled())
         return;
 
     SkRect r = rect;
     SkPaint paint = immutableState()->fillPaint();
     paint.setColor(color.rgb());
     drawRect(r, paint);
 }
 
 void GraphicsContext::fillBetweenRoundedRects(const IntRect& outer, const IntSize& outerTopLeft, const IntSize& outerTopRight, const IntSize& outerBottomLeft, const IntSize& outerBottomRight,
-    const IntRect& inner, const IntSize& innerTopLeft, const IntSize& innerTopRight, const IntSize& innerBottomLeft, const IntSize& innerBottomRight, const Color& color) {
+    const IntRect& inner, const IntSize& innerTopLeft, const IntSize& innerTopRight, const IntSize& innerBottomLeft, const IntSize& 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;
@@ skipping 11 matching lines @@
 
 void GraphicsContext::fillBetweenRoundedRects(const RoundedRect& outer, const RoundedRect& 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 IntRect& rect, const IntSize& topLeft, const IntSize& topRight,
     const IntSize& bottomLeft, const IntSize& 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.
@@ skipping 155 matching lines @@
 
     SkPath::FillType temporaryFillType = WebCoreWindRuleToSkFillType(clipRule);
     path.setFillType(temporaryFillType);
     clipPath(path);
 
     path.setFillType(previousFillType);
 }
 
 void GraphicsContext::clipRect(const SkRect& rect, AntiAliasingMode aa, SkRegion::Op op)
 {
+    ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     realizeCanvasSave();
 
     m_canvas->clipRect(rect, op, aa == AntiAliased);
 }
 
 void GraphicsContext::clipPath(const SkPath& path, AntiAliasingMode aa, SkRegion::Op op)
 {
+    ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     realizeCanvasSave();
 
     m_canvas->clipPath(path, op, aa == AntiAliased);
 }
 
 void GraphicsContext::clipRRect(const SkRRect& rect, AntiAliasingMode aa, SkRegion::Op op)
 {
+    ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     realizeCanvasSave();
 
     m_canvas->clipRRect(rect, op, aa == AntiAliased);
 }
 
 void GraphicsContext::beginCull(const FloatRect& rect)
 {
+    ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     realizeCanvasSave();
     m_canvas->pushCull(rect);
 }
 
 void GraphicsContext::endCull()
 {
+    ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     realizeCanvasSave();
 
     m_canvas->popCull();
 }
 
 void GraphicsContext::rotate(float angleInRadians)
 {
+    ASSERT(m_canvas);
     if (contextDisabled())
         return;
 
     realizeCanvasSave();
 
     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;
 
     realizeCanvasSave();
 
     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;
 
     realizeCanvasSave();
 
     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())
@@ skipping 311 matching lines @@
         // FIXME: This is to not break tests (it results in the filter bitmap flag
         // being set to true). We need to decide if we respect InterpolationNone
         // being returned from computeInterpolationQuality.
         resampling = InterpolationLow;
     }
     resampling = limitInterpolationQuality(this, resampling);
     paint->setFilterLevel(static_cast<SkPaint::FilterLevel>(resampling));
 }
 
 } // namespace blink