Delete kInvalid_GammaNamed (part 2)

src/core/SkColorSpace_ICC.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkColorSpace.h"
 #include "SkColorSpace_Base.h"
 #include "SkColorSpacePriv.h"
@@ skipping 576 matching lines @@
             return 0;
     }
 }
 
 /**
  *  Sets invalid gamma to the default value.
  */
 static void handle_invalid_gamma(SkGammas::Type* type, SkGammas::Data* data) {
     if (SkGammas::Type::kNone_Type == *type) {
         *type = SkGammas::Type::kNamed_Type;
-        data->fNamed = SkColorSpace::kInvalid_GammaNamed;
+
+        // Guess sRGB in the case of a malformed transfer function.
+        data->fNamed = SkColorSpace::kSRGB_GammaNamed;
     }
 }
 
 /**
  *  Finish loading the gammas, now that we have allocated memory for the SkGammas struct.
  *
  *  There's nothing to do for the simple cases, but for table gammas we need to actually
  *  read the table into heap memory.  And for parametric gammas, we need to copy over the
  *  parameter values.
  *
@@ skipping 277 matching lines @@
             offset += load_gammas(memory, offset, gType, &gData, gParams, gTagPtr);
 
             (*gammas)->fBlueType = bType;
             load_gammas(memory, offset, bType, &bData, bParams, bTagPtr);
 
             (*gammas)->fRedData = rData;
             (*gammas)->fGreenData = gData;
             (*gammas)->fBlueData = bData;
         }
     } else {
-        *gammaNamed = SkColorSpace::kInvalid_GammaNamed;
+        // Guess sRGB if the chunk is missing a transfer function.
+        *gammaNamed = SkColorSpace::kSRGB_GammaNamed;
     }
 
     if (SkColorSpace::kNonStandard_GammaNamed == *gammaNamed) {
         *gammaNamed = is_named(*gammas);
         if (SkColorSpace::kNonStandard_GammaNamed != *gammaNamed) {
             // No need to keep the gammas struct, the enum is enough.
             *gammas = nullptr;
         }
     }
 
@@ skipping 179 matching lines @@
                                               g->addr(base));
 
                         gammas->fBlueType = bType;
                         load_gammas(memory, offset, bType, &bData, bParams, b->addr(base));
 
                         gammas->fRedData = rData;
                         gammas->fGreenData = gData;
                         gammas->fBlueData = bData;
                     }
                 } else {
-                    gammaNamed = kInvalid_GammaNamed;
+                    // Guess sRGB if the profile is missing transfer functions.
+                    gammaNamed = kSRGB_GammaNamed;
                 }
 
                 if (kNonStandard_GammaNamed == gammaNamed) {
                     // It's possible that we'll initially detect non-matching gammas, only for
                     // them to evaluate to the same named gamma curve.
                     gammaNamed = is_named(gammas);
                     if (kNonStandard_GammaNamed == gammaNamed) {
                         return sk_sp<SkColorSpace>(new SkColorSpace_Base(nullptr, gammaNamed,
                                                                          std::move(gammas), mat,
                                                                          std::move(data)));
@@ skipping 251 matching lines @@
     ptr32[4] = SkEndian_SwapBE32(0x000116cc);
     ptr += kTAG_XYZ_Bytes;
 
     // Write copyright tag
     memcpy(ptr, gEmptyTextTag, sizeof(gEmptyTextTag));
 
     // TODO (msarett): Should we try to hold onto the data so we can return immediately if
     //                 the client calls again?
     return SkData::MakeFromMalloc(profile.release(), kICCProfileSize);
 }