Fix alpha textures in NV ES3 contexts on Windows.

Make unit tests iterate over all the rendering GL context types rather than using kNative.

Fix the extension printing when gStartupSpew is set.

R=jvanverth@google.com

Author: bsalomon@google.com

Review URL: https://codereview.chromium.org/398183002

src/gpu/gl/GrGLContext.h

@@ -65,6 +65,8 @@ public:
         return fInterface->hasExtension(ext);
     }
 
+    const GrGLExtensions& extensions() const { return fInterface->fExtensions; }
+
     /**
      * Reset the information
      */

src/gpu/gl/GrGLUtil.cpp

@@ -219,6 +219,9 @@ GrGLVendor GrGLGetVendorFromString(const char* vendorString) {
         if (0 == strcmp(vendorString, "Qualcomm")) {
             return kQualcomm_GrGLVendor;
         }
+        if (0 == strcmp(vendorString, "NVIDIA Corporation")) {
+                return kNVIDIA_GrGLVendor;
+        }
     }
     return kOther_GrGLVendor;
 }

src/gpu/gl/GrGLUtil.h

@@ -34,6 +34,7 @@ enum GrGLVendor {
     kImagination_GrGLVendor,
     kIntel_GrGLVendor,
     kQualcomm_GrGLVendor,
+    kNVIDIA_GrGLVendor,
 
     kOther_GrGLVendor
 };

src/gpu/gl/GrGpuGL.cpp

@@ -137,9 +137,7 @@ GrGpuGL::GrGpuGL(const GrGLContext& ctx, GrContext* context)
         GrPrintf("------ RENDERER %s\n", renderer);
         GrPrintf("------ VERSION %s\n",  version);
         GrPrintf("------ EXTENSIONS\n");
-#if 0  // TODO: Reenable this after GrGLInterface's extensions can be accessed safely.
         ctx.extensions().print();
-#endif
         GrPrintf("\n");
         GrPrintf(this->glCaps().dump().c_str());
     }
@@ -574,13 +572,21 @@ bool GrGpuGL::uploadTexData(const GrGLTexture::Desc& desc,
     }
 
     GrGLenum internalFormat;
-    GrGLenum externalFormat;
+    GrGLenum externalFormat = 0x0; // suprress warning
-    GrGLenum externalType;
+    GrGLenum externalType = 0x0;// suprress warning
+
     // glTexStorage requires sized internal formats on both desktop and ES. ES2 requires an unsized
     // format for glTexImage, unlike ES3 and desktop. However, we allow the driver to decide the
     // size of the internal format whenever possible and so only use a sized internal format when
     // using texture storage.
-    if (!this->configToGLFormats(dataConfig, useTexStorage, &internalFormat,
+    bool useSizedFormat = useTexStorage;
+    // At least some versions of the desktop ES3 drivers for NVIDIA won't accept GL_RED in
+    // glTexImage2D for the internal format but will accept GL_R8.
+    if (!useSizedFormat && kNVIDIA_GrGLVendor == this->glContext().vendor() &&
+        kGLES_GrGLStandard == this->glStandard() && this->glVersion() >= GR_GL_VER(3, 0)) {
+        useSizedFormat = true;
+    }
+    if (!this->configToGLFormats(dataConfig, useSizedFormat, &internalFormat,
                                  &externalFormat, &externalType)) {
         return false;
     }

tests/DeferredCanvasTest.cpp

@@ -681,23 +681,37 @@ static PixelPtr get_surface_ptr(SkSurface* surface, bool useGpu) {
 
 static void TestDeferredCanvasSurface(skiatest::Reporter* reporter, GrContextFactory* factory) {
     SkImageInfo imageSpec = SkImageInfo::MakeN32Premul(10, 10);
-    SkSurface* surface;
     bool useGpu = NULL != factory;
+    int cnt;
 #if SK_SUPPORT_GPU
     if (useGpu) {
-        GrContext* context = factory->get(GrContextFactory::kNative_GLContextType);
+        cnt = GrContextFactory::kGLContextTypeCnt;
+    } else {
+        cnt = 1;
+    }
+#else
+    SkASSERT(!useGpu);
+    cnt = 1;
+#endif
+    for (int i = 0; i < cnt; ++i) {
+        SkSurface* surface;
+#if SK_SUPPORT_GPU
+        if (useGpu) {
+            GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
+            if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
+                continue;
+            }
+            GrContext* context = factory->get(glCtxType);
             if (NULL == context) {
                 return;
             }
 
             surface = SkSurface::NewRenderTarget(context, imageSpec);
-    } else {
+        } else
+#endif
+        {
            surface = SkSurface::NewRaster(imageSpec);
         }
-#else
-    SkASSERT(!useGpu);
-    surface = SkSurface::NewRaster(imageSpec);
-#endif
         SkASSERT(NULL != surface);
         SkAutoTUnref<SkSurface> aur(surface);
         SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface));
@@ -744,29 +758,44 @@ static void TestDeferredCanvasSurface(skiatest::Reporter* reporter, GrContextFac
         PixelPtr pixels5 = get_surface_ptr(surface, useGpu);
         REPORTER_ASSERT(reporter, pixels4 == pixels5);
     }
+}
 
 static void TestDeferredCanvasSetSurface(skiatest::Reporter* reporter, GrContextFactory* factory) {
     SkImageInfo imageSpec = SkImageInfo::MakeN32Premul(10, 10);
     SkSurface* surface;
     SkSurface* alternateSurface;
     bool useGpu = NULL != factory;
+    int cnt;
 #if SK_SUPPORT_GPU
     if (useGpu) {
-        GrContext* context = factory->get(GrContextFactory::kNative_GLContextType);
+        cnt = GrContextFactory::kGLContextTypeCnt;
-        if (NULL == context) {
-            return;
-        }
-        surface = SkSurface::NewRenderTarget(context, imageSpec);
-        alternateSurface = SkSurface::NewRenderTarget(context, imageSpec);
     } else {
-        surface = SkSurface::NewRaster(imageSpec);
+        cnt = 1;
-        alternateSurface = SkSurface::NewRaster(imageSpec);
     }
 #else
     SkASSERT(!useGpu);
+    cnt = 1;
+#endif
+
+    for (int i = 0; i < cnt; ++i) {
+#if SK_SUPPORT_GPU
+        if (useGpu) {
+            GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
+            if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
+                continue;
+            }
+            GrContext* context = factory->get(glCtxType);
+            if (NULL == context) {
+                continue;
+            }
+            surface = SkSurface::NewRenderTarget(context, imageSpec);
+            alternateSurface = SkSurface::NewRenderTarget(context, imageSpec);
+        } else 
+#endif
+        {
             surface = SkSurface::NewRaster(imageSpec);
             alternateSurface = SkSurface::NewRaster(imageSpec);
-#endif
+        }
         SkASSERT(NULL != surface);
         SkASSERT(NULL != alternateSurface);
         SkAutoTUnref<SkSurface> aur1(surface);
@@ -787,6 +816,7 @@ static void TestDeferredCanvasSetSurface(skiatest::Reporter* reporter, GrContext
         REPORTER_ASSERT(reporter, get_surface_ptr(surface, useGpu) == pixels1);
         REPORTER_ASSERT(reporter, get_surface_ptr(alternateSurface, useGpu) != pixels2);
     }
+}
 
 static void TestDeferredCanvasCreateCompatibleDevice(skiatest::Reporter* reporter) {
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));

tests/GLProgramsTest.cpp

@@ -147,6 +147,10 @@ bool GrGpuGL::programUnitTest(int maxStages) {
     dummyDesc.fHeight = 22;
     SkAutoTUnref<GrTexture> dummyTexture2(this->createTexture(dummyDesc, NULL, 0));
 
+    if (!dummyTexture1 || ! dummyTexture2) {
+        return false;
+    }
+
     static const int NUM_TESTS = 512;
 
     SkRandom random;

tests/GpuLayerCacheTest.cpp

@@ -49,10 +49,17 @@ static void create_layers(skiatest::Reporter* reporter,
 // locking & unlocking textures).
 // TODO: need to add checks on VRAM usage!
 DEF_GPUTEST(GpuLayerCache, reporter, factory) {
+    for (int i= 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
+        GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
+
+        if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
+            continue;
+        }
+
+        GrContext* context = factory->get(glCtxType);
 
-    GrContext* context = factory->get(GrContextFactory::kNative_GLContextType);
         if (NULL == context) {
-        return;
+            continue;
         }
 
         SkPictureRecorder recorder;
@@ -136,5 +143,6 @@ DEF_GPUTEST(GpuLayerCache, reporter, factory) {
         // TODO: add VRAM/resource cache check here
 #endif
     }
+}
 
 #endif

tests/GrContextFactoryTest.cpp

@@ -16,17 +16,17 @@ DEF_GPUTEST(GrContextFactory, reporter, factory) {
 
     // Before we ask for a context, we expect the GL context to not be there.
     REPORTER_ASSERT(reporter,
-                    NULL == factory->getGLContext(GrContextFactory::kNative_GLContextType));
+                    NULL == factory->getGLContext(GrContextFactory::kNull_GLContextType));
 
     // After we ask for a context, we expect that the GL context to be there.
-    factory->get(GrContextFactory::kNative_GLContextType);
+    factory->get(GrContextFactory::kNull_GLContextType);
     REPORTER_ASSERT(reporter,
-                    factory->getGLContext(GrContextFactory::kNative_GLContextType) != NULL);
+                    factory->getGLContext(GrContextFactory::kNull_GLContextType) != NULL);
 
     // If we did not ask for a context with the particular GL context, we would
     // expect the particular GL context to not be there.
     REPORTER_ASSERT(reporter,
-                    NULL == factory->getGLContext(GrContextFactory::kNull_GLContextType));
+                    NULL == factory->getGLContext(GrContextFactory::kDebug_GLContextType));
 }
 
 #endif

tests/ImageNewShaderTest.cpp

@@ -92,7 +92,18 @@ void rasterToGpu(skiatest::Reporter* reporter, GrContext* context) {
 }
 
 DEF_GPUTEST(ImageNewShader_GPU, reporter, factory) {
-    GrContext* context = factory->get(GrContextFactory::kNative_GLContextType);
+    for (int i= 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
+        GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
+
+        if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
+            continue;
+        }
+
+        GrContext* context = factory->get(glCtxType);
+
+        if (NULL == context) {
+            continue;
+        }
 
         // GPU -> GPU
         gpuToGpu(reporter, context);
@@ -104,5 +115,6 @@ DEF_GPUTEST(ImageNewShader_GPU, reporter, factory) {
         // RASTER -> GPU
         rasterToGpu(reporter, context);
     }
+}
 
 #endif

tests/PictureTest.cpp

@@ -780,8 +780,18 @@ static void test_gpu_veto(skiatest::Reporter* reporter) {
 
 static void test_gpu_picture_optimization(skiatest::Reporter* reporter,
                                           GrContextFactory* factory) {
+    for (int i= 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
+        GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
 
-    GrContext* context = factory->get(GrContextFactory::kNative_GLContextType);
+        if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
+            continue;
+        }
+
+        GrContext* context = factory->get(glCtxType);
+
+        if (NULL == context) {
+            continue;
+        }
 
         static const int kWidth = 100;
         static const int kHeight = 100;
@@ -905,6 +915,7 @@ static void test_gpu_picture_optimization(skiatest::Reporter* reporter,
     #endif
         }
     }
+}
 
 #endif
 

tests/SurfaceTest.cpp

@@ -170,11 +170,26 @@ static void test_canvaspeek(skiatest::Reporter* reporter,
     const SkColor color = SK_ColorRED;
     const SkPMColor pmcolor = SkPreMultiplyColor(color);
 
-    GrContext* context = NULL;
+    int cnt;
 #if SK_SUPPORT_GPU
-    context = factory->get(GrContextFactory::kNative_GLContextType);
+    cnt = GrContextFactory::kGLContextTypeCnt;
+#else
+    cnt = 1;
 #endif
 
+    for (int i= 0; i < cnt; ++i) {
+        GrContext* context = NULL;
+#if SK_SUPPORT_GPU
+        GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
+        if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
+            continue;
+        }
+        context = factory->get(glCtxType);
+
+        if (NULL == context) {
+            continue;
+        }
+#endif
         for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
             SkImageInfo info, requestInfo;
             size_t rowBytes;
@@ -204,6 +219,7 @@ static void test_canvaspeek(skiatest::Reporter* reporter,
             }
         }
     }
+}
 
 static void TestSurfaceCopyOnWrite(skiatest::Reporter* reporter, SurfaceType surfaceType,
                                    GrContext* context) {
@@ -429,7 +445,12 @@ DEF_GPUTEST(Surface, reporter, factory) {
 #if SK_SUPPORT_GPU
     TestGetTexture(reporter, kRaster_SurfaceType, NULL);
     if (NULL != factory) {
-        GrContext* context = factory->get(GrContextFactory::kNative_GLContextType);
+        for (int i= 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
+            GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
+            if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
+                continue;
+            }
+            GrContext* context = factory->get(glCtxType);
             if (NULL != context) {
                 TestSurfaceInCache(reporter, kGpu_SurfaceType, context);
                 TestSurfaceInCache(reporter, kGpuScratch_SurfaceType, context);
@@ -447,5 +468,6 @@ DEF_GPUTEST(Surface, reporter, factory) {
                 TestGetTexture(reporter, kGpuScratch_SurfaceType, context);
             }
         }
+    }
 #endif
 }