Add SkColorSpace::Equals() API

src/core/SkColorSpace.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 298 matching lines @@
     uint32_t profileSize = *((uint32_t*) data);
     data = SkTAddOffset<const void>(data, sizeof(uint32_t));
     length -= sizeof(uint32_t);
     if (length < profileSize) {
         return nullptr;
     }
 
     return NewICC(data, profileSize);
 }
 
+bool SkColorSpace::Equals(SkColorSpace* src, SkColorSpace* dst) {
+    if (src == dst) {
+        return true;
+    }
+
+    if (!src || !dst) {
+        return false;
+    }
+
+    switch (src->fNamed) {
+        case kSRGB_Named:
+        case kAdobeRGB_Named:
+            // No need to check for a match.  sRGB and Adobe RGB are once ptrs - if they
+            // were a match, we would have already returned.

[mtklein, 2016/07/29 15:43:48]

This seems fragile.  Unless you've got a way to assert that this assumption is
true, why not just check?

[msarett, 2016/07/29 16:16:01]

True, that also seems nicer to read, sgtm.

+            return false;
+        case kUnknown_Named:
+            if (kUnknown_Named != dst->fNamed) {
+                return false;
+            }
+            break;
+    }
+
+    SkData* srcData = as_CSB(src)->fProfileData.get();
+    SkData* dstData = as_CSB(dst)->fProfileData.get();
+    if (srcData || dstData) {
+        if (srcData && dstData) {
+            if (srcData->size() != dstData->size()) {

[mtklein, 2016/07/29 15:43:48]

Maybe,

return srcData->size() == dstData->size()
    && 0 == memcmp(srcData->data(), dstData->data(), srcData()->size());

[msarett, 2016/07/29 16:16:01]

Done.

+                return false;
+            }
+
+            return !memcmp(srcData->data(), dstData->data(), srcData->size());
+        }
+
+        return false;
+    }
+
+    switch (src->fGammaNamed) {
+        case kSRGB_GammaNamed:
+        case k2Dot2Curve_GammaNamed:
+        case kLinear_GammaNamed:
+            return (src->fGammaNamed == dst->fGammaNamed) && (src->fToXYZD50 == dst->fToXYZD50);
+        default:
+            // If |src| does not have a named gamma, fProfileData should be non-null.

[mtklein, 2016/07/29 15:43:48]

Does it make sense to just move this before the fProfileData section, and make
this fall through?

[msarett, 2016/07/29 16:16:01]

Can't do that because a kNonStandard_GammaNamed is not the only reason we might
save the profile data (we also save it if there is a colorLUT).

An earlier version of this CL actually checks for colorLUTs, but I thought this
was a bit simpler (and also the old one had bugs).  Maybe a comment would be
helpful?  One thing I like about this function is that if I continue to add
"nonstandard" features, I think it should continue to work.  fProfileData is a
nice catch-all for weird profiles.

reed@ actually suggested at one point that I just use serialize() to test
equality if we don't hit the first couple fast cases.  That also might make this
simpler and easier to maintain.

+            SkASSERT(false);
+            return false;
+    }
+}
+
 bool SkColorSpace::gammasAreMatching() const {
     const SkGammas* gammas = as_CSB(this)->gammas();
     SkASSERT(gammas);
     return gammas->fRedType == gammas->fGreenType && gammas->fGreenType == gammas->fBlueType &&
            gammas->fRedData == gammas->fGreenData && gammas->fGreenData == gammas->fBlueData;
 }
 
 bool SkColorSpace::gammasAreNamed() const {
     const SkGammas* gammas = as_CSB(this)->gammas();
     SkASSERT(gammas);
@@ skipping 18 matching lines @@
            gammas->fBlueType == SkGammas::Type::kTable_Type;
 }
 
 bool SkColorSpace::gammasAreParams() const {
     const SkGammas* gammas = as_CSB(this)->gammas();
     SkASSERT(gammas);
     return gammas->fRedType == SkGammas::Type::kParam_Type &&
            gammas->fGreenType == SkGammas::Type::kParam_Type &&
            gammas->fBlueType == SkGammas::Type::kParam_Type;
 }