add ability to get FBO ID to Surface

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"
@@ skipping 212 matching lines @@
     }
 };
 
 // May we (soon) eliminate the need to keep testing this, by hiding the bloody device!
 #include "SkDevice.h"
 static uint32_t get_legacy_gen_id(SkSurface* surf) {
     SkBaseDevice* device = surf->getCanvas()->getDevice_just_for_deprecated_compatibility_testing();
     return device->accessBitmap(false).getGenerationID();
 }
 
-static void test_texture_handle(skiatest::Reporter* reporter, SkSurface* surf) {
+template <class F>
+static void test_backend_handle(skiatest::Reporter* reporter, SkSurface* surf, F f) {
     SkAutoTUnref<SkImage> image0(surf->newImageSnapshot());
     const uint32_t genID0 = get_legacy_gen_id(surf);
-    GrBackendObject obj = surf->getTextureHandle(SkSurface::kFlushRead_TextureHandleAccess);
+    GrBackendObject obj = f(surf, SkSurface::kFlushRead_BackendHandleAccess);
     REPORTER_ASSERT(reporter, obj != 0);
     SkAutoTUnref<SkImage> image1(surf->newImageSnapshot());
     const uint32_t genID1 = get_legacy_gen_id(surf);
     // just read access should not affect the snapshot
     REPORTER_ASSERT(reporter, image0->uniqueID() == image1->uniqueID());
     REPORTER_ASSERT(reporter, genID0 == genID1);
 
-    obj = surf->getTextureHandle(SkSurface::kFlushWrite_TextureHandleAccess);
+    obj = f(surf, SkSurface::kFlushWrite_BackendHandleAccess);
     REPORTER_ASSERT(reporter, obj != 0);
     SkAutoTUnref<SkImage> image2(surf->newImageSnapshot());
     const uint32_t genID2 = get_legacy_gen_id(surf);
     // expect a new image, since we claimed we would write
     REPORTER_ASSERT(reporter, image0->uniqueID() != image2->uniqueID());
     REPORTER_ASSERT(reporter, genID0 != genID2);
 
-    obj = surf->getTextureHandle(SkSurface::kDiscardWrite_TextureHandleAccess);
+    obj = f(surf, SkSurface::kDiscardWrite_BackendHandleAccess);
     REPORTER_ASSERT(reporter, obj != 0);
     SkAutoTUnref<SkImage> image3(surf->newImageSnapshot());
     const uint32_t genID3 = get_legacy_gen_id(surf);
     // expect a new(er) image, since we claimed we would write
     REPORTER_ASSERT(reporter, image0->uniqueID() != image3->uniqueID());
     REPORTER_ASSERT(reporter, image2->uniqueID() != image3->uniqueID());
     REPORTER_ASSERT(reporter, genID0 != genID3);
     REPORTER_ASSERT(reporter, genID2 != genID3);
 }
 
@@ skipping 16 matching lines @@
             return SkImage::NewRasterData(info, data, rowBytes);
         case kRasterProc_ImageType:
             SkASSERT(releaseContext);
             releaseContext->fData = SkRef(data.get());
             return SkImage::NewFromRaster(info, addr, rowBytes,
                                           ReleaseDataContext::Release, releaseContext);
         case kGpu_ImageType: {
             SkAutoTUnref<SkSurface> surf(
                 SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0));
             surf->getCanvas()->clear(color);
-            // test our backing texture while were here...
-            test_texture_handle(reporter, surf);
+            // test our backing texture / rendertarget while were here...
+            test_backend_handle(reporter, surf,
+                [](SkSurface* surf, SkSurface::BackendHandleAccess access) -> GrBackendObject {
+                    return surf->getTextureHandle(access); });
+            test_backend_handle(reporter, surf,
+                [](SkSurface* surf, SkSurface::BackendHandleAccess access) -> GrBackendObject {
+                    GrBackendObject obj;
+                    bool result = surf->getRenderTargetHandle(&obj, access);
+                    SkASSERT(result);
+                    return obj; });
             // redraw so our returned image looks as expected.
             surf->getCanvas()->clear(color);
             return surf->newImageSnapshot();
         }
         case kCodec_ImageType: {
             SkBitmap bitmap;
             bitmap.installPixels(info, addr, rowBytes);
             SkAutoTUnref<SkData> src(
                  SkImageEncoder::EncodeData(bitmap, SkImageEncoder::kPNG_Type, 100));
             return SkImage::NewFromEncoded(src);
@@ skipping 632 matching lines @@
     // 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);
 
     // Now exercise the release proc
     REPORTER_ASSERT(reporter, !releaseCtx.fIsReleased);
     refImg.reset(NULL); // force a release of the image
     REPORTER_ASSERT(reporter, releaseCtx.fIsReleased);
 }
 #endif