Cache the inverse matrix on SkColorSpace. Rename xyz() to toXYZ().

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"
 #include "SkOnce.h"
 
 SkColorSpace::SkColorSpace(const SkMatrix44& toXYZD50)
     : fToXYZD50(toXYZD50)
 {}
 
 SkColorSpace_Base::SkColorSpace_Base(SkGammaNamed gammaNamed, const SkMatrix44& toXYZD50)
     : INHERITED(toXYZD50)
     , fGammaNamed(gammaNamed)
     , fGammas(nullptr)
     , fProfileData(nullptr)
+    , fFromXYZD50(SkMatrix44::kUninitialized_Constructor)
 {}
 
 SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkColorLookUpTable> colorLUT, SkGammaNamed gammaNamed,
                                      sk_sp<SkGammas> gammas, const SkMatrix44& toXYZD50,
                                      sk_sp<SkData> profileData)
     : INHERITED(toXYZD50)
     , fColorLUT(std::move(colorLUT))
     , fGammaNamed(gammaNamed)
     , fGammas(std::move(gammas))
     , fProfileData(std::move(profileData))
+    , fFromXYZD50(SkMatrix44::kUninitialized_Constructor)
 {}
 
 static constexpr float gSRGB_toXYZD50[] {
     0.4358f, 0.2224f, 0.0139f,    // * R
     0.3853f, 0.7170f, 0.0971f,    // * G
     0.1430f, 0.0606f, 0.7139f,    // * B
 };
 
 static constexpr float gAdobeRGB_toXYZD50[] {
     0.6098f, 0.3111f, 0.0195f,    // * R
     0.2052f, 0.6257f, 0.0609f,    // * G
     0.1492f, 0.0632f, 0.7448f,    // * B
 };
 
+const SkMatrix44& SkColorSpace_Base::fromXYZ() const {

[msarett, 2016/09/08 15:06:07]

nit: In my head, this should be next to the other "getters" in this file
(gammaIsLinear(), gammaCloseSRGB()).

Does that make sense to anyone else?

+    fFromXYZOnce([this] {
+        if (!fToXYZD50.invert(&fFromXYZD50)) {
+            SkDEBUGFAIL("Non-invertible XYZ matrix, defaulting to sRGB");
+            SkMatrix44 srgbToxyzD50(SkMatrix44::kUninitialized_Constructor);

[msarett, 2016/09/08 15:06:07]

I'm fine with this behavior, but just to be clear on the implications of this:

Every time a client asks for a transform to a dst gamut that we can't invert -
we will instead give them a transform to sRGB gamut.

Maybe a comment?

+            srgbToxyzD50.set3x3RowMajorf(gSRGB_toXYZD50);
+            srgbToxyzD50.invert(&fFromXYZD50);
+        }
+    });
+    return fFromXYZD50;
+}
+
 /**
  *  Checks if our toXYZ matrix is a close match to a known color gamut.
  *
  *  @param toXYZD50 transformation matrix deduced from profile data
  *  @param standard 3x3 canonical transformation matrix
  */
 static bool xyz_almost_equal(const SkMatrix44& toXYZD50, const float* standard) {
     return color_space_almost_equal(toXYZD50.getFloat(0, 0), standard[0]) &&
            color_space_almost_equal(toXYZD50.getFloat(0, 1), standard[1]) &&
            color_space_almost_equal(toXYZD50.getFloat(0, 2), standard[2]) &&
@@ skipping 365 matching lines @@
                 return false;
             }
 
             // It is unlikely that we will reach this case.
             sk_sp<SkData> srcData = src->serialize();
             sk_sp<SkData> dstData = dst->serialize();
             return srcData->size() == dstData->size() &&
                    0 == memcmp(srcData->data(), dstData->data(), srcData->size());
     }
 }