Clean up test drawContext usage

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 "SkData.h"
 #include "SkDevice.h"
 #include "SkImage_Base.h"
 #include "SkPath.h"
 #include "SkRRect.h"
 #include "SkSurface.h"
 #include "SkUtils.h"
 #include "Test.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
+#include "GrDrawContext.h"
 #include "GrGpu.h"
 #endif
 
 #include <initializer_list>
 
 static void release_direct_surface_storage(void* pixels, void* context) {
     SkASSERT(pixels == context);
     sk_free(pixels);
 }
 static sk_sp<SkSurface> create_surface(SkAlphaType at = kPremul_SkAlphaType,
@@ skipping 375 matching lines @@
         auto imageBackingStore = [reporter](SkImage* image) {
             GrTexture* texture = as_IB(image)->peekTexture();
             if (!texture) {
                 ERRORF(reporter, "Not texture backed.");
                 return static_cast<intptr_t>(0);
             }
             return static_cast<intptr_t>(texture->getUniqueID());
         };
 
         auto surfaceBackingStore = [reporter](SkSurface* surface) {
-            GrRenderTarget* rt =
-                surface->getCanvas()->internal_private_accessTopLayerRenderTarget();
+            GrDrawContext* dc = surface->getCanvas()->internal_private_accessTopLayerDrawContext();
+            GrRenderTarget* rt = dc->accessRenderTarget();
             if (!rt) {
                 ERRORF(reporter, "Not render target backed.");
                 return static_cast<intptr_t>(0);
             }
             return static_cast<intptr_t>(rt->getUniqueID());
         };
 
         test_unique_image_snap(reporter, surface.get(), false, imageBackingStore,
                                surfaceBackingStore);
 
@@ skipping 426 matching lines @@
                        expectedValue, x, y);
                 return;
             }
         }
     }
 }
 
 DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SurfaceClear_Gpu, reporter, ctxInfo) {
     GrContext* context = ctxInfo.fGrContext;
     std::function<GrSurface*(SkSurface*)> grSurfaceGetters[] = {
-        [] (SkSurface* s){ return s->getCanvas()->internal_private_accessTopLayerRenderTarget(); },
+        [] (SkSurface* s){ 
+            GrDrawContext* dc = s->getCanvas()->internal_private_accessTopLayerDrawContext();
+            return dc->accessRenderTarget(); },
         [] (SkSurface* s){
             SkBaseDevice* d =
                 s->getCanvas()->getDevice_just_for_deprecated_compatibility_testing();
             return d->accessRenderTarget(); },
         [] (SkSurface* s){ sk_sp<SkImage> i(s->makeImageSnapshot());
                            return as_IB(i)->peekTexture(); },
     };
     for (auto grSurfaceGetter : grSurfaceGetters) {
         for (auto& surface_func : {&create_gpu_surface, &create_gpu_scratch_surface}) {
             auto surface = surface_func(context, kPremul_SkAlphaType, nullptr);
@@ skipping 15 matching lines @@
         desc.fHeight = kHeight;
         desc.fFlags = kRenderTarget_GrBackendTextureFlag;
         desc.fTextureHandle = textureObject;
 
         auto surface = SkSurface::MakeFromBackendTexture(context, desc, nullptr);
         test_surface_clear(reporter, surface, grSurfaceGetter, 0xABABABAB);
         context->getGpu()->deleteTestingOnlyBackendTexture(textureObject);
     }
 }
 #endif