Remove SkTileGrid (except for TileGridInfo).

tools/PictureRenderer.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "PictureRenderer.h"
 #include "picture_utils.h"
 #include "SamplePipeControllers.h"
@@ skipping 210 matching lines @@
  */
 void PictureRenderer::buildBBoxHierarchy() {
     SkASSERT(fPicture);
     if (kNone_BBoxHierarchyType != fBBoxHierarchyType && fPicture) {
         SkAutoTDelete<SkBBHFactory> factory(this->getFactory());
         SkPictureRecorder recorder;
         uint32_t flags = this->recordFlags();
         if (fUseMultiPictureDraw) {
             flags |= SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag;
         }
-        SkCanvas* canvas = recorder.beginRecording(fPicture->cullRect().width(), 
+        SkCanvas* canvas = recorder.beginRecording(fPicture->cullRect().width(),
                                                    fPicture->cullRect().height(),
                                                    factory.get(),
                                                    flags);
         fPicture->playback(canvas);
         fPicture.reset(recorder.endRecording());
     }
 }
 
 void PictureRenderer::resetState(bool callFinish) {
 #if SK_SUPPORT_GPU
@@ skipping 127 matching lines @@
     bool onUseEncodedData(const void*, size_t) SK_OVERRIDE { return true; }
     SkData* onEncodePixels(const SkImageInfo& info, const void* pixels,
                            size_t rowBytes) SK_OVERRIDE {
         return SkImageEncoder::EncodeData(info, pixels, rowBytes, SkImageEncoder::kPNG_Type, 100);
     }
 };
 
 bool RecordPictureRenderer::render(SkBitmap** out) {
     SkAutoTDelete<SkBBHFactory> factory(this->getFactory());
     SkPictureRecorder recorder;
-    SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(this->getViewWidth()), 
+    SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(this->getViewWidth()),
                                                SkIntToScalar(this->getViewHeight()),
                                                factory.get(),
                                                this->recordFlags());
     this->scaleToScaleFactor(canvas);
     fPicture->playback(canvas);
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
     if (!fWritePath.isEmpty()) {
         // Record the new picture as a new SKP with PNG encoded bitmaps.
         SkString skpPath = SkOSPath::Join(fWritePath.c_str(), fInputFilename.c_str());
         SkFILEWStream stream(skpPath.c_str());
@@ skipping 18 matching lines @@
     }
 
     PipeController pipeController(fCanvas.get());
     SkGPipeWriter writer;
     SkCanvas* pipeCanvas = writer.startRecording(&pipeController);
     pipeCanvas->drawPicture(fPicture);
     writer.endRecording();
     fCanvas->flush();
     if (out) {
         *out = SkNEW(SkBitmap);
-        setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()), 
+        setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()),
                            SkScalarCeilToInt(fPicture->cullRect().height()));
         fCanvas->readPixels(*out, 0, 0);
     }
     if (fEnableWrites) {
         return write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
                      fUseChecksumBasedFilenames);
     } else {
         return true;
     }
 }
 
 SkString PipePictureRenderer::getConfigNameInternal() {
     return SkString("pipe");
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 void SimplePictureRenderer::init(const SkPicture* picture, const SkString* writePath,
                                  const SkString* mismatchPath, const SkString* inputFilename,
                                  bool useChecksumBasedFilenames, bool useMultiPictureDraw) {
-    INHERITED::init(picture, writePath, mismatchPath, inputFilename, 
+    INHERITED::init(picture, writePath, mismatchPath, inputFilename,
                     useChecksumBasedFilenames, useMultiPictureDraw);
     this->buildBBoxHierarchy();
 }
 
 bool SimplePictureRenderer::render(SkBitmap** out) {
     SkASSERT(fCanvas.get() != NULL);
     SkASSERT(fPicture);
     if (NULL == fCanvas.get() || NULL == fPicture) {
         return false;
     }
 
     if (fUseMultiPictureDraw) {
         SkMultiPictureDraw mpd;
 
         mpd.add(fCanvas, fPicture);
 
         mpd.draw();
     } else {
         fCanvas->drawPicture(fPicture);
     }
     fCanvas->flush();
     if (out) {
         *out = SkNEW(SkBitmap);
-        setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()), 
+        setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()),
                            SkScalarCeilToInt(fPicture->cullRect().height()));
         fCanvas->readPixels(*out, 0, 0);
     }
     if (fEnableWrites) {
         return write(fCanvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
                      fUseChecksumBasedFilenames);
     } else {
         return true;
     }
 }
@@ skipping 190 matching lines @@
         return true;
     }
     return false;
 }
 
 void TiledPictureRenderer::drawCurrentTile() {
     SkASSERT(fCurrentTileOffset >= 0 && fCurrentTileOffset < fTileRects.count());
     draw_tile_to_canvas(fCanvas, fTileRects[fCurrentTileOffset], fPicture);
 }
 
-bool TiledPictureRenderer::postRender(SkCanvas* canvas, const SkIRect& tileRect, 
+bool TiledPictureRenderer::postRender(SkCanvas* canvas, const SkIRect& tileRect,
                                       SkBitmap* tempBM, SkBitmap** out,
                                       int tileNumber) {
     bool success = true;
 
     if (fEnableWrites) {
         success &= write(canvas, fWritePath, fMismatchPath, fInputFilename, fJsonSummaryPtr,
                          fUseChecksumBasedFilenames, &tileNumber);
     }
     if (out) {
         if (canvas->readPixels(tempBM, 0, 0)) {
             // Add this tile to the entire bitmap.
             bitmapCopyAtOffset(*tempBM, *out, tileRect.left(), tileRect.top());
         } else {
             success = false;
         }
     }
 
     return success;
 }
 
 bool TiledPictureRenderer::render(SkBitmap** out) {
     SkASSERT(fPicture != NULL);
     if (NULL == fPicture) {
         return false;
     }
 
     SkBitmap bitmap;
     if (out) {
         *out = SkNEW(SkBitmap);
-        setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()), 
+        setup_bitmap(*out, SkScalarCeilToInt(fPicture->cullRect().width()),
                            SkScalarCeilToInt(fPicture->cullRect().height()));
         setup_bitmap(&bitmap, fTileWidth, fTileHeight);
     }
     bool success = true;
 
     if (fUseMultiPictureDraw) {
         SkMultiPictureDraw mpd;
         SkTDArray<SkSurface*> surfaces;
         surfaces.setReserve(fTileRects.count());
 
@@ skipping 79 matching lines @@
         name.appendf("%i", fTileHeight);
     }
     return name;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 void PlaybackCreationRenderer::setup() {
     SkAutoTDelete<SkBBHFactory> factory(this->getFactory());
     fRecorder.reset(SkNEW(SkPictureRecorder));
-    SkCanvas* canvas = fRecorder->beginRecording(SkIntToScalar(this->getViewWidth()), 
+    SkCanvas* canvas = fRecorder->beginRecording(SkIntToScalar(this->getViewWidth()),
                                                  SkIntToScalar(this->getViewHeight()),
                                                  factory.get(),
                                                  this->recordFlags());
     this->scaleToScaleFactor(canvas);
     canvas->drawPicture(fPicture);
 }
 
 bool PlaybackCreationRenderer::render(SkBitmap** out) {
     fPicture.reset(fRecorder->endRecording());
     // Since this class does not actually render, return false.
     return false;
 }
 
 SkString PlaybackCreationRenderer::getConfigNameInternal() {
     return SkString("playback_creation");
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // SkPicture variants for each BBoxHierarchy type
 
 SkBBHFactory* PictureRenderer::getFactory() {
     switch (fBBoxHierarchyType) {
         case kNone_BBoxHierarchyType:
             return NULL;
         case kRTree_BBoxHierarchyType:
             return SkNEW(SkRTreeFactory);
-        case kTileGrid_BBoxHierarchyType:
-            return SkNEW_ARGS(SkTileGridFactory, (fGridInfo));
     }
     SkASSERT(0); // invalid bbhType
     return NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GatherRenderer : public PictureRenderer {
 public:
 #if SK_SUPPORT_GPU
@@ skipping 21 matching lines @@
 PictureRenderer* CreateGatherPixelRefsRenderer(const GrContext::Options& opts) {
     return SkNEW_ARGS(GatherRenderer, (opts));
 }
 #else
 PictureRenderer* CreateGatherPixelRefsRenderer() {
     return SkNEW(GatherRenderer);
 }
 #endif
 
 } // namespace sk_tools