Use SkEncodedInfo in place of SkSwizzler::SrcConfig

include/codec/SkEncodedInfo.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkEncodedInfo_DEFINED
 #define SkEncodedInfo_DEFINED
 
@@ skipping 85 matching lines @@
                 SkASSERT(kOpaque_Alpha == alpha);
                 SkASSERT(bitsPerComponent >= 8);
                 break;
             case kYUV_Color:
             case kInvertedCMYK_Color:
             case kYCCK_Color:
                 SkASSERT(kOpaque_Alpha == alpha);
                 SkASSERT(8 == bitsPerComponent);
                 break;
             case kRGBA_Color:
-                SkASSERT(kOpaque_Alpha != alpha);
                 SkASSERT(bitsPerComponent >= 8);
                 break;
             case kBGRA_Color:
             case kYUVA_Color:
-                SkASSERT(kOpaque_Alpha != alpha);
                 SkASSERT(8 == bitsPerComponent);
                 break;
             default:
                 SkASSERT(false);
                 break;
         }
 
         return SkEncodedInfo(color, alpha, bitsPerComponent);
     }
 
@@ skipping 27 matching lines @@
             case kBGRA_Color:
             case kYUVA_Color:
                 SkASSERT(kOpaque_Alpha != fAlpha);
                 return SkImageInfo::Make(width, height, kN32_SkColorType, kUnpremul_SkAlphaType);
             default:
                 SkASSERT(false);
                 return SkImageInfo::MakeUnknown();
         }
     }
 
+    Color color() const { return fColor; }
+    Alpha alpha() const { return fAlpha; }
+    uint8_t bitsPerComponent() const { return fBitsPerComponent; }
+
+    SkEncodedInfo makeColor(Color color) const {
+        return SkEncodedInfo::Make(color, fAlpha, fBitsPerComponent);
+    }
+
+    uint8_t bitsPerPixel() const {

[reed1, 2016/04/21 14:15:00]

Why do we offer bitsPer and bytesPer, when bits is always a multiple of 8?

[msarett, 2016/04/21 14:36:44]

It's not always a multiple.

Though crashing through SkASSERT when clients ask for bytesPerPixel is a strange
behavior.

I've rewritten to only provide bitsPerPixel() and fixed the clients.

+        switch (fColor) {
+            case kGray_Color:
+                return fBitsPerComponent;
+            case kGrayAlpha_Color:
+                return 2 * fBitsPerComponent;
+            case kPalette_Color:
+                return fBitsPerComponent;
+            case kRGB_Color:
+            case kBGR_Color:
+            case kYUV_Color:
+                return 3 * fBitsPerComponent;
+            case kRGBA_Color:
+            case kBGRA_Color:
+            case kBGRX_Color:
+            case kYUVA_Color:
+            case kInvertedCMYK_Color:
+            case kYCCK_Color:
+                return 4 * fBitsPerComponent;
+            default:
+                SkASSERT(false);
+                return 0;
+        }
+    }
+
+    uint8_t bytesPerPixel() const {
+        SkASSERT(SkIsAlign8(this->bitsPerPixel()));
+        return this->bitsPerPixel() >> 3;
+    }
+
     SkEncodedInfo()
         : fColor(kUnknown_Color)
         , fAlpha(kUnknown_Alpha)
         , fBitsPerComponent(0)
     {}
 
 private:
 
     SkEncodedInfo(Color color, Alpha alpha, uint8_t bitsPerComponent)
         : fColor(color)
         , fAlpha(alpha)
         , fBitsPerComponent(bitsPerComponent)
     {}
 
     Color   fColor;
     Alpha   fAlpha;
     uint8_t fBitsPerComponent;
 };
 
 #endif