Deprecate SkPicture::clone().

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 48 matching lines @@
               "\tpicture is large enough, it is broken into larger tiles to avoid\n"
               "\tcreating a large canvas.\n"
 // TODO: If bench_pictures and render_pictures were two separate targets, we could use build flags
 // to determine which modes to display.
               "record: (Only in bench_pictures) Time recording from a picture to a new\n"
               "\tpicture.\n"
               "playbackCreation: (Only in bench_pictures) Time creation of the \n"
               "\tSkPicturePlayback.\n"
               "rerecord: (Only in render_pictures) Record the picture as a new skp,\n"
               "\twith the bitmaps PNG encoded.\n");
-DEFINE_int32(multi, 1, "Set the number of threads for multi threaded drawing. "
-             "If > 1, requires tiled rendering.");
 DEFINE_bool(pipe, false, "Use SkGPipe rendering. Currently incompatible with \"mode\".");
 DEFINE_string2(readPath, r, "", "skp files or directories of skp files to process.");
 DEFINE_double(scale, 1, "Set the scale factor.");
 DEFINE_string(tiles, "", "Used with --mode copyTile to specify number of tiles per larger tile "
               "in the x and y directions.");
 DEFINE_string(viewport, "", "width height: Set the viewport.");
 
 sk_tools::PictureRenderer* parseRenderer(SkString& error, PictureTool tool) {
     error.reset();
 
-    if (FLAGS_multi <= 0) {
-        error.printf("--multi must be > 0, was %i", FLAGS_multi);
-        return NULL;
-    }
-
     bool useTiles = false;
     const char* widthString = NULL;
     const char* heightString = NULL;
     bool isPowerOf2Mode = false;
     bool isCopyMode = false;
     const char* mode = NULL;
     bool gridSupported = false;
 
     SkAutoTUnref<sk_tools::PictureRenderer> renderer;
     if (FLAGS_mode.count() >= 1) {
         mode = FLAGS_mode[0];
         if (0 == strcmp(mode, "record")) {
             renderer.reset(SkNEW(sk_tools::RecordPictureRenderer));
             gridSupported = true;
-        // undocumented
-        } else if (0 == strcmp(mode, "clone")) {
-            renderer.reset(sk_tools::CreatePictureCloneRenderer());
         } 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;
@@ skipping 50 matching lines @@
                 x = xTiles;
                 y = yTiles;
                 if (x <= 0 || y <= 0) {
                     error.printf("--tiles must be given values > 0\n");
                     return NULL;
                 }
             } else {
                 x = y = 4;
             }
             tiledRenderer.reset(SkNEW_ARGS(sk_tools::CopyTilesRenderer, (x, y)));
-        } else if (FLAGS_multi > 1) {
-            tiledRenderer.reset(SkNEW_ARGS(sk_tools::MultiCorePictureRenderer,
-                                           (FLAGS_multi)));
         } else {
             tiledRenderer.reset(SkNEW(sk_tools::TiledPictureRenderer));
         }
 
         if (isPowerOf2Mode) {
             int minWidth = atoi(widthString);
             if (!SkIsPow2(minWidth) || minWidth < 0) {
                 SkString err;
                 error.printf("-mode %s must be given a width"
                              " value that is a power of two\n", mode);
@@ skipping 37 matching lines @@
             }
         }
 
         renderer.reset(tiledRenderer.detach());
         if (FLAGS_pipe) {
             error.printf("Pipe rendering is currently not compatible with tiling.\n"
                          "Turning off pipe.\n");
         }
 
     } else { // useTiles
-        if (FLAGS_multi > 1) {
-            error.printf("Multithreaded drawing requires tiled rendering.\n");
-            return NULL;
-        }
         if (FLAGS_pipe) {
             if (renderer != NULL) {
                 error.printf("Pipe is incompatible with other modes.\n");
                 return NULL;
             }
             renderer.reset(SkNEW(sk_tools::PipePictureRenderer));
         }
     }
 
     if (NULL == renderer) {
@@ skipping 16 matching lines @@
 #if SK_SUPPORT_GPU
     int sampleCount = 0;
 #endif
     if (FLAGS_config.count() > 0) {
         if (0 == strcmp(FLAGS_config[0], "8888")) {
             deviceType = sk_tools::PictureRenderer::kBitmap_DeviceType;
         }
 #if SK_SUPPORT_GPU
         else if (0 == strcmp(FLAGS_config[0], "gpu")) {
             deviceType = sk_tools::PictureRenderer::kGPU_DeviceType;
-            if (FLAGS_multi > 1) {
-                error.printf("GPU not compatible with multithreaded tiling.\n");
-                return NULL;
-            }
         }
         else if (0 == strcmp(FLAGS_config[0], "msaa4")) {
             deviceType = sk_tools::PictureRenderer::kGPU_DeviceType;
-            if (FLAGS_multi > 1) {
-                error.printf("GPU not compatible with multithreaded tiling.\n");
-                return NULL;
-            }
             sampleCount = 4;
         }
         else if (0 == strcmp(FLAGS_config[0], "msaa16")) {
             deviceType = sk_tools::PictureRenderer::kGPU_DeviceType;
-            if (FLAGS_multi > 1) {
-                error.printf("GPU not compatible with multithreaded tiling.\n");
-                return NULL;
-            }
             sampleCount = 16;
         }
         else if (0 == strcmp(FLAGS_config[0], "nvprmsaa4")) {
             deviceType = sk_tools::PictureRenderer::kNVPR_DeviceType;
-            if (FLAGS_multi > 1) {
-                error.printf("GPU not compatible with multithreaded tiling.\n");
-                return NULL;
-            }
             sampleCount = 4;
         }
         else if (0 == strcmp(FLAGS_config[0], "nvprmsaa16")) {
             deviceType = sk_tools::PictureRenderer::kNVPR_DeviceType;
-            if (FLAGS_multi > 1) {
-                error.printf("GPU not compatible with multithreaded tiling.\n");
-                return NULL;
-            }
             sampleCount = 16;
         }
 #if SK_ANGLE
         else if (0 == strcmp(FLAGS_config[0], "angle")) {
             deviceType = sk_tools::PictureRenderer::kAngle_DeviceType;
-            if (FLAGS_multi > 1) {
-                error.printf("Angle not compatible with multithreaded tiling.\n");
-                return NULL;
-            }
         }
 #endif
 #if SK_MESA
         else if (0 == strcmp(FLAGS_config[0], "mesa")) {
             deviceType = sk_tools::PictureRenderer::kMesa_DeviceType;
-            if (FLAGS_multi > 1) {
-                error.printf("Mesa not compatible with multithreaded tiling.\n");
-                return NULL;
-            }
         }
 #endif
 #endif
         else {
             error.printf("%s is not a valid mode for --config\n", FLAGS_config[0]);
             return NULL;
         }
         renderer->setDeviceType(deviceType);
 #if SK_SUPPORT_GPU
         renderer->setSampleCount(sampleCount);
@@ skipping 32 matching lines @@
         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();
 }