Remove SkTileGrid (except for TileGridInfo).

tools/PictureRenderingFlags.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "PictureRenderingFlags.h"
 
 #include "CopyTilesRenderer.h"
@@ skipping 74 matching lines @@
 
 sk_tools::PictureRenderer* parseRenderer(SkString& error, PictureTool tool) {
     error.reset();
 
     bool useTiles = false;
     const char* widthString = NULL;
     const char* heightString = NULL;
     bool isPowerOf2Mode = false;
     bool isCopyMode = false;
     const char* mode = NULL;
-    bool gridSupported = false;
 
 #if SK_SUPPORT_GPU
     GrContext::Options grContextOpts;
     grContextOpts.fDrawPathToCompressedTexture = FLAGS_gpuCompressAlphaMasks;
   #define RENDERER_ARGS (grContextOpts)
 #else
   #define RENDERER_ARGS ()
 #endif
 
     SkAutoTUnref<sk_tools::PictureRenderer> renderer;
     if (FLAGS_mode.count() >= 1) {
         mode = FLAGS_mode[0];
         if (0 == strcmp(mode, "record")) {
             renderer.reset(SkNEW_ARGS(sk_tools::RecordPictureRenderer, RENDERER_ARGS));
-            gridSupported = true;
         } else if (0 == strcmp(mode, "tile") || 0 == strcmp(mode, "pow2tile")
                    || 0 == strcmp(mode, "copyTile")) {
             useTiles = true;
 
             if (0 == strcmp(mode, "pow2tile")) {
                 isPowerOf2Mode = true;
             } else if (0 == strcmp(mode, "copyTile")) {
                 isCopyMode = true;
-            } else {
-                gridSupported = true;
             }
 
             if (FLAGS_mode.count() < 2) {
                 error.printf("Missing width for --mode %s\n", mode);
                 return NULL;
             }
 
             widthString = FLAGS_mode[1];
             if (FLAGS_mode.count() < 3) {
                 error.printf("Missing height for --mode %s\n", mode);
                 return NULL;
             }
 
             heightString = FLAGS_mode[2];
         } else if (0 == strcmp(mode, "playbackCreation") && kBench_PictureTool == tool) {
             renderer.reset(SkNEW_ARGS(sk_tools::PlaybackCreationRenderer, RENDERER_ARGS));
-            gridSupported = true;
         // undocumented
         } else if (0 == strcmp(mode, "gatherPixelRefs") && kBench_PictureTool == tool) {
 #if SK_SUPPORT_GPU
             renderer.reset(sk_tools::CreateGatherPixelRefsRenderer(grContextOpts));
 #else
             renderer.reset(sk_tools::CreateGatherPixelRefsRenderer());
 #endif
         } else if (0 == strcmp(mode, "rerecord") && kRender_PictureTool == tool) {
             renderer.reset(SkNEW_ARGS(sk_tools::RecordPictureRenderer, RENDERER_ARGS));
         // Allow 'mode' to be set to 'simple', but do not create a renderer, so we can
         // ensure that pipe does not override a mode besides simple. The renderer will
         // be created below.
-        } else if (0 == strcmp(mode, "simple")) {
-            gridSupported = true;
         } else {
             error.printf("%s is not a valid mode for --mode\n", mode);
             return NULL;
         }
     }
 
     if (useTiles) {
         SkASSERT(NULL == renderer);
         SkAutoTUnref<sk_tools::TiledPictureRenderer> tiledRenderer;
         if (isCopyMode) {
@@ skipping 185 matching lines @@
 
 
     sk_tools::PictureRenderer::BBoxHierarchyType bbhType
             = sk_tools::PictureRenderer::kNone_BBoxHierarchyType;
     if (FLAGS_bbh.count() > 0) {
         const char* type = FLAGS_bbh[0];
         if (0 == strcmp(type, "none")) {
             bbhType = sk_tools::PictureRenderer::kNone_BBoxHierarchyType;
         } else if (0 == strcmp(type, "rtree")) {
             bbhType = sk_tools::PictureRenderer::kRTree_BBoxHierarchyType;
-        } else if (0 == strcmp(type, "grid")) {
-            if (!gridSupported) {
-                error.printf("'--bbh grid' is not compatible with --mode=%s.\n", mode);
-                return NULL;
-            }
-            bbhType = sk_tools::PictureRenderer::kTileGrid_BBoxHierarchyType;
-            if (FLAGS_bbh.count() != 3) {
-                error.printf("--bbh grid requires a width and a height.\n");
-                return NULL;
-            }
-            int gridWidth = atoi(FLAGS_bbh[1]);
-            int gridHeight = atoi(FLAGS_bbh[2]);
-            renderer->setGridSize(gridWidth, gridHeight);
-
         } else {
             error.printf("%s is not a valid value for --bbhType\n", type);
             return NULL;
         }
         if (FLAGS_pipe && sk_tools::PictureRenderer::kNone_BBoxHierarchyType != bbhType) {
             error.printf("--pipe and --bbh cannot be used together\n");
             return NULL;
         }
     }
     renderer->setBBoxHierarchyType(bbhType);
     renderer->setScaleFactor(SkDoubleToScalar(FLAGS_scale));
 
     return renderer.detach();
 }