Revert[2] SkDraw and all Blitters to use pixmap instead of bitmapi

tests/SurfaceTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkData.h"
+#include "SkDevice.h"
 #include "SkImageEncoder.h"
 #include "SkRRect.h"
 #include "SkSurface.h"
 #include "SkUtils.h"
 #include "Test.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContextFactory.h"
 #else
 class GrContextFactory;
@@ skipping 323 matching lines @@
                 REPORTER_ASSERT(reporter, addr2 == addr);
                 REPORTER_ASSERT(reporter, info2 == info);
                 REPORTER_ASSERT(reporter, rb2 == rowBytes);
             } else {
                 REPORTER_ASSERT(reporter, NULL == addr2);
             }
         }
     }
 }
 
+// For compatibility with clients that still call accessBitmap(), we need to ensure that we bump
+// the bitmap's genID when we draw to it, else they won't know it has new values. When they are
+// exclusively using surface/image, and we can hide accessBitmap from device, we can remove this
+// test.
+static void test_accessPixels(skiatest::Reporter* reporter, GrContextFactory* factory) {
+    static const struct {
+        SurfaceType fType;

[robertphillips, 2015/06/09 19:02:44]

fPeekShouldSucceed doesn't seem to be used ?

+        bool        fPeekShouldSucceed;
+    } gRec[] = {
+        { kRaster_SurfaceType,          true    },
+        { kRasterDirect_SurfaceType,    true    },
+#if SK_SUPPORT_GPU
+        { kGpu_SurfaceType,             false   },
+        { kGpuScratch_SurfaceType,      false   },
+#endif
+    };
+    
+    int cnt;
+#if SK_SUPPORT_GPU
+    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 j = 0; j < SK_ARRAY_COUNT(gRec); ++j) {
+            SkImageInfo info, requestInfo;
+            
+            SkAutoTUnref<SkSurface> surface(createSurface(gRec[j].fType, context,
+                                                          &requestInfo));
+            SkCanvas* canvas = surface->getCanvas();
+            canvas->clear(0);
+
+            SkBitmap bm = canvas->getDevice_just_for_deprecated_compatibility_testing()->accessBitmap(false);
+            uint32_t genID0 = bm.getGenerationID();
+            canvas->drawColor(SK_ColorBLUE);

[robertphillips, 2015/06/09 19:06:15]

// Thus draw call causes a call to ...
?

[reed1, 2015/06/09 19:11:12]

Done.

+            uint32_t genID1 = bm.getGenerationID();
+            REPORTER_ASSERT(reporter, genID0 != genID1);
+        }
+    }
+}
+
 static void TestSurfaceCopyOnWrite(skiatest::Reporter* reporter, SurfaceType surfaceType,
                                    GrContext* context) {
     // Verify that the right canvas commands trigger a copy on write
     SkSurface* surface = createSurface(surfaceType, context);
     SkAutoTUnref<SkSurface> aur_surface(surface);
     SkCanvas* canvas = surface->getCanvas();
 
     const SkRect testRect =
         SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0),
                          SkIntToScalar(4), SkIntToScalar(5));
@@ skipping 217 matching lines @@
     TestSurfaceWritableAfterSnapshotRelease(reporter, kRaster_SurfaceType, NULL);
     TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, NULL, SkSurface::kDiscard_ContentChangeMode);
     TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, NULL, SkSurface::kRetain_ContentChangeMode);
 
     test_empty_image(reporter);
     test_empty_surface(reporter, NULL);
 
     test_imagepeek(reporter, factory);
     test_canvaspeek(reporter, factory);
 
+    test_accessPixels(reporter, factory);
+
 #if SK_SUPPORT_GPU
     TestGetTexture(reporter, kRaster_SurfaceType, NULL);
     if (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);
             if (context) {
@@ skipping 76 matching lines @@
     // Now lets jam new colors into our "external" texture, and see if the images notice
     const SkPMColor expected1 = SkPreMultiplyColor(SK_ColorBLUE);
     sk_memset32(storage, expected1, w * h);
     tex->writePixels(0, 0, w, h, kSkia8888_GrPixelConfig, storage, GrContext::kFlushWrites_PixelOp);
 
     // We expect the ref'd image to see the new color, but cpy'd one should still see the old color
     test_image_color(reporter, refImg, expected1);
     test_image_color(reporter, cpyImg, expected0);
 }
 #endif