Fix for nexus 5 crashing in GL benches

tools/VisualBench/VisualInteractiveModule.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  */
 
 #include "VisualInteractiveModule.h"
 
@@ skipping 80 matching lines @@
     }
 
     fBenchmark.reset(fBenchmarkStream->next());
     if (!fBenchmark) {
         return false;
     }
 
     // clear both buffers
     fOwner->clear(canvas, SK_ColorWHITE, 2);
 
-    fBenchmark->preDraw();
+    fBenchmark->delayedSetup();
 
     return true;
 }
 
 void VisualInteractiveModule::draw(SkCanvas* canvas) {
     if (!this->advanceRecordIfNecessary(canvas)) {
         SkDebugf("Exiting VisualBench successfully\n");
         fOwner->closeWindow();
         return;
     }
     this->renderFrame(canvas);
     switch (fState) {
         case kPreWarmLoopsPerCanvasPreDraw_State: {
             this->perCanvasPreDraw(canvas, kPreWarmLoops_State);
             break;
         }
         case kPreWarmLoops_State: {
             this->preWarm(kTuneLoops_State);
             break;
         }
         case kTuneLoops_State: {
             this->tuneLoops(canvas);
             break;
         }
         case kPreTiming_State: {
             fBenchmark->perCanvasPreDraw(canvas);
+            fBenchmark->preDraw(canvas);
             fCurrentFrame = 0;
             fTimer.start();
             fState = kTiming_State;
             // fall to next state
         }
         case kTiming_State: {
             this->timing(canvas);
             break;
         }
         case kAdvance_State: {
             this->postDraw(canvas);
             this->nextState(kPreWarmLoopsPerCanvasPreDraw_State);
             break;
         }
     }
 }
 
 inline void VisualInteractiveModule::nextState(State nextState) {
     fState = nextState;
 }
 
 void VisualInteractiveModule::perCanvasPreDraw(SkCanvas* canvas, State nextState) {
     fBenchmark->perCanvasPreDraw(canvas);
+    fBenchmark->preDraw(canvas);
     fCurrentFrame = 0;
     this->nextState(nextState);
 }
 
 void VisualInteractiveModule::preWarm(State nextState) {
     if (fCurrentFrame >= kGpuFrameLag) {
         // we currently time across all frames to make sure we capture all GPU work
         this->nextState(nextState);
         fCurrentFrame = 0;
         fTimer.start();
@@ skipping 38 matching lines @@
 }
 
 void VisualInteractiveModule::recordMeasurement() {
     double measurement = this->elapsed() / (kFrames * fLoops);
     fMeasurements[fCurrentMeasurement++] = measurement;
     fCurrentMeasurement &= (kMeasurementCount-1);  // fast mod
     SkASSERT(fCurrentMeasurement < kMeasurementCount);
 }
 
 void VisualInteractiveModule::postDraw(SkCanvas* canvas) {
+    fBenchmark->postDraw(canvas);
     fBenchmark->perCanvasPostDraw(canvas);
     fBenchmark.reset(nullptr);
     fLoops = 1;
 }
 
 inline void VisualInteractiveModule::timing(SkCanvas* canvas) {
     if (fCurrentFrame >= kFrames) {
         this->recordMeasurement();
         fTimer.start();
         fCurrentFrame = 0;
     } else {
         fCurrentFrame++;
     }
 }
 
 bool VisualInteractiveModule::onHandleChar(SkUnichar c) {
     if (' ' == c) {
         this->nextState(kAdvance_State);
     }
 
     return true;
 }