Don't crash if device creation fails in bench.

bench/benchmain.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.
  */
 
 
 #include "BenchTimer.h"
@@ skipping 764 matching lines @@
             continue;
         }
 
         bool loggedBenchStart = false;
 
         AutoPrePostDraw appd(bench);
 
         for (int x = 0; x < configs.count(); ++x) {
             int configIndex = configs[x];
 
+            bool setupFailed = false;
+
             if (kNonRendering_Backend == gConfigs[configIndex].fBackend) {
                 if (bench->isRendering()) {
                     continue;
                 }
             } else {
                 if (!bench->isRendering()) {
                     continue;
                 }
             }
 
@@ skipping 14 matching lines @@
                 glContext = gContextFactory.getGLContext(gConfigs[configIndex].fContextType);
             }
 #endif
             SkDevice* device = NULL;
             SkCanvas* canvas = NULL;
             SkPicture pictureRecordFrom;
             SkPicture pictureRecordTo;
 
             if (kNonRendering_Backend != backend) {
                 device = make_device(outConfig, dim, backend, sampleCount, context);
+                if (NULL == device) {
+                    SkString error;
+                    error.printf("Device creation failure for config %s. Will skip.\n", configName);
+                    logger.logError(error.c_str());
+                    setupFailed = true;
+                } else {
+                    switch(benchMode) {
+                        case kDeferredSilent_benchModes:
+                        case kDeferred_benchModes:
+                            canvas =
+#if SK_DEFERRED_CANVAS_USES_FACTORIES
+                                SkDeferredCanvas::Create(device);
+#else
+                                SkNEW_ARGS(SkDeferredCanvas, (device));
+#endif
+                            break;
+                        case kRecord_benchModes:
+                            canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY,
+                                SkPicture::kUsePathBoundsForClip_RecordingFlag);
+                            canvas->ref();
+                            break;
+                        case kPictureRecord_benchModes: {
+                            // This sets up picture-to-picture recording.
+                            // The C++ drawing calls for the benchmark are recorded into
+                            // pictureRecordFrom. As the benchmark, we will time how
+                            // long it takes to playback pictureRecordFrom into
+                            // pictureRecordTo.
+                            SkCanvas* tempCanvas = pictureRecordFrom.beginRecording(dim.fX, dim.fY,
+                                SkPicture::kUsePathBoundsForClip_RecordingFlag);
+                            bench->draw(tempCanvas);
+                            pictureRecordFrom.endRecording();
+                            canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY,
+                                SkPicture::kUsePathBoundsForClip_RecordingFlag);
+                            canvas->ref();
+                            break;
+                        }
+                        case kNormal_benchModes:
+                            canvas = new SkCanvas(device);
+                            break;
+                        default:
+                            SkASSERT(0);
+                    }
+                    device->unref();
+                    canvas->clear(SK_ColorWHITE);
+                }
+            }
+            SkAutoUnref canvasUnref(canvas);
+            if (!setupFailed) {
+                if (NULL != canvas) {
+                    if (doClip) {
+                        performClip(canvas, dim.fX, dim.fY);
+                    }
+                    if (doScale) {
+                        performScale(canvas, dim.fX, dim.fY);
+                    }
+                    if (doRotate) {
+                        performRotate(canvas, dim.fX, dim.fY);
+                    }
+                }
 
-                switch(benchMode) {
-                    case kDeferredSilent_benchModes:
-                    case kDeferred_benchModes:
-                        canvas =
-#if SK_DEFERRED_CANVAS_USES_FACTORIES
-                            SkDeferredCanvas::Create(device);
-#else
-                            SkNEW_ARGS(SkDeferredCanvas, (device));
+                if (!loggedBenchStart) {
+                    loggedBenchStart = true;
+                    SkString str;
+                    str.printf("running bench [%d %d] %28s", dim.fX, dim.fY, bench->getName());
+                    logger.logProgress(str);
+                }
+
+                // warm up caches if needed
+                if (repeatDraw > 1 && NULL != canvas) {
+#if SK_SUPPORT_GPU
+                    // purge the GPU resources to reduce variance
+                    if (NULL != context) {
+                        context->freeGpuResources();
+                    }
 #endif
-                        break;
-                    case kRecord_benchModes:
+                    SkAutoCanvasRestore acr(canvas, true);
+                    if (benchMode == kPictureRecord_benchModes) {
+                        pictureRecordFrom.draw(canvas);
+                    } else {
+                        bench->draw(canvas);
+                    }
+
+                    if (kDeferredSilent_benchModes == benchMode) {
+                        static_cast<SkDeferredCanvas*>(canvas)->silentFlush();
+                    } else {
+                        canvas->flush();
+                    }
+#if SK_SUPPORT_GPU
+                    if (NULL != context) {
+                        context->flush();
+                        SK_GL(*glContext, Finish());
+                    }
+#endif
+                }
+
+                // record timer values for each repeat, and their sum
+                TimerData timerData(perIterTimeformat, normalTimeFormat);
+                for (int i = 0; i < repeatDraw; i++) {
+                    if ((benchMode == kRecord_benchModes || benchMode == kPictureRecord_benchModes)) {
+                        // This will clear the recorded commands so that they do not
+                        // accumulate.
                         canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY,
                             SkPicture::kUsePathBoundsForClip_RecordingFlag);
-                        canvas->ref();
-                        break;
-                    case kPictureRecord_benchModes: {
-                        // This sets up picture-to-picture recording.
-                        // The C++ drawing calls for the benchmark are recorded into
-                        // pictureRecordFrom. As the benchmark, we will time how
-                        // long it takes to playback pictureRecordFrom into
-                        // pictureRecordTo.
-                        SkCanvas* tempCanvas = pictureRecordFrom.beginRecording(dim.fX, dim.fY,
-                            SkPicture::kUsePathBoundsForClip_RecordingFlag);
-                        bench->draw(tempCanvas);
-                        pictureRecordFrom.endRecording();
-                        canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY,
-                            SkPicture::kUsePathBoundsForClip_RecordingFlag);
-                        canvas->ref();
-                        break;
                     }
-                    case kNormal_benchModes:
-                        canvas = new SkCanvas(device);
-                        break;
-                    default:
-                        SkASSERT(0);
+
+                    timer->start(bench->getDurationScale());
+                    if (NULL != canvas) {
+                        canvas->save();
+                    }
+                    if (benchMode == kPictureRecord_benchModes) {
+                        pictureRecordFrom.draw(canvas);
+                    } else {
+                        bench->draw(canvas);
+                    }
+
+                    if (kDeferredSilent_benchModes == benchMode) {
+                        static_cast<SkDeferredCanvas*>(canvas)->silentFlush();
+                    } else if (NULL != canvas) {
+                        canvas->flush();
+                    }
+
+                    if (NULL != canvas) {
+                        canvas->restore();
+                    }
+
+                    // stop the truncated timer after the last canvas call but
+                    // don't wait for all the GL calls to complete
+                    timer->truncatedEnd();
+#if SK_SUPPORT_GPU
+                    if (NULL != glContext) {
+                        context->flush();
+                        SK_GL(*glContext, Finish());
+                    }
+#endif
+                    // stop the inclusive and gpu timers once all the GL calls
+                    // have completed
+                    timer->end();
+
+                    timerData.appendTimes(timer, repeatDraw - 1 == i);
+
                 }
-                device->unref();
-                canvas->clear(SK_ColorWHITE);
-            }
-            SkAutoUnref canvasUnref(canvas);
-
-            if (NULL != canvas) {
-                if (doClip) {
-                    performClip(canvas, dim.fX, dim.fY);
+                if (repeatDraw > 1) {
+                    SkString result = timerData.getResult(
+                                        logPerIter, printMin, repeatDraw, configName,
+                                        timerWall, truncatedTimerWall, timerCpu,
+                                        truncatedTimerCpu,
+                                        timerGpu && NULL != context);
+                    logger.logProgress(result);
                 }
-                if (doScale) {
-                    performScale(canvas, dim.fX, dim.fY);
-                }
-                if (doRotate) {
-                    performRotate(canvas, dim.fX, dim.fY);
+                if (outDir.size() > 0 && kNonRendering_Backend != backend) {
+                    saveFile(bench->getName(), configName, outDir.c_str(),
+                             device->accessBitmap(false));
                 }
             }
-
-            if (!loggedBenchStart) {
-                loggedBenchStart = true;
-                SkString str;
-                str.printf("running bench [%d %d] %28s", dim.fX, dim.fY, bench->getName());
-                logger.logProgress(str);
+            if (loggedBenchStart) {
+                logger.logProgress(SkString("\n"));
             }
-
-            // warm up caches if needed
-            if (repeatDraw > 1 && NULL != canvas) {
-#if SK_SUPPORT_GPU
-                // purge the GPU resources to reduce variance
-                if (NULL != context) {
-                    context->freeGpuResources();
-                }
-#endif
-                SkAutoCanvasRestore acr(canvas, true);
-                if (benchMode == kPictureRecord_benchModes) {
-                    pictureRecordFrom.draw(canvas);
-                } else {
-                    bench->draw(canvas);
-                }
-
-                if (kDeferredSilent_benchModes == benchMode) {
-                    static_cast<SkDeferredCanvas*>(canvas)->silentFlush();
-                } else {
-                    canvas->flush();
-                }
-#if SK_SUPPORT_GPU
-                if (NULL != context) {
-                    context->flush();
-                    SK_GL(*glContext, Finish());
-                }
-#endif
-            }
-
-            // record timer values for each repeat, and their sum
-            TimerData timerData(perIterTimeformat, normalTimeFormat);
-            for (int i = 0; i < repeatDraw; i++) {
-                if ((benchMode == kRecord_benchModes || benchMode == kPictureRecord_benchModes)) {
-                    // This will clear the recorded commands so that they do not
-                    // accumulate.
-                    canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY,
-                        SkPicture::kUsePathBoundsForClip_RecordingFlag);
-                }
-
-                timer->start(bench->getDurationScale());
-                if (NULL != canvas) {
-                    canvas->save();
-                }
-                if (benchMode == kPictureRecord_benchModes) {
-                    pictureRecordFrom.draw(canvas);
-                } else {
-                    bench->draw(canvas);
-                }
-
-                if (kDeferredSilent_benchModes == benchMode) {
-                    static_cast<SkDeferredCanvas*>(canvas)->silentFlush();
-                } else if (NULL != canvas) {
-                    canvas->flush();
-                }
-
-                if (NULL != canvas) {
-                    canvas->restore();
-                }
-
-                // stop the truncated timer after the last canvas call but
-                // don't wait for all the GL calls to complete
-                timer->truncatedEnd();
-#if SK_SUPPORT_GPU
-                if (NULL != glContext) {
-                    context->flush();
-                    SK_GL(*glContext, Finish());
-                }
-#endif
-                // stop the inclusive and gpu timers once all the GL calls
-                // have completed
-                timer->end();
-
-                timerData.appendTimes(timer, repeatDraw - 1 == i);
-
-            }
-            if (repeatDraw > 1) {
-                SkString result = timerData.getResult(logPerIter, printMin, repeatDraw, configName,
-                                                      timerWall, truncatedTimerWall, timerCpu,
-                                                      truncatedTimerCpu,
-                                                      timerGpu && NULL != context);
-                logger.logProgress(result);
-            }
-            if (outDir.size() > 0 && kNonRendering_Backend != backend) {
-                saveFile(bench->getName(), configName, outDir.c_str(),
-                         device->accessBitmap(false));
-            }
-        }
-        if (loggedBenchStart) {
-            logger.logProgress(SkString("\n"));
         }
     }
 #if SK_SUPPORT_GPU
 #if GR_CACHE_STATS
     for (int i = 0; i <= GrContextFactory::kLastGLContextType; ++i) {
         GrContextFactory::GLContextType ctxType = (GrContextFactory::GLContextType)i;
         GrContext* context = gContextFactory.get(ctxType);
         if (NULL != context) {
             SkDebugf("Cache Stats for %s context:\n", GrContextFactory::GLContextTypeName(ctxType));
             context->printCacheStats();
             SkDebugf("\n");
         }
     }
 #endif
     // Destroy the GrContext before the inst tracking printing at main() exit occurs.
     gContextFactory.destroyContexts();
 #endif
     for (size_t i = 0; i < SK_ARRAY_COUNT(gConfigs); ++i) {
         SkDELETE(timers[i]);
     }
 
     return 0;
 }
 
 #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