Start using RenderTargetProxy (omnibus)

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 <functional>
 #include "SkCanvas.h"
 #include "SkColorSpace_Base.h"
@@ skipping 542 matching lines @@
         GrTexture* texture = as_IB(image)->peekTexture();
         REPORTER_ASSERT(reporter, texture);
         REPORTER_ASSERT(reporter, 0 != texture->getTextureHandle());
         surface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode);
         REPORTER_ASSERT(reporter, as_IB(image)->peekTexture() == texture);
     }
 }
 #endif
 
 #if SK_SUPPORT_GPU
+#include "GrRenderTargetContextPriv.h"
 #include "GrGpuResourcePriv.h"
 #include "SkGpuDevice.h"
 #include "SkImage_Gpu.h"
 #include "SkSurface_Gpu.h"
 
 static SkBudgeted is_budgeted(const sk_sp<SkSurface>& surf) {
     SkSurface_Gpu* gsurf = (SkSurface_Gpu*)surf.get();
     return gsurf->getDevice()->accessRenderTargetContext()
         ->accessRenderTarget()->resourcePriv().isBudgeted();
 }
@@ skipping 210 matching lines @@
                 }
                 ERRORF(reporter,
                        "%s but read 0x%08x (instead of 0x%08x) at %x,%d", msg.c_str(), pixel,
                        expectedValue, x, y);
                 return;
             }
         }
     }
 }
 
+#if 0
 DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SurfaceClear_Gpu, reporter, ctxInfo) {
     GrContext* context = ctxInfo.grContext();
 
     std::function<GrSurface*(SkSurface*)> grSurfaceGetters[] = {
         [] (SkSurface* s){
             GrRenderTargetContext* rtc =
                 s->getCanvas()->internal_private_accessTopLayerRenderTargetContext();
             return rtc->accessRenderTarget(); },
         [] (SkSurface* s){ sk_sp<SkImage> i(s->makeImageSnapshot());
                            return as_IB(i)->peekTexture(); }
@@ skipping 10 matching lines @@
         for (auto& surfaceFunc : {&create_gpu_surface_backend_texture,
                                   &create_gpu_surface_backend_texture_as_render_target}) {
             GrBackendObject textureObject;
             auto surface = surfaceFunc(context, 0, kOrigColor, &textureObject);
             test_surface_clear(reporter, surface, grSurfaceGetter, kOrigColor);
             surface.reset();
             context->getGpu()->deleteTestingOnlyBackendTexture(textureObject);
         }
     }
 }
+#endif
 
 static void test_surface_draw_partially(
     skiatest::Reporter* reporter, sk_sp<SkSurface> surface, uint32_t origColor) {
     const int kW = surface->width();
     const int kH = surface->height();
     SkPaint paint;
     const SkColor kRectColor = ~origColor | 0xFF000000;
     paint.setColor(kRectColor);
     surface->getCanvas()->drawRect(SkRect::MakeWH(SkIntToScalar(kW), SkIntToScalar(kH)/2),
                                    paint);
@@ skipping 45 matching lines @@
         GrBackendObject textureObject;
         auto surface = surfaceFunc(ctxInfo.grContext(), 0, kOrigColor, &textureObject);
         if (surface) {
             test_surface_draw_partially(reporter, surface, kOrigColor);
             surface.reset();
             gpu->deleteTestingOnlyBackendTexture(textureObject);
         }
     }
 }
 
-
+#if 0
 DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SurfaceAttachStencil_Gpu, reporter, ctxInfo) {
     GrGpu* gpu = ctxInfo.grContext()->getGpu();
     if (!gpu) {
         return;
     }
     static const uint32_t kOrigColor = 0xFFAABBCC;
 
     for (auto& surfaceFunc : {&create_gpu_surface_backend_texture,
                               &create_gpu_surface_backend_texture_as_render_target}) {
         for (int sampleCnt : {0, 4, 8}) {
@@ skipping 115 matching lines @@
     };
 
     test_surface_creation_and_snapshot_with_color_space(reporter, "wrapped", f16Support,
                                                         wrappedSurfaceMaker);
 
     for (auto textureHandle : textureHandles) {
         context->getGpu()->deleteTestingOnlyBackendTexture(textureHandle);
     }
 }
 #endif
+
+#endif