Clean up dead clear() code in SkRecord.

src/core/SkRecordDraw.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLayerInfo.h"
 #include "SkRecordDraw.h"
 #include "SkPatchUtils.h"
 
 void SkRecordDraw(const SkRecord& record,
                   SkCanvas* canvas,
                   SkPicture const* const drawablePicts[],
                   SkCanvasDrawable* const drawables[],
                   int drawableCount,
                   const SkBBoxHierarchy* bbh,
                   SkDrawPictureCallback* callback) {
     SkAutoCanvasRestore saveRestore(canvas, true /*save now, restore at exit*/);
 
     if (bbh) {
         // Draw only ops that affect pixels in the canvas's current clip.
         // The SkRecord and BBH were recorded in identity space.  This canvas
         // is not necessarily in that same space.  getClipBounds() returns us
         // this canvas' clip bounds transformed back into identity space, which
         // lets us query the BBH.
-        SkRect query;
-        if (!canvas->getClipBounds(&query)) {
-            // We want to make sure our query rectangle is never totally empty.
-            // Clear ignores the clip, so it must draw even if the clip is logically empty.
-            query = SkRect::MakeWH(SK_ScalarNearlyZero, SK_ScalarNearlyZero);
-        }
+        SkRect query = {0,0,0,0};
+        (void)canvas->getClipBounds(&query);

[reed1, 2015/01/05 14:45:30]

not sure why the new form is clearer.

[mtklein, 2015/01/05 14:49:17]

You're saying you prefer
  SkRect query;
  if (!canvas->getClipBounds(&query)) {
    query.setEmpty();
  }
?  That'd be fine with me.

[reed1, 2015/01/05 16:26:08]

danke

 
         SkTDArray<unsigned> ops;
         bbh->search(query, &ops);
 
         SkRecords::Draw draw(canvas, drawablePicts, drawables, drawableCount);
         for (int i = 0; i < ops.count(); i++) {
             if (callback && callback->abortDrawing()) {
                 return;
             }
             // This visit call uses the SkRecords::Draw::operator() to call
@@ skipping 31 matching lines @@
 
 namespace SkRecords {
 
 // NoOps draw nothing.
 template <> void Draw::draw(const NoOp&) {}
 
 #define DRAW(T, call) template <> void Draw::draw(const T& r) { fCanvas->call; }
 DRAW(Restore, restore());
 DRAW(Save, save());
 DRAW(SaveLayer, saveLayer(r.bounds, r.paint, r.flags));
-DRAW(Clear, clear(r.color));
 DRAW(SetMatrix, setMatrix(SkMatrix::Concat(fInitialCTM, r.matrix)));
 
 DRAW(ClipPath, clipPath(r.path, r.opAA.op, r.opAA.aa));
 DRAW(ClipRRect, clipRRect(r.rrect, r.opAA.op, r.opAA.aa));
 DRAW(ClipRect, clipRect(r.rect, r.opAA.op, r.opAA.aa));
 DRAW(ClipRegion, clipRegion(r.region, r.op));
 
 DRAW(BeginCommentGroup, beginCommentGroup(r.description));
 DRAW(AddComment, addComment(r.key, r.value));
 DRAW(EndCommentGroup, endCommentGroup());
@@ skipping 116 matching lines @@
         // Adjust rect for all the paints from the SaveLayers we're inside.
         if (!this->adjustForSaveLayerPaints(&rect)) {
             // Same deal as above.
             return fCurrentClipBounds;
         }
 
         // Map the rect back to identity space.
         fCTM->mapRect(&rect);
 
         // Nothing can draw outside the current clip.
-        // (Only bounded ops call into this method, so oddballs like Clear don't matter here.)
         if (!rect.intersect(fCurrentClipBounds)) {
             return Bounds::MakeEmpty();
         }
 
         return rect;
     }
 
 private:
     struct SaveBounds {
         int controlOps;        // Number of control ops in this Save block, including the Save.
@@ skipping 149 matching lines @@
     void updateSaveBounds(const Bounds& bounds) {
         // If we're in a Save block, expand its bounds to cover these bounds too.
         if (!fSaveStack.isEmpty()) {
             fSaveStack.top().bounds.join(bounds);
         }
     }
 
     // FIXME: this method could use better bounds
     Bounds bounds(const DrawText&) const { return fCurrentClipBounds; }
 
-    Bounds bounds(const Clear&) const { return fCullRect; }             // Ignores the clip.
     Bounds bounds(const DrawPaint&) const { return fCurrentClipBounds; }
     Bounds bounds(const NoOp&)  const { return Bounds::MakeEmpty(); }    // NoOps don't draw.
 
     Bounds bounds(const DrawSprite& op) const {  // Ignores the matrix.
         return Bounds::MakeXYWH(op.left, op.top, op.bitmap.width(), op.bitmap.height());
     }
 
     Bounds bounds(const DrawRect& op) const { return this->adjustAndMap(op.rect, &op.paint); }
     Bounds bounds(const DrawOval& op) const { return this->adjustAndMap(op.oval, &op.paint); }
     Bounds bounds(const DrawRRect& op) const {
@@ skipping 390 matching lines @@
     SkRecords::CollectLayers visitor(cullRect, record, pictList, data);
 
     for (unsigned curOp = 0; curOp < record.count(); curOp++) {
         visitor.setCurrentOp(curOp);
         record.visit<void>(curOp, visitor);
     }
 
     visitor.cleanUp(bbh);
 }