Revert of correct reporting of kAlphaUnchanged_Flag in ModeFilter

src/effects/SkColorFilters.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlitRow.h"
 #include "SkColorFilter.h"
 #include "SkColorPriv.h"
 #include "SkModeColorFilter.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkUtils.h"
 #include "SkString.h"
 #include "SkValidationUtils.h"
 #include "SkColorMatrixFilter.h"
 
 bool SkModeColorFilter::asColorMode(SkColor* color, SkXfermode::Mode* mode) const {
     if (color) {
         *color = fColor;
     }
     if (mode) {
         *mode = fMode;
     }
     return true;
 }
 
 uint32_t SkModeColorFilter::getFlags() const {
-    uint32_t flags = 0;
-    switch (fMode) {
-        case SkXfermode::kDst_Mode:      //!< [Da, Dc]
-        case SkXfermode::kSrcATop_Mode:  //!< [Da, Sc * Da + (1 - Sa) * Dc]
-            flags |= kAlphaUnchanged_Flag;
-        default:
-            break;
-    }
-    if (fProc16) {
-        flags |= kHasFilter16_Flag;
-    }
-    return flags;
+    return fProc16 ? (kAlphaUnchanged_Flag | kHasFilter16_Flag) : 0;
 }
 
 void SkModeColorFilter::filterSpan(const SkPMColor shader[], int count, SkPMColor result[]) const {
     SkPMColor       color = fPMColor;
     SkXfermodeProc  proc = fProc;
     
     for (int i = 0; i < count; i++) {
         result[i] = proc(color, shader[i]);
     }
 }
@@ skipping 342 matching lines @@
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class Src_SkModeColorFilter : public SkModeColorFilter {
 public:
     Src_SkModeColorFilter(SkColor color) : INHERITED(color, SkXfermode::kSrc_Mode) {}
 
     uint32_t getFlags() const SK_OVERRIDE {
         if (SkGetPackedA32(this->getPMColor()) == 0xFF) {
-            return kHasFilter16_Flag;
+            return kAlphaUnchanged_Flag | kHasFilter16_Flag;
         } else {
             return 0;
         }
     }
 
     virtual void filterSpan(const SkPMColor shader[], int count,
                             SkPMColor result[]) const SK_OVERRIDE {
         sk_memset32(result, this->getPMColor(), count);
     }
 
     virtual void filterSpan16(const uint16_t shader[], int count,
                               uint16_t result[]) const SK_OVERRIDE {
         SkASSERT(this->getFlags() & kHasFilter16_Flag);
         sk_memset16(result, SkPixel32ToPixel16(this->getPMColor()), count);
     }
 
 private:
     typedef SkModeColorFilter INHERITED;
 };
 
 class SrcOver_SkModeColorFilter : public SkModeColorFilter {
 public:
     SrcOver_SkModeColorFilter(SkColor color)
             : INHERITED(color, SkXfermode::kSrcOver_Mode) {
         fColor32Proc = SkBlitRow::ColorProcFactory();
     }
 
     uint32_t getFlags() const SK_OVERRIDE {
         if (SkGetPackedA32(this->getPMColor()) == 0xFF) {
-            return kHasFilter16_Flag;
+            return kAlphaUnchanged_Flag | kHasFilter16_Flag;
         } else {
             return 0;
         }
     }
 
     virtual void filterSpan(const SkPMColor shader[], int count,
                             SkPMColor result[]) const SK_OVERRIDE {
         fColor32Proc(result, shader, count, this->getPMColor());
     }
 
@@ skipping 72 matching lines @@
                     byte_to_scale(SkColorGetG(mul)),
                     byte_to_scale(SkColorGetB(mul)),
                     1);
     matrix.postTranslate(SkIntToScalar(SkColorGetR(add)),
                          SkIntToScalar(SkColorGetG(add)),
                          SkIntToScalar(SkColorGetB(add)),
                          0);
     return SkColorMatrixFilter::Create(matrix);
 }