Remove redundant tests to make DM a little faster

dm/DM.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "CrashHandler.h"
 #include "DMJsonWriter.h"
 #include "DMSrcSink.h"
@@ skipping 529 matching lines @@
         for (float scale : nativeScales) {
             for (CodecSrc::DstColorType colorType : colorTypes) {
                 for (SkAlphaType alphaType : alphaModes) {
                     // Only test kCroppedScanline_Mode when the alpha type is opaque.  The test is
                     // slow and won't be interestingly different with different alpha types.
                     if (CodecSrc::kCroppedScanline_Mode == mode &&
                             kOpaque_SkAlphaType != alphaType) {
                         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);
                 }
             }
         }
     }
 
     if (FLAGS_simpleCodec) {
         return;
     }
 
@@ skipping 10 matching lines @@
             subset = true;
             break;
         }
     }
 
     const int sampleSizes[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 
     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) {
                     push_android_codec_src(path, AndroidCodecSrc::kDivisor_Mode, colorType,
                             alphaType, sampleSize);
                 }
             }
         }
     }
 
@@ skipping 828 matching lines @@
 #endif
 }
 } // namespace skiatest
 
 #if !defined(SK_BUILD_FOR_IOS)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif