protected:
bool onShouldDisableLCD(const SkPaint&) const SK_OVERRIDE;
- /** Clears the entire device to the specified color (including alpha).
- * Ignores the clip.
- */
- virtual void clear(SkColor color) SK_OVERRIDE;
-
/** These are called inside the per-device-layer loop for each draw call.
When these are called, we have already applied any saveLayer operations,
and are handling any looping from the paint, and any effects from the
@param color the color to draw with
@param mode the mode to apply the color in (defaults to SrcOver)
*/
- void drawColor(SkColor color,
- SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode);
+ void drawColor(SkColor color, SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode);
- /**
- * This erases the entire drawing surface to the specified color,
- * irrespective of the clip. It does not blend with the previous pixels,
- * but always overwrites them.
- *
- * It is roughly equivalent to the following:
- * canvas.save();
- * canvas.clipRect(hugeRect, kReplace_Op);
- * paint.setColor(color);
- * paint.setXfermodeMode(kSrc_Mode);
- * canvas.drawPaint(paint);
- * canvas.restore();
- * though it is almost always much more efficient.
- */
- virtual void clear(SkColor);
+ // TODO: remove virtual when chrome subclass stop overriding this.
+ virtual void clear(SkColor color) {
+ this->drawColor(color, SkXfermode::kSrc_Mode);
+ }
/**
* This makes the contents of the canvas undefined. Subsequent calls that
private:
/** Clears the entire device to the specified color (including alpha).
* Ignores the clip.
+ * DEPRECATED : will go away when chrome subclasses have been updated
*/
- virtual void clear(SkColor color) = 0;
+ virtual void clear(SkColor color);
public:
/** These are called inside the per-device-layer loop for each draw call.
// V34: Add SkTextBlob serialization.
// V35: Store SkRect (rather then width & height) in header
// V36: Remove (obsolete) alphatype from SkColorTable
- // V37: Added shadow only option to SkDropShadowImageFilter
- // Added PictureResolution and FilterLevel options to SkPictureImageFilter
+ // V37: Added shadow only option to SkDropShadowImageFilter (last version to record CLEAR)
+ // V37: Added PictureResolution and FilterLevel options to SkPictureImageFilter
// Note: If the picture version needs to be increased then please follow the
// steps to generate new SKPs in (only accessible to Googlers): http://goo.gl/qATVcw
const SkMatrix& initialTransform);
SK_API virtual ~SkPDFDevice();
- virtual void clear(SkColor color) SK_OVERRIDE;
-
/** These are called inside the per-device-layer loop for each draw call.
When these are called, we have already applied any saveLayer operations,
and are handling any looping from the paint, and any effects from the
// Overrides of the SkCanvas interface
virtual bool isDrawingToLayer() const SK_OVERRIDE;
- virtual void clear(SkColor) SK_OVERRIDE;
virtual void drawPaint(const SkPaint& paint) SK_OVERRIDE;
virtual void drawPoints(PointMode mode, size_t count, const SkPoint pts[],
const SkPaint& paint) SK_OVERRIDE;
///////////////////////////////////////////////////////////////////////////
// These are forwarded to the N canvases we're referencing
- virtual void clear(SkColor) SK_OVERRIDE;
virtual void drawPaint(const SkPaint& paint) SK_OVERRIDE;
virtual void drawPoints(PointMode mode, size_t count, const SkPoint pts[],
const SkPaint&) SK_OVERRIDE;
}
}
-void SkBitmapDevice::clear(SkColor color) {
- fBitmap.eraseColor(color);
-}
-
const SkBitmap& SkBitmapDevice::onAccessBitmap() {
return fBitmap;
}
// These are the virtual drawing methods
//////////////////////////////////////////////////////////////////////////////
-void SkCanvas::clear(SkColor color) {
- SkDrawIter iter(this);
- this->predrawNotify();
- while (iter.next()) {
- iter.fDevice->clear(color);
- }
-}
-
void SkCanvas::onDiscard() {
if (fSurfaceBase) {
fSurfaceBase->aboutToDraw(SkSurface::kDiscard_ContentChangeMode);
const void* SkBaseDevice::peekPixels(SkImageInfo*, size_t*) { return NULL; }
+// DEPRECATED : remove when chrome subclass have been updated to not override clear()
+void SkBaseDevice::clear(SkColor color) {
+ SkFAIL("SkDevice::clear() should not be called");
+}
+
void SkBaseDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer,
const SkRRect& inner, const SkPaint& paint) {
SkPath path;
return offset;
}
-void SkPictureRecord::clear(SkColor color) {
- // op + color
- size_t size = 2 * kUInt32Size;
- size_t initialOffset = this->addDraw(DRAW_CLEAR, &size);
- this->addInt(color);
- this->validate(initialOffset, size);
-}
-
void SkPictureRecord::drawPaint(const SkPaint& paint) {
// op + paint index
size_t size = 2 * kUInt32Size;
SkPictureRecord(const SkISize& dimensions, uint32_t recordFlags);
virtual ~SkPictureRecord();
- virtual void clear(SkColor) SK_OVERRIDE;
virtual void drawPaint(const SkPaint& paint) SK_OVERRIDE;
virtual void drawPoints(PointMode, size_t count, const SkPoint pts[],
const SkPaint&) SK_OVERRIDE;
void SkRecordPartialDraw(const SkRecord& record, SkCanvas* canvas,
SkPicture const* const drawablePicts[], int drawableCount,
- const SkRect& clearRect,
unsigned start, unsigned stop,
const SkMatrix& initialCTM) {
SkAutoCanvasRestore saveRestore(canvas, true /*save now, restore at exit*/);
stop = SkTMin(stop, record.count());
- SkRecords::PartialDraw draw(canvas, NULL, 0, clearRect, initialCTM);
+ SkRecords::Draw draw(canvas, drawablePicts, NULL, drawableCount, &initialCTM);
for (unsigned i = start; i < stop; i++) {
record.visit<void>(i, draw);
}
SkCanvasDrawable* const drawables[], int drawableCount,
const SkBBoxHierarchy*, SkDrawPictureCallback*);
-// Draw a portion of an SkRecord into an SkCanvas while replacing clears with drawRects.
+// Draw a portion of an SkRecord into an SkCanvas.
// When drawing a portion of an SkRecord the CTM on the passed in canvas must be
// the composition of the replay matrix with the record-time CTM (for the portion
// of the record that is being replayed). For setMatrix calls to behave correctly
// the initialCTM parameter must set to just the replay matrix.
void SkRecordPartialDraw(const SkRecord&, SkCanvas*,
SkPicture const* const drawablePicts[], int drawableCount,
- const SkRect&, unsigned start, unsigned stop,
- const SkMatrix& initialCTM);
+ unsigned start, unsigned stop, const SkMatrix& initialCTM);
namespace SkRecords {
int fDrawableCount;
};
-// Used by SkRecordPartialDraw.
-class PartialDraw : public Draw {
-public:
- PartialDraw(SkCanvas* canvas, SkPicture const* const drawablePicts[], int drawableCount,
- const SkRect& clearRect, const SkMatrix& initialCTM)
- : INHERITED(canvas, drawablePicts, NULL, drawableCount, &initialCTM), fClearRect(clearRect)
- {}
-
- // Same as Draw for all ops except Clear.
- template <typename T> void operator()(const T& r) {
- this->INHERITED::operator()(r);
- }
- void operator()(const Clear& c) {
- SkPaint p;
- p.setColor(c.color);
- DrawRect drawRect(p, fClearRect);
- this->INHERITED::operator()(drawRect);
- }
-
-private:
- const SkRect fClearRect;
- typedef Draw INHERITED;
-};
-
} // namespace SkRecords
#endif//SkRecordDraw_DEFINED
}
-void SkRecorder::clear(SkColor color) {
- APPEND(Clear, color);
-}
-
void SkRecorder::drawPaint(const SkPaint& paint) {
APPEND(DrawPaint, delay_copy(paint));
}
// Make SkRecorder forget entirely about its SkRecord*; all calls to SkRecorder will fail.
void forgetRecord();
- void clear(SkColor) SK_OVERRIDE;
void drawPaint(const SkPaint& paint) SK_OVERRIDE;
void drawPoints(PointMode mode,
size_t count,
RECORD3(ClipRect, SkIRect, devBounds, SkRect, rect, RegionOpAndAA, opAA);
RECORD3(ClipRegion, SkIRect, devBounds, SkRegion, region, SkRegion::Op, op);
+// Picture version 37 was last to record this op-code; clear is now non-virtual
RECORD1(Clear, SkColor, color);
RECORD1(BeginCommentGroup, PODArray<char>, description);
SkCanvas* atlasCanvas = surface->getCanvas();
- SkPaint clearPaint;
- clearPaint.setColor(SK_ColorTRANSPARENT);
- clearPaint.setXfermode(SkXfermode::Create(SkXfermode::kSrc_Mode))->unref();
-
for (int i = 0; i < atlased.count(); ++i) {
const GrCachedLayer* layer = atlased[i].fLayer;
const SkPicture* pict = atlased[i].fPicture;
// extend beyond the boundaries of the atlased sub-rect
const SkRect bound = SkRect::Make(layer->rect());
atlasCanvas->clipRect(bound);
-
- // Since 'clear' doesn't respect the clip we need to draw a rect
- atlasCanvas->drawRect(bound, clearPaint);
+ atlasCanvas->clear(0);
// '-offset' maps the layer's top/left to the origin.
// Since this layer is atlased, the top/left corner needs
SkRecordPartialDraw(*pict->fRecord.get(), atlasCanvas,
pict->drawablePicts(), pict->drawableCount(),
- bound, layer->start() + 1, layer->stop(), initialCTM);
+ layer->start() + 1, layer->stop(), initialCTM);
atlasCanvas->restore();
}
// extend beyond the boundaries of the layer
const SkRect bound = SkRect::Make(layer->rect());
layerCanvas->clipRect(bound);
-
layerCanvas->clear(SK_ColorTRANSPARENT);
SkMatrix initialCTM;
SkRecordPartialDraw(*pict->fRecord.get(), layerCanvas,
pict->drawablePicts(), pict->drawableCount(),
- bound, layer->start()+1, layer->stop(), initialCTM);
+ layer->start()+1, layer->stop(), initialCTM);
layerCanvas->flush();
}
#define DO_DEFERRED_CLEAR() \
do { \
if (fFlags & kNeedClear_Flag) { \
- this->clear(SK_ColorTRANSPARENT); \
+ this->clearAll(); \
} \
} while (false) \
return fRenderTarget;
}
+void SkGpuDevice::clearAll() {
+ GrColor color = 0;
+ GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::clearAll", fContext);
+ SkIRect rect = SkIRect::MakeWH(this->width(), this->height());
+ fContext->clear(&rect, color, true, fRenderTarget);
+ fFlags &= ~kNeedClear_Flag;
+}
+
///////////////////////////////////////////////////////////////////////////////
SK_COMPILE_ASSERT(SkShader::kNone_BitmapType == 0, shader_type_mismatch);
///////////////////////////////////////////////////////////////////////////////
-void SkGpuDevice::clear(SkColor color) {
- GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::clear", fContext);
- SkIRect rect = SkIRect::MakeWH(this->width(), this->height());
- fContext->clear(&rect, SkColor2GrColor(color), true, fRenderTarget);
- fFlags &= ~kNeedClear_Flag;
-}
-
void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
CHECK_SHOULD_DRAW(draw, false);
GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawPaint", fContext);
SkGpuDevice* dev = static_cast<SkGpuDevice*>(device);
if (dev->fFlags & kNeedClear_Flag) {
// TODO: could check here whether we really need to draw at all
- dev->clear(0x0);
+ dev->clearAll();
}
// drawDevice is defined to be in device coords.
GrContext* context() const { return fContext; }
+ // set all pixels to 0
+ void clearAll();
+
virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE;
virtual SkImageInfo imageInfo() const SK_OVERRIDE {
return fRenderTarget ? fRenderTarget->surfacePriv().info() : SkImageInfo::MakeUnknown();
}
- virtual void clear(SkColor color) SK_OVERRIDE;
virtual void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE;
virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
const SkPoint[], const SkPaint& paint) SK_OVERRIDE;
fDevice = SkGpuDevice::Create(renderTarget, this->props(), deviceFlags);
if (kRGB_565_GrPixelConfig != renderTarget->config() && doClear) {
- fDevice->clear(0x0);
+ fDevice->clearAll();
}
}
}
}
-void SkPDFDevice::clear(SkColor color) {
- this->cleanUp(true);
- this->init();
-
- SkPaint paint;
- paint.setColor(color);
- paint.setStyle(SkPaint::kFill_Style);
- SkMatrix identity;
- identity.reset();
- ScopedContentEntry content(this, &fExistingClipStack, fExistingClipRegion,
- identity, paint);
- internalDrawPaint(paint, content.entry());
-}
-
void SkPDFDevice::drawPaint(const SkDraw& d, const SkPaint& paint) {
SkPaint newPaint = paint;
newPaint.setStyle(SkPaint::kFill_Style);
// overrides from SkCanvas
virtual bool isDrawingToLayer() const SK_OVERRIDE;
- virtual void clear(SkColor) SK_OVERRIDE;
virtual void drawPaint(const SkPaint& paint) SK_OVERRIDE;
virtual void drawPoints(PointMode, size_t count, const SkPoint pts[],
const SkPaint&) SK_OVERRIDE;
///////////////////////////////////////////////////////////////////////////////
-void SkGPipeCanvas::clear(SkColor color) {
- NOTIFY_SETUP(this);
- unsigned flags = 0;
- if (color) {
- flags |= kClear_HasColor_DrawOpFlag;
- }
- if (this->needOpBytes(sizeof(SkColor))) {
- this->writeOp(kDrawClear_DrawOp, flags, 0);
- if (color) {
- fWriter.write32(color);
- }
- }
-}
-
void SkGPipeCanvas::drawPaint(const SkPaint& paint) {
NOTIFY_SETUP(this);
this->writePaint(paint);
// None of the following drawing methods should ever get called on the
// deferred device
- virtual void clear(SkColor color) SK_OVERRIDE
- {SkASSERT(0);}
virtual void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE
{SkASSERT(0);}
virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode,
this->recordedDrawCommand();
}
-void SkDeferredCanvas::clear(SkColor color) {
- // purge pending commands
- if (fDeferredDrawing) {
- this->getDeferredDevice()->skipPendingCommands();
- }
-
- this->drawingCanvas()->clear(color);
- this->recordedDrawCommand();
-}
-
void SkDeferredCanvas::drawPaint(const SkPaint& paint) {
if (fDeferredDrawing && this->isFullFrame(NULL, &paint) &&
isPaintOpaque(&paint)) {
}
protected:
- virtual void clear(SkColor color) SK_OVERRIDE {
- NothingToDo();
- }
virtual void drawPaint(const SkDraw& draw, const SkPaint& paint) SK_OVERRIDE {
SkBitmap bm;
this->INHERITED::onClipRegion(deviceRgn, op);
}
-void SkNWayCanvas::clear(SkColor color) {
- Iter iter(fList);
- while (iter.next()) {
- iter->clear(color);
- }
-}
-
void SkNWayCanvas::drawPaint(const SkPaint& paint) {
Iter iter(fList);
while (iter.next()) {
return false;
}
- virtual void clear(SkColor color) SK_OVERRIDE {
- nothing_to_do();
- }
-
virtual void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE {
this->addBitmapFromPaint(paint);
}
fTexOverrideFilter->setFilterLevel(level);
}
-void SkDebugCanvas::clear(SkColor color) {
- this->addDrawCommand(new SkClearCommand(color));
-}
-
void SkDebugCanvas::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
this->addDrawCommand(new SkClipPathCommand(path, op, kSoft_ClipEdgeStyle == edgeStyle));
}
// Inherited from SkCanvas
////////////////////////////////////////////////////////////////////////////////
- virtual void clear(SkColor) SK_OVERRIDE;
-
virtual void drawBitmap(const SkBitmap&, SkScalar left, SkScalar top,
const SkPaint*) SK_OVERRIDE;
canvas->restore();
REPORTER_ASSERT(reporter, !canvas->isFreshFrame());
- // Verify that a clear with clipping triggers a fresh frame
- // (clear is not affected by clipping)
- canvas->save();
- canvas->clipRect(partialRect, SkRegion::kIntersect_Op, false);
- canvas->clear(0x00000000);
- canvas->restore();
- REPORTER_ASSERT(reporter, canvas->isFreshFrame());
-
// Verify that full frame rects with different forms of opaque paint
// trigger frames to be marked as fresh
{
SkRecord rerecord;
SkRecorder canvas(&rerecord, kWidth, kHeight);
- SkRecordPartialDraw(record, &canvas, NULL, 0, r1, 1, 2, SkMatrix::I()); // replay just drawRect of r2
+ SkRecordPartialDraw(record, &canvas, NULL, 0, 1, 2, SkMatrix::I()); // replay just drawRect of r2
REPORTER_ASSERT(r, 3 == rerecord.count());
assert_type<SkRecords::Save> (r, rerecord, 0);
REPORTER_ASSERT(r, drawRect->rect == r2);
}
-// Check that clears are converted to drawRects
-DEF_TEST(RecordDraw_PartialClear, r) {
- static const int kWidth = 10, kHeight = 10;
-
- SkRect rect = { 0, 0, kWidth, kHeight };
-
- SkRecord record;
- SkRecorder recorder(&record, kWidth, kHeight);
- recorder.clear(SK_ColorRED);
-
- SkRecord rerecord;
- SkRecorder canvas(&rerecord, kWidth, kHeight);
- SkRecordPartialDraw(record, &canvas, NULL, 0, rect, 0, 1, SkMatrix::I()); // replay just the clear
-
- REPORTER_ASSERT(r, 3 == rerecord.count());
- assert_type<SkRecords::Save> (r, rerecord, 0);
- assert_type<SkRecords::DrawRect>(r, rerecord, 1);
- assert_type<SkRecords::Restore> (r, rerecord, 2);
-
- const SkRecords::DrawRect* drawRect = assert_type<SkRecords::DrawRect>(r, rerecord, 1);
- REPORTER_ASSERT(r, drawRect->rect == rect);
- REPORTER_ASSERT(r, drawRect->paint.getColor() == SK_ColorRED);
-}
-
// A regression test for crbug.com/415468 and skbug.com/2957.
//
// This also now serves as a regression test for crbug.com/418417. We used to adjust the