Remove redundant tests to make DM a little faster

dm/DM.cpp

Index: dm/DM.cpp
diff --git a/dm/DM.cpp b/dm/DM.cpp
index e77c99c3042740aef3c304024ce0b1c18b8ee14c..9878ae8d21f6ae7181ba3fa2fb7581faaed19ec2 100644
--- a/dm/DM.cpp
+++ b/dm/DM.cpp
@@ -547,6 +547,14 @@ static void push_codec_srcs(Path path) {
                         continue;
                     }
 
+                    // Only test kNonNative_DstColorType when the alpha type is premul and there is

[scroggo, 2016/04/26 13:22:33]

I found this a little bit confusing. I thought you meant when the image's alpha
type is premul, leaving me confused why we didn't care to test an opaque image
with both byte orders. Here's my understanding:

We normally test decoding an image while requesting premul alpha type and
unpremul.
If the image is opaque, we also request opaque.
This prevents us from doing the second and third ones.

Is that correct?

I understand skipping opaque, which would follow the same code path, but
unpremul will take a different path, so I think that might be interesting.

As for the scale, I could imagine that our sampling code is wrong for one byte
order, so I could imagine it being useful to test a scale.

[msarett, 2016/04/26 15:00:54]

Yes you're correct.  You make a good point that unpremul swizzles differently
than premul.  We should test both.

I think we can safely drop opaque, decoding opaque images to
premul/unpremul/opaque will exercise the same code.

IMO, this is sufficiently confusing that I'd rather back off on disabling alpha
modes.  I'd rather come up with a long term fix than pile on these hacks.
Yes.  We should test our sampling code.  "Native" scales don't test sampling
though, they test scaling in libjpeg-turbo/libwebp.

+                    // no native scale.  This test won't be interestingly different with different
+                    // alpha types or scales.
+                    if (CodecSrc::kNonNative8888_Always_DstColorType == colorType &&
+                            (kPremul_SkAlphaType != alphaType || 1.0f != scale)) {
+                        continue;
+                    }
+
                     push_codec_src(path, mode, colorType, alphaType, scale);
                 }
             }
@@ -577,6 +585,14 @@ static void push_codec_srcs(Path path) {
     for (int sampleSize : sampleSizes) {
         for (CodecSrc::DstColorType colorType : colorTypes) {
             for (SkAlphaType alphaType : alphaModes) {
+                // Only test kNonNative_DstColorType when the alpha type is premul and sample size
+                // is 1 or 2.  This test won't be interestingly different with different
+                // alpha types or additional sample sizes.

[scroggo, 2016/04/26 13:22:33]

Why not for additional sample sizes? Won't we be exercising different code?

[msarett, 2016/04/26 15:00:54]

Sampling vs not-sampling will exercise different code.  But sampleSize=2 vs
sampleSize=3,4,5,6,7,8 all exercise the same code.  I thought it would be good
enough to exercise the sampling code once (with sampleSize = 2).  What do you
think?

I'm adding sampleSize 3 as well for a little additional coverage.

[scroggo, 2016/04/26 15:31:40]

sgtm

+                if (CodecSrc::kNonNative8888_Always_DstColorType == colorType &&
+                        (kPremul_SkAlphaType != alphaType || sampleSize > 2)) {
+                    continue;
+                }
+
                 push_android_codec_src(path, AndroidCodecSrc::kFullImage_Mode, colorType,
                         alphaType, sampleSize);
                 if (subset) {