Expose more gamma info for UMA statistics

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 542 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::kSRGB_GammaNamed;
+        data->fNamed = SkColorSpace::kInvalid_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 258 matching lines @@
             (*gammas)->fGreenType = gType;
             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;
     }
 
     uint32_t offsetToMatrix = read_big_endian_i32(src + 16);
     if (0 != offsetToMatrix && offsetToMatrix < len) {
         if (!load_matrix(toXYZ, src + offsetToMatrix, len - offsetToMatrix)) {
             SkColorSpacePrintf("Failed to read matrix from A to B tag.\n");
             toXYZ->setIdentity();
         }
     }
 
@@ skipping 102 matching lines @@
                     }
                 }
 
                 GammaNamed gammaNamed = kNonStandard_GammaNamed;
                 sk_sp<SkGammas> gammas = nullptr;
                 size_t tagBytes;
                 if (r && g && b) {
                     if (tag_equals(r, g, base) && tag_equals(g, b, base)) {
                         SkGammas::Data data;
                         SkGammas::Params params;
-                        SkGammas::Type Type =
+                        SkGammas::Type type =
                                 parse_gamma(&data, &params, &tagBytes, r->addr(base), r->fLength);
-                        handle_invalid_gamma(&Type, &data);
+                        handle_invalid_gamma(&type, &data);
 
-                        if (SkGammas::Type::kNamed_Type == Type) {
+                        if (SkGammas::Type::kNamed_Type == type) {
                             gammaNamed = data.fNamed;
                         } else {
-                            size_t allocSize = sizeof(SkGammas) + gamma_alloc_size(Type, data);
+                            size_t allocSize = sizeof(SkGammas) + gamma_alloc_size(type, data);
                             void* memory = sk_malloc_throw(allocSize);
                             gammas = sk_sp<SkGammas>(new (memory) SkGammas());
-                            load_gammas(memory, 0, Type, &data, params, r->addr(base));
+                            load_gammas(memory, 0, type, &data, params, r->addr(base));
 
-                            gammas->fRedType = Type;
-                            gammas->fGreenType = Type;
-                            gammas->fBlueType = Type;
+                            gammas->fRedType = type;
+                            gammas->fGreenType = type;
+                            gammas->fBlueType = type;
 
                             gammas->fRedData = data;
                             gammas->fGreenData = data;
                             gammas->fBlueData = data;
                         }
                     } else {
                         SkGammas::Data rData;
                         SkGammas::Params rParams;
                         SkGammas::Type rType =
                                 parse_gamma(&rData, &rParams, &tagBytes, r->addr(base), r->fLength);
@@ skipping 27 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 = kLinear_GammaNamed;
+                    gammaNamed = kInvalid_GammaNamed;
                 }
 
                 if (kNonStandard_GammaNamed == gammaNamed) {
                     return sk_sp<SkColorSpace>(new SkColorSpace_Base(nullptr, gammaNamed,
                                                                      std::move(gammas), mat,
                                                                      std::move(data)));
                 } else {
                     return SkColorSpace_Base::NewRGB(gammaNamed, mat);
                 }
             }
@@ skipping 246 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);
 }