add ability to get FBO ID to Surface

src/image/SkSurface_Gpu.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkSurface_Gpu.h"
 
 #include "SkCanvas.h"
 #include "SkGpuDevice.h"
 #include "SkImage_Base.h"
 #include "SkImage_Gpu.h"
 #include "SkImagePriv.h"
 #include "SkSurface_Base.h"
 
 #if SK_SUPPORT_GPU
 
 ///////////////////////////////////////////////////////////////////////////////
 SkSurface_Gpu::SkSurface_Gpu(SkGpuDevice* device)
     : INHERITED(device->width(), device->height(), &device->surfaceProps())
     , fDevice(SkRef(device)) {
 }
 
 SkSurface_Gpu::~SkSurface_Gpu() {
     fDevice->unref();
 }
 
-GrBackendObject SkSurface_Gpu::onGetTextureHandle(TextureHandleAccess access) {
-    GrRenderTarget* rt = fDevice->accessRenderTarget();
+static GrRenderTarget* prepare_rt_for_external_access(SkSurface_Gpu* surface,
+                                                      SkSurface::BackendHandleAccess access) {
+    GrRenderTarget* rt = surface->getDevice()->accessRenderTarget();
     switch (access) {
-        case kFlushRead_TextureHandleAccess:
+        case SkSurface::kFlushRead_BackendHandleAccess:
             break;
-        case kFlushWrite_TextureHandleAccess:
-        case kDiscardWrite_TextureHandleAccess:
+        case SkSurface::kFlushWrite_BackendHandleAccess:
+        case SkSurface::kDiscardWrite_BackendHandleAccess:
             // for now we don't special-case on Discard, but we may in the future.
-            this->notifyContentWillChange(kRetain_ContentChangeMode);
+            surface->notifyContentWillChange(SkSurface::kRetain_ContentChangeMode);
             // legacy: need to dirty the bitmap's genID in our device (curse it)
-            fDevice->fLegacyBitmap.notifyPixelsChanged();
+            surface->getDevice()->accessBitmap(false).notifyPixelsChanged();
             break;
     }
     rt->prepareForExternalIO();
-    return rt->asTexture()->getTextureHandle();
+    return rt;
+}
+
+GrBackendObject SkSurface_Gpu::onGetTextureHandle(BackendHandleAccess access) {
+    GrRenderTarget* rt = prepare_rt_for_external_access(this, access);
+    GrTexture* texture = rt->asTexture();
+    if (texture) {
+        return texture->getTextureHandle();
+    }
+    return 0;
+}
+
+bool SkSurface_Gpu::onGetRenderTargetHandle(GrBackendObject* obj, BackendHandleAccess access) {
+    GrRenderTarget* rt = prepare_rt_for_external_access(this, access);
+    *obj = rt->getRenderTargetHandle();
+    return true;
 }
 
 SkCanvas* SkSurface_Gpu::onNewCanvas() {
     SkCanvas::InitFlags flags = SkCanvas::kDefault_InitFlags;
     // When we think this works...
 //    flags |= SkCanvas::kConservativeRasterClip_InitFlag;
 
     return SkNEW_ARGS(SkCanvas, (fDevice, flags));
 }
 
@@ skipping 97 matching lines @@
     }
     SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(rt, props,
                                                          SkGpuDevice::kUninit_InitContents));
     if (!device) {
         return NULL;
     }
     return SkNEW_ARGS(SkSurface_Gpu, (device));
 }
 
 #endif