Remove SkTileGrid (except for TileGridInfo).

gm/gmmain.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*
  * Code for the "gm" (Golden Master) rendering comparison tool.
  *
@@ skipping 124 matching lines @@
 enum Backend {
     kRaster_Backend,
     kGPU_Backend,
     kPDF_Backend,
     kXPS_Backend,
 };
 
 enum BbhType {
     kNone_BbhType,
     kRTree_BbhType,
-    kTileGrid_BbhType,
 };
 
 enum ConfigFlags {
     kNone_ConfigFlag  = 0x0,
     /* Write GM images if a write path is provided. */
     kWrite_ConfigFlag = 0x1,
     /* Read reference GM images if a read path is provided. */
     kRead_ConfigFlag  = 0x2,
     kRW_ConfigFlag    = (kWrite_ConfigFlag | kRead_ConfigFlag),
     /* Use distance fields for rendering text */
@@ skipping 876 matching lines @@
 
         return errors;
     }
 
     static SkPicture* generate_new_picture(GM* gm, BbhType bbhType, uint32_t recordFlags,
                                            SkScalar scale = SK_Scalar1) {
         SkScalar width = SkScalarMul(SkIntToScalar(gm->getISize().width()), scale);
         SkScalar height = SkScalarMul(SkIntToScalar(gm->getISize().height()), scale);
 
         SkAutoTDelete<SkBBHFactory> factory;
-        if (kTileGrid_BbhType == bbhType) {
-            SkTileGridFactory::TileGridInfo info;
-            info.fMargin.setEmpty();
-            info.fOffset.setZero();
-            info.fTileInterval.set(16, 16);
-            factory.reset(SkNEW_ARGS(SkTileGridFactory, (info)));
-        } else if (kRTree_BbhType == bbhType) {
+        if (kRTree_BbhType == bbhType) {
             factory.reset(SkNEW(SkRTreeFactory));
         }
         SkPictureRecorder recorder;
         SkCanvas* cv = recorder.beginRecording(width, height, factory.get(), recordFlags);
         cv->scale(scale, scale);
         invokeGM(gm, cv, false, false);
         return recorder.endRecording();
     }
 
     static SkPicture* stream_to_new_picture(const SkPicture& src) {
@@ skipping 109 matching lines @@
             return compare_test_results_to_reference_bitmap(
                 gm->getName(), gRec.fName, renderModeDescriptor, bitmap, &referenceBitmap);
         }
         return kEmpty_ErrorCombination;
     }
 
     static SkSurface* CreateSurface(const ConfigData& config,
                                     const SkISize& size,
                                     GrSurface* gpuTarget) {
         if (config.fBackend == kRaster_Backend) {
-            SkImageInfo ii = SkImageInfo::Make(size.width(), size.height(), 
+            SkImageInfo ii = SkImageInfo::Make(size.width(), size.height(),
                                                config.fColorType, kPremul_SkAlphaType);
 
             return SkSurface::NewRaster(ii);
         }
 #if SK_SUPPORT_GPU
         else {
             uint32_t flags = (config.fFlags & kDFText_ConfigFlag) ?
                                 SkSurfaceProps::kUseDistanceFieldFonts_Flag : 0;
             SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
             return SkSurface::NewRenderTargetDirect(gpuTarget->asRenderTarget(), &props);
@@ skipping 529 matching lines @@
             SkPicture* pict = gmmain.generate_new_picture(gm, kRTree_BbhType, 0);
             SkAutoTUnref<SkPicture> aur(pict);
             SkBitmap bitmap;
             gmmain.generate_image_from_picture(gm, compareConfig, gpuTarget, pict, &bitmap);
             errorsForAllModes.add(gmmain.compare_test_results_to_reference_bitmap(
                 gm->getName(), compareConfig.fName, renderModeDescriptor, bitmap,
                 &comparisonBitmap));
         }
     }
 
-    if (FLAGS_tileGrid) {
-        for(int scaleIndex = 0; scaleIndex < tileGridReplayScales.count(); ++scaleIndex) {
-            SkScalar replayScale = tileGridReplayScales[scaleIndex];
-            SkString renderModeDescriptor("-tilegrid");
-            if (SK_Scalar1 != replayScale) {
-                renderModeDescriptor += "-scale-";
-                renderModeDescriptor.appendScalar(replayScale);
-            }
-
-            if ((gmFlags & GM::kSkipPicture_Flag) ||
-                (gmFlags & GM::kSkipTiled_Flag) ||
-                ((gmFlags & GM::kSkipScaledReplay_Flag) && replayScale != 1)) {
-                gmmain.RecordTestResults(kIntentionallySkipped_ErrorType, shortNamePlusConfig,
-                                         renderModeDescriptor.c_str());
-                errorsForAllModes.add(kIntentionallySkipped_ErrorType);
-            } else {
-                // We record with the reciprocal scale to obtain a replay
-                // result that can be validated against comparisonBitmap.
-                SkScalar recordScale = SkScalarInvert(replayScale);
-                SkPicture* pict = gmmain.generate_new_picture(
-                    gm, kTileGrid_BbhType, 0, recordScale);
-                SkAutoTUnref<SkPicture> aur(pict);
-                SkBitmap bitmap;
-                // We cannot yet pass 'true' to generate_image_from_picture to
-                // perform actual tiled rendering (see Issue 1198 -
-                // https://code.google.com/p/skia/issues/detail?id=1198)
-                gmmain.generate_image_from_picture(gm, compareConfig, gpuTarget, pict, &bitmap,
-                                                   replayScale /*, true */);
-                errorsForAllModes.add(gmmain.compare_test_results_to_reference_bitmap(
-                    gm->getName(), compareConfig.fName, renderModeDescriptor.c_str(), bitmap,
-                    &comparisonBitmap));
-            }
-        }
-    }
-
     // run the pipe centric GM steps
     if (FLAGS_pipe) {
         errorsForAllModes.add(gmmain.test_pipe_playback(gm, compareConfig, comparisonBitmap,
                                                         FLAGS_simulatePipePlaybackFailure));
         if (FLAGS_tiledPipe) {
             errorsForAllModes.add(gmmain.test_tiled_pipe_playback(gm, compareConfig,
                                                                   comparisonBitmap));
         }
     }
     return errorsForAllModes;
@@ skipping 129 matching lines @@
         }
 
         if (FLAGS_mpd && (kGPU_Backend == config.fBackend || kRaster_Backend == config.fBackend)) {
 
             if (gmFlags & GM::kSkipPicture_Flag) {
                 gmmain.RecordSkippedTest(shortNamePlusConfig,
                                          renderModeDescriptor,
                                          config.fBackend);
                 errorsForThisConfig.add(kIntentionallySkipped_ErrorType);
             } else if (!(gmFlags & GM::kGPUOnly_Flag)) {
-                errorsForThisConfig.add(gmmain.testMPDDrawing(gm, config, 
+                errorsForThisConfig.add(gmmain.testMPDDrawing(gm, config,
                                                               writePath, gpuTarget,
                                                               comparisonBitmap));
             }
         }
 
         errorsForAllConfigs.add(errorsForThisConfig);
     }
     return errorsForAllConfigs;
 }
 
@@ skipping 659 matching lines @@
     if (FLAGS_forceBWtext) {
         canvas->setDrawFilter(SkNEW(BWTextDrawFilter))->unref();
     }
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif