Revert of - Add astcbitmap to gm slides

tests/TextureCompressionTest.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkData.h"
 #include "SkEndian.h"
 #include "SkImageInfo.h"
 #include "SkTextureCompressor.h"
 #include "Test.h"
 
-// TODO: Create separate tests for RGB and RGBA data once
-// ASTC and ETC1 decompression is implemented.
-
-static bool decompresses_a8(SkTextureCompressor::Format fmt) {
-    switch (fmt) {
-        case SkTextureCompressor::kLATC_Format:
-        case SkTextureCompressor::kR11_EAC_Format:
-            return true;
-
-        default:
-            return false;
-    }
-}
-
-static bool compresses_a8(SkTextureCompressor::Format fmt) {
-    switch (fmt) {
-        case SkTextureCompressor::kLATC_Format:
-        case SkTextureCompressor::kR11_EAC_Format:
-        case SkTextureCompressor::kASTC_12x12_Format:
-            return true;
-
-        default:
-            return false;
-    }
-}
-
 /**
  * Make sure that we properly fail when we don't have multiple of four image dimensions.
  */
 DEF_TEST(CompressAlphaFailDimensions, reporter) {
     SkBitmap bitmap;
     static const int kWidth = 17;
     static const int kHeight = 17;
     SkImageInfo info = SkImageInfo::MakeA8(kWidth, kHeight);
 
     // R11_EAC and LATC are both dimensions of 4, so we need to make sure that we
     // are violating those assumptions. And if we are, then we're also violating the
     // assumptions of ASTC, which is 12x12 since any number not divisible by 4 is
     // also not divisible by 12. Our dimensions are prime, so any block dimension
     // larger than 1 should fail.
     REPORTER_ASSERT(reporter, kWidth % 4 != 0);
     REPORTER_ASSERT(reporter, kHeight % 4 != 0);
 
     bool setInfoSuccess = bitmap.setInfo(info);
     REPORTER_ASSERT(reporter, setInfoSuccess);
 
     bool allocPixelsSuccess = bitmap.allocPixels(info);
     REPORTER_ASSERT(reporter, allocPixelsSuccess);
     bitmap.unlockPixels();
     
     for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) {
         const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i);
-        if (!compresses_a8(fmt)) {
-            continue;
-        }
         SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(bitmap, fmt));
         REPORTER_ASSERT(reporter, NULL == data);
     }
 }
 
 /**
  * Make sure that we properly fail when we don't have the correct bitmap type.
  * compressed textures can (currently) only be created from A8 bitmaps.
  */
 DEF_TEST(CompressAlphaFailColorType, reporter) {
@@ skipping 11 matching lines @@
 
     bool setInfoSuccess = bitmap.setInfo(info);
     REPORTER_ASSERT(reporter, setInfoSuccess);
 
     bool allocPixelsSuccess = bitmap.allocPixels(info);
     REPORTER_ASSERT(reporter, allocPixelsSuccess);
     bitmap.unlockPixels();
 
     for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) {
         const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i);
-        if (!compresses_a8(fmt)) {
-            continue;
-        }
         SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(bitmap, fmt));
         REPORTER_ASSERT(reporter, NULL == data);
     }
 }
 
 /**
  * Make sure that if you compress a texture with alternating black/white pixels, and
  * then decompress it, you get what you started with.
  */
 DEF_TEST(CompressCheckerboard, reporter) {
@@ skipping 45 matching lines @@
     REPORTER_ASSERT(reporter, NULL != decompBuffer);
     if (NULL == decompBuffer) {
         return;
     }
 
     for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) {
         const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i);
 
         // Ignore formats for RGBA data, since the decompressed buffer
         // won't match the size and contents of the original.
-        if (!decompresses_a8(fmt) || !compresses_a8(fmt)) {
+        // TODO: Create separate tests for RGB and RGBA data once
+        // ASTC and ETC1 decompression is implemented.
+        if (SkTextureCompressor::kASTC_12x12_Format == fmt ||
+            SkTextureCompressor::kETC1_Format == fmt) {
             continue;
         }
 
         SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(bitmap, fmt));
         REPORTER_ASSERT(reporter, NULL != data);
         if (NULL == data) {
             continue;
         }
 
         bool decompResult =
@@ skipping 87 matching lines @@
                 (kIndex << 28) | (kIndex << 31) | (kIndex << 34) | (kIndex << 37) |
                 (kIndex << 40) | (kIndex << 43) | (kIndex << 46) | (kIndex << 49) |
                 (kIndex << 52) | (kIndex << 55) | (kIndex << 58) | (kIndex << 61));
 
         const uint64_t* blockPtr = reinterpret_cast<const uint64_t*>(latcData->data());
         for (size_t i = 0; i < (kSizeToBe/8); ++i) {
             REPORTER_ASSERT(reporter, blockPtr[i] == kConstColorEncoding);
         }
     }
 }