Retract SkDevice a bit more

tests/ReadWriteAlphaTest.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 "Test.h"
 
 // This test is specific to the GPU backend.
 #if SK_SUPPORT_GPU
 
 #include "GrContext.h"
-#include "SkGpuDevice.h"
+#include "SkCanvas.h"
+#include "SkSurface.h"
 
 // This was made indivisible by 4 to ensure we test setting GL_PACK_ALIGNMENT properly.
 static const int X_SIZE = 13;
 static const int Y_SIZE = 13;
 
 static void validate_alpha_data(skiatest::Reporter* reporter, int w, int h, const uint8_t* actual,
                                 size_t actualRowBytes, const uint8_t* expected, SkString extraMsg) {
     for (int y = 0; y < h; ++y) {
         for (int x = 0; x < w; ++x) {
             uint8_t a = actual[y * actualRowBytes + x];
@@ skipping 60 matching lines @@
             REPORTER_ASSERT_MESSAGE(reporter, result, "Initial A8 readPixels failed");
 
             // make sure the original & read back versions match
             SkString msg;
             msg.printf("rt:%d, rb:%d A8", rt, SkToU32(rowBytes));
             validate_alpha_data(reporter, X_SIZE, Y_SIZE, readback.get(), nonZeroRowBytes,
                                 alphaData, msg);
 
             // Now try writing on the single channel texture (if we could create as a RT).
             if (texture->asRenderTarget()) {
-                SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
-                SkAutoTUnref<SkBaseDevice> device(SkGpuDevice::Create(
-                    texture->asRenderTarget(), &props, SkGpuDevice::kUninit_InitContents));
-                SkCanvas canvas(device);
+                sk_sp<SkSurface> surf(SkSurface::MakeRenderTargetDirect(texture->asRenderTarget()));
+                SkCanvas* canvas = surf->getCanvas();
 
                 SkPaint paint;
 
                 const SkRect rect = SkRect::MakeLTRB(-10, -10, X_SIZE + 10, Y_SIZE + 10);
 
                 paint.setColor(SK_ColorWHITE);
 
-                canvas.drawRect(rect, paint);
+                canvas->drawRect(rect, paint);
 
                 memset(readback.get(), kClearValue, nonZeroRowBytes * Y_SIZE);
                 result = texture->readPixels(0, 0, desc.fWidth, desc.fHeight, 
                                              desc.fConfig, readback.get(), rowBytes);
                 REPORTER_ASSERT_MESSAGE(reporter, result, "A8 readPixels after clear failed");
 
                 match = true;
                 for (int y = 0; y < Y_SIZE && match; ++y) {
                     for (int x = 0; x < X_SIZE && match; ++x) {
                         uint8_t rbValue = readback.get()[y * nonZeroRowBytes + x];
@@ skipping 66 matching lines @@
                 SkString msg;
                 msg.printf("rt:%d, rb:%d 8888", rt, SkToU32(rowBytes));
                 validate_alpha_data(reporter, X_SIZE, Y_SIZE, readback.get(), nonZeroRowBytes,
                                     alphaData, msg);
             }
         }
     }
 }
 
 #endif