Get gpudft support working in dm, gm, nanobench and bench_pictures

tools/PictureRenderer.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef PictureRenderer_DEFINED
 #define PictureRenderer_DEFINED
 
@@ skipping 202 matching lines @@
             fGrContext->ref();
             return true;
         }
 #endif
     }
 
 #if SK_SUPPORT_GPU
     void setSampleCount(int sampleCount) {
         fSampleCount = sampleCount;
     }
+
+    void setUseDFText(bool useDFText) {
+        fUseDFText = useDFText;
+    }
 #endif
 
     void setDrawFilters(DrawFilterFlags const * const filters, const SkString& configName) {
         memcpy(fDrawFilters, filters, sizeof(fDrawFilters));
         fDrawFiltersConfig = configName;
     }
 
     void setBBoxHierarchyType(BBoxHierarchyType bbhType) {
         fBBoxHierarchyType = bbhType;
     }
@@ skipping 34 matching lines @@
             config.append("_");
             config.appendS32(fGridInfo.fTileInterval.width());
             config.append("x");
             config.appendS32(fGridInfo.fTileInterval.height());
         }
 #if SK_SUPPORT_GPU
         switch (fDeviceType) {
             case kGPU_DeviceType:
                 if (fSampleCount) {
                     config.appendf("_msaa%d", fSampleCount);
+                } else if (fUseDFText) {
+                    config.append("_gpudft");
                 } else {
                     config.append("_gpu");
                 }
                 break;
             case kNVPR_DeviceType:
                 config.appendf("_nvprmsaa%d", fSampleCount);
                 break;
 #if SK_ANGLE
             case kAngle_DeviceType:
                 config.append("_angle");
@@ skipping 31 matching lines @@
             result["bbh"] = tmp.c_str();
         }
 #if SK_SUPPORT_GPU
         SkString tmp;
         switch (fDeviceType) {
             case kGPU_DeviceType:
                 if (0 != fSampleCount) {
                     tmp = "msaa";
                     tmp.appendS32(fSampleCount);
                     result["config"] = tmp.c_str();
+                } else if (fUseDFText) {
+                    result["config"] = "gpudft";
                 } else {
                     result["config"] = "gpu";
                 }
                 break;
             case kNVPR_DeviceType:
                 tmp = "nvprmsaa";
                 tmp.appendS32(fSampleCount);
                 result["config"] = tmp.c_str();
                 break;
 #if SK_ANGLE
@@ skipping 83 matching lines @@
 #endif
         : fJsonSummaryPtr(NULL)
         , fDeviceType(kBitmap_DeviceType)
         , fEnableWrites(false)
         , fBBoxHierarchyType(kNone_BBoxHierarchyType)
         , fScaleFactor(SK_Scalar1)
 #if SK_SUPPORT_GPU
         , fGrContextFactory(opts)
         , fGrContext(NULL)
         , fSampleCount(0)
+        , fUseDFText(false)
 #endif
         {
             fGridInfo.fMargin.setEmpty();
             fGridInfo.fOffset.setZero();
             fGridInfo.fTileInterval.set(1, 1);
             sk_bzero(fDrawFilters, sizeof(fDrawFilters));
             fViewport.set(0, 0);
         }
 
 #if SK_SUPPORT_GPU
@@ skipping 47 matching lines @@
      */
     static void CopyString(SkString* dest, const SkString* src);
 
 private:
     SkISize                fViewport;
     SkScalar               fScaleFactor;
 #if SK_SUPPORT_GPU
     GrContextFactory       fGrContextFactory;
     GrContext*             fGrContext;
     int                    fSampleCount;
+    bool                   fUseDFText;
 #endif
 
     virtual SkString getConfigNameInternal() = 0;
 
     typedef SkRefCnt INHERITED;
 };
 
 /**
  * This class does not do any rendering, but its render function executes recording, which we want
  * to time.
@@ skipping 213 matching lines @@
 
 #if SK_SUPPORT_GPU
 extern PictureRenderer* CreateGatherPixelRefsRenderer(const GrContext::Options& opts);
 #else
 extern PictureRenderer* CreateGatherPixelRefsRenderer();
 #endif
 
 }
 
 #endif  // PictureRenderer_DEFINED