Make NVPR a GL context option instead of a GL context

dm/DMSrcSink.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 "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkAndroidCodec.h"
@@ skipping 771 matching lines @@
 Error NullSink::draw(const Src& src, SkBitmap*, SkWStream*, SkString*) const {
     SkAutoTDelete<SkCanvas> canvas(SkCreateNullCanvas());
     return src.draw(canvas);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 DEFINE_bool(gpuStats, false, "Append GPU stats to the log for each GPU task?");
 
 GPUSink::GPUSink(GrContextFactory::GLContextType ct,
-                 GrGLStandard api,
+                 GrGLStandard gpuAPI,
                  int samples,
                  bool diText,
                  bool threaded)
     : fContextType(ct)
-    , fGpuAPI(api)
+    , fContextOptions(GrContextFactory::kNone_GLContextOptions)
+    , fGpuAPI(gpuAPI)
     , fSampleCount(samples)
     , fUseDIText(diText)
     , fThreaded(threaded) {}
+
+GPUSink::GPUSink(GrContextFactory::GLContextType ct,
+                 GrContextFactory::GLContextOptions options,
+                 GrGLStandard gpuAPI,
+                 int samples,
+                 bool diText,
+                 bool threaded)
+    : fContextType(ct)
+    , fContextOptions(options)
+    , fGpuAPI(gpuAPI)
+    , fSampleCount(samples)
+    , fUseDIText(diText)
+    , fThreaded(threaded) {}
 
 int GPUSink::enclave() const {
     return fThreaded ? kAnyThread_Enclave : kGPU_Enclave;
 }
 
 void PreAbandonGpuContextErrorHandler(SkError, void*) {}
 
 DEFINE_bool(imm, false, "Run gpu configs in immediate mode.");
 DEFINE_bool(batchClip, false, "Clip each GrBatch to its device bounds for testing.");
 
 Error GPUSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString* log) const {
-    GrContextOptions options;
+    GrContextOptions grOptions;
     if (FLAGS_imm) {
-        options.fImmediateMode = true;
+        grOptions.fImmediateMode = true;
     }
     if (FLAGS_batchClip) {
-        options.fClipBatchToBounds = true;
+        grOptions.fClipBatchToBounds = true;
     }
-    src.modifyGrContextOptions(&options);
+    src.modifyGrContextOptions(&grOptions);
 
-    GrContextFactory factory(options);
+    GrContextFactory factory(grOptions);
     const SkISize size = src.size();
     const SkImageInfo info =
         SkImageInfo::Make(size.width(), size.height(), kN32_SkColorType, kPremul_SkAlphaType);
     SkAutoTUnref<SkSurface> surface(
-            NewGpuSurface(&factory, fContextType, fGpuAPI, info, fSampleCount, fUseDIText));
+            NewGpuSurface(&factory, fContextType, fContextOptions, fGpuAPI, info, fSampleCount, fUseDIText));
     if (!surface) {
         return "Could not create a surface.";
     }
     if (FLAGS_preAbandonGpuContext) {
         SkSetErrorCallback(&PreAbandonGpuContextErrorHandler, nullptr);
         factory.abandonContexts();
     }
     SkCanvas* canvas = surface->getCanvas();
     Error err = src.draw(canvas);
     if (!err.isEmpty()) {
@@ skipping 423 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return "";
     });
 }
 
 }  // namespace DM