skia: Add ANGLE with GL backend to nanobench/DM

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 26 matching lines @@
 namespace sk_tools {
 
 class TiledPictureRenderer;
 
 class PictureRenderer : public SkRefCnt {
 
 public:
     enum SkDeviceTypes {
 #if SK_ANGLE
         kAngle_DeviceType,
+        kAngle_GL_DeviceType,

[bsalomon, 2015/09/11 18:54:47]

The PictureRenderer stuff isn't really used anymore. Feel free to just not
modify this.

 #endif
 #if SK_COMMAND_BUFFER
         kCommandBuffer_DeviceType,
 #endif
 #if SK_MESA
         kMesa_DeviceType,
 #endif
         kBitmap_DeviceType,
 #if SK_SUPPORT_GPU
         kGPU_DeviceType,
@@ skipping 113 matching lines @@
 
     /**
      * Set the backend type. Returns true on success and false on failure.
      */
 #if SK_SUPPORT_GPU
     bool setDeviceType(SkDeviceTypes deviceType, GrGLStandard gpuAPI = kNone_GrGLStandard) {
 #else
     bool setDeviceType(SkDeviceTypes deviceType) {
 #endif
         fDeviceType = deviceType;
+        if (deviceType == kBitmap_DeviceType) {
+            return true;
+        }
+
 #if SK_SUPPORT_GPU
         // In case this function is called more than once
         SkSafeUnref(fGrContext);
         fGrContext = nullptr;
         // Set to Native so it will have an initial value.
-        GrContextFactory::GLContextType glContextType = GrContextFactory::kNative_GLContextType;
-#endif
-        switch(deviceType) {
-            case kBitmap_DeviceType:
-                return true;
-#if SK_SUPPORT_GPU
-            case kGPU_DeviceType:
-                // Already set to GrContextFactory::kNative_GLContextType, above.
-                break;
-            case kNVPR_DeviceType:
-                glContextType = GrContextFactory::kNVPR_GLContextType;
-                break;
-#if SK_ANGLE
-            case kAngle_DeviceType:
-                glContextType = GrContextFactory::kANGLE_GLContextType;
-                break;
-#endif
-#if SK_COMMAND_BUFFER
-            case kCommandBuffer_DeviceType:
-                glContextType = GrContextFactory::kCommandBuffer_GLContextType;
-                break;
-#endif
-#if SK_MESA
-            case kMesa_DeviceType:
-                glContextType = GrContextFactory::kMESA_GLContextType;
-                break;
-#endif
-#endif
-            default:
-                // Invalid device type.
-                return false;
+        GrContextFactory::GLContextType glContextType = getGPUContextType(fDeviceType);
+        if (GrContextFactory::kNull_GLContextType == glContextType) {
+            return false;
         }
-#if SK_SUPPORT_GPU
+
         fGrContext = fGrContextFactory.get(glContextType, gpuAPI);
         if (nullptr == fGrContext) {
             return false;
         } else {
             fGrContext->ref();
             return true;
         }
 #endif
+        return false;
     }
 
 #if SK_SUPPORT_GPU
     void setSampleCount(int sampleCount) {
         fSampleCount = sampleCount;
     }
 
     void setUseDFText(bool useDFText) {
         fUseDFText = useDFText;
     }
@@ skipping 52 matching lines @@
                     config.append("_gpu");
                 }
                 break;
             case kNVPR_DeviceType:
                 config.appendf("_nvprmsaa%d", fSampleCount);
                 break;
 #if SK_ANGLE
             case kAngle_DeviceType:
                 config.append("_angle");
                 break;
+            case kAngle_GL_DeviceType:
+                config.append("_angle-gl");
+                break;
 #endif
 #if SK_COMMAND_BUFFER
             case kCommandBuffer_DeviceType:
                 config.append("_commandbuffer");
                 break;
 #endif
 #if SK_MESA
             case kMesa_DeviceType:
                 config.append("_mesa");
                 break;
@@ skipping 34 matching lines @@
                 break;
             case kNVPR_DeviceType:
                 tmp = "nvprmsaa";
                 tmp.appendS32(fSampleCount);
                 result["config"] = tmp.c_str();
                 break;
 #if SK_ANGLE
             case kAngle_DeviceType:
                 result["config"] = "angle";
                 break;
+            case kAngle_GL_DeviceType:
+                result["config"] = "angle-gl";
+                break;
 #endif
 #if SK_COMMAND_BUFFER
             case kCommandBuffer_DeviceType:
                 result["config"] = "commandbuffer";
                 break;
 #endif
 #if SK_MESA
             case kMesa_DeviceType:
                 result["config"] = "mesa";
                 break;
 #endif
             default:
                 // Assume that no extra info means bitmap.
                 break;
         }
 #endif
         return result;
     }
 
 #if SK_SUPPORT_GPU
     bool isUsingGpuDevice() {
         switch (fDeviceType) {
             case kGPU_DeviceType:
             case kNVPR_DeviceType:
                 // fall through
 #if SK_ANGLE
             case kAngle_DeviceType:
+            case kAngle_GL_DeviceType:
                 // fall through
 #endif
 #if SK_COMMAND_BUFFER
             case kCommandBuffer_DeviceType:
                 // fall through
 #endif
 #if SK_MESA
             case kMesa_DeviceType:
 #endif
                 return true;
             default:
                 return false;
         }
     }
 
     SkGLContext* getGLContext() {
-        GrContextFactory::GLContextType glContextType
-                = GrContextFactory::kNull_GLContextType;
-        switch(fDeviceType) {
-            case kGPU_DeviceType:
-                glContextType = GrContextFactory::kNative_GLContextType;
-                break;
-            case kNVPR_DeviceType:
-                glContextType = GrContextFactory::kNVPR_GLContextType;
-                break;
-#if SK_ANGLE
-            case kAngle_DeviceType:
-                glContextType = GrContextFactory::kANGLE_GLContextType;
-                break;
-#endif
-#if SK_COMMAND_BUFFER
-            case kCommandBuffer_DeviceType:
-                glContextType = GrContextFactory::kCommandBuffer_GLContextType;
-                break;
-#endif
-#if SK_MESA
-            case kMesa_DeviceType:
-                glContextType = GrContextFactory::kMESA_GLContextType;
-                break;
-#endif
-            default:
-                return nullptr;
+        GrContextFactory::GLContextType glContextType = getGPUContextType(fDeviceType);
+        if (GrContextFactory::kNull_GLContextType == glContextType) {
+            return nullptr;
         }
         return fGrContextFactory.getGLContext(glContextType);
     }
 
     GrContext* getGrContext() {
         return fGrContext;
     }
 
     const GrContextOptions& getGrContextOptions() {
         return fGrContextFactory.getGlobalOptions();
@@ skipping 74 matching lines @@
     SkBBHFactory* getFactory();
     uint32_t recordFlags() const { return 0; }
     SkCanvas* setupCanvas();
     virtual SkCanvas* setupCanvas(int width, int height);
 
     /**
      * Copy src to dest; if src==nullptr, set dest to empty string.
      */
     static void CopyString(SkString* dest, const SkString* src);
 
+#if SK_SUPPORT_GPU
+    /**
+     * Get the context type for a given device type.  Returns kNull_GLContextType for non gpu
+     * device types.
+     */
+    GrContextFactory::GLContextType getGPUContextType(SkDeviceTypes deviceType) const {
+        GrContextFactory::GLContextType glContextType = GrContextFactory::kNull_GLContextType;
+        switch(deviceType) {
+            case kGPU_DeviceType:
+                glContextType = GrContextFactory::kNative_GLContextType;
+                break;
+            case kNVPR_DeviceType:
+                glContextType = GrContextFactory::kNVPR_GLContextType;
+                break;
+#if SK_ANGLE
+            case kAngle_DeviceType:
+                glContextType = GrContextFactory::kANGLE_GLContextType;
+                break;
+            case kAngle_GL_DeviceType:
+                glContextType = GrContextFactory::kANGLE_GL_GLContextType;
+                break;
+#endif // SK_ANGLE
+#if SK_COMMAND_BUFFER
+            case kCommandBuffer_DeviceType:
+                glContextType = GrContextFactory::kCommandBuffer_GLContextType;
+                break;
+#endif // SK_COMMAND_BUFFER
+#if SK_MESA
+            case kMesa_DeviceType:
+                glContextType = GrContextFactory::kMESA_GLContextType;
+                break;
+#endif // SK_MESA
+        }
+        return glContextType;
+    }
+#endif // SK_SUPPORT_GPU
+
 private:
     SkISize                fViewport;
     SkScalar               fScaleFactor;
 #if SK_SUPPORT_GPU
     GrContextFactory       fGrContextFactory;
     GrContext*             fGrContext;
     int                    fSampleCount;
     bool                   fUseDFText;
 #endif
 
@@ skipping 221 matching lines @@
 
 #if SK_SUPPORT_GPU
 extern PictureRenderer* CreateGatherPixelRefsRenderer(const GrContextOptions& opts);
 #else
 extern PictureRenderer* CreateGatherPixelRefsRenderer();
 #endif
 
 }
 
 #endif  // PictureRenderer_DEFINED