Refugee from Dead Machine 4: MDB Monster

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 && !defined(SK_BUILD_FOR_ANDROID)
 
 #include "GrContextFactory.h"
 #include "SkGpuDevice.h"
 
 static const int X_SIZE = 12;
 static const int Y_SIZE = 12;
 
+#if 0
 DEF_GPUTEST(ReadWriteAlpha, reporter, factory) {
     for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
         GrContextFactory::GLContextType glType = static_cast<GrContextFactory::GLContextType>(type);
         if (!GrContextFactory::IsRenderingGLContext(glType)) {
             continue;
         }
         GrContext* context = factory->get(glType);
         if (nullptr == context) {
             continue;
         }
@@ skipping 10 matching lines @@
         desc.fConfig    = kAlpha_8_GrPixelConfig;
         desc.fWidth     = X_SIZE;
         desc.fHeight    = Y_SIZE;
 
         // We are initializing the texture with zeros here
         GrTexture* texture = context->textureProvider()->createTexture(desc, false, textureData, 0);
         if (!texture) {
             return;
         }
 
+        // TODO: this should be okay
+        texture->setFromRawPixels(false);
+
         SkAutoTUnref<GrTexture> au(texture);
 
+        SkAutoTUnref<GrDrawContext> dc(context->drawContext(texture->asRenderTarget()));
+        if (!dc) {
+            return;
+        }
+
         // create a distinctive texture
         for (int y = 0; y < Y_SIZE; ++y) {
             for (int x = 0; x < X_SIZE; ++x) {
                 textureData[x][y] = x*Y_SIZE+y;
             }
         }
 
         // upload the texture
-        texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
+        texture->writePixels(dc, 0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
                              textureData, 0);
 
         unsigned char readback[X_SIZE][Y_SIZE];
 
         // clear readback to something non-zero so we can detect readback failures
         memset(readback, 0x1, X_SIZE * Y_SIZE);
 
         // read the texture back
         texture->readPixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
                             readback, 0);
 
         // make sure the original & read back versions match
         bool match = true;
 
         for (int y = 0; y < Y_SIZE; ++y) {
             for (int x = 0; x < X_SIZE; ++x) {
                 if (textureData[x][y] != readback[x][y]) {
                     match = false;
                 }
             }
         }
 
+        // What on earth is this doing?
+        texture->setFromRawPixels(false);
+        texture->setDC1(NULL);
+        texture->setDT(NULL);
+
         REPORTER_ASSERT(reporter, match);
 
         // Now try writing on the single channel texture
         SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
         SkAutoTUnref<SkBaseDevice> device(SkGpuDevice::Create(texture->asRenderTarget(), &props,
                                                               SkGpuDevice::kUninit_InitContents));
         SkCanvas canvas(device);
 
         SkPaint paint;
 
@@ skipping 12 matching lines @@
             for (int x = 0; x < X_SIZE; ++x) {
                 if (0xFF != readback[x][y]) {
                     match = false;
                 }
             }
         }
 
         REPORTER_ASSERT(reporter, match);
     }
 }
+#endif
 
 #endif