SkColorSpace tweaks

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 "SkOnce.h"
 
 static bool color_space_almost_equal(float a, float b) {
     return SkTAbs(a - b) < 0.01f;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
 SkColorSpace::SkColorSpace(GammaNamed gammaNamed, const SkMatrix44& toXYZD50, Named named)
     : fGammaNamed(kNonStandard_GammaNamed)
     , fToXYZD50(toXYZD50)
     , fNamed(named)
 {}
 
 SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkGammas> gammas, const SkMatrix44& toXYZD50,
                                      Named named)
     : INHERITED(kNonStandard_GammaNamed, toXYZD50, named)
-    , fGammas(gammas)
+    , fGammas(std::move(gammas))
 {}
 
 SkColorSpace_Base::SkColorSpace_Base(sk_sp<SkGammas> gammas, GammaNamed gammaNamed,
                                      const SkMatrix44& toXYZD50, Named named)
     : INHERITED(gammaNamed, toXYZD50, named)
-    , fGammas(gammas)
+    , fGammas(std::move(gammas))
 {}
 
 SkColorSpace_Base::SkColorSpace_Base(SkColorLookUpTable* colorLUT, sk_sp<SkGammas> gammas,
                                      const SkMatrix44& toXYZD50)
     : INHERITED(kNonStandard_GammaNamed, toXYZD50, kUnknown_Named)
     , fColorLUT(colorLUT)
-    , fGammas(gammas)
+    , fGammas(std::move(gammas))
 {}
 
 const float gSRGB_toXYZD50[] {
     0.4358f, 0.2224f, 0.0139f,    // * R
     0.3853f, 0.7170f, 0.0971f,    // * G
     0.1430f, 0.0606f, 0.7139f,    // * B
 };
 
 const float gAdobeRGB_toXYZD50[] {
     0.6098f, 0.3111f, 0.0195f,    // * R
@@ skipping 24 matching lines @@
            color_space_almost_equal(toXYZD50.getFloat(3, 1), 0.0f) &&
            color_space_almost_equal(toXYZD50.getFloat(3, 2), 0.0f) &&
            color_space_almost_equal(toXYZD50.getFloat(3, 3), 1.0f);
 }
 
 static SkOnce g2Dot2CurveGammasOnce;
 static SkGammas* g2Dot2CurveGammas;
 static SkOnce gLinearGammasOnce;
 static SkGammas* gLinearGammas;
 
-sk_sp<SkColorSpace> SkColorSpace::NewRGB(float gammaVals[3], const SkMatrix44& toXYZD50) {
+sk_sp<SkColorSpace> SkColorSpace::NewRGB(const float gammaVals[3], const SkMatrix44& toXYZD50) {
     sk_sp<SkGammas> gammas = nullptr;
     GammaNamed gammaNamed = kNonStandard_GammaNamed;
 
     // Check if we really have sRGB or Adobe RGB
     if (color_space_almost_equal(2.2f, gammaVals[0]) &&
         color_space_almost_equal(2.2f, gammaVals[1]) &&
         color_space_almost_equal(2.2f, gammaVals[2]))
     {
         g2Dot2CurveGammasOnce([] {
                 g2Dot2CurveGammas = new SkGammas(2.2f, 2.2f, 2.2f);
@@ skipping 692 matching lines @@
                 mat.set3x3ColMajorf(toXYZ);
                 if (gammas->isValues()) {
                     // When we have values, take advantage of the NewFromRGB initializer.
                     // This allows us to check for canonical sRGB and Adobe RGB.
                     float gammaVals[3];
                     gammaVals[0] = gammas->fRed.fValue;
                     gammaVals[1] = gammas->fGreen.fValue;
                     gammaVals[2] = gammas->fBlue.fValue;
                     return SkColorSpace::NewRGB(gammaVals, mat);
                 } else {
-                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammas, mat, kUnknown_Named));
+                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(std::move(gammas), mat,
+                                                                     kUnknown_Named));
                 }
             }
 
             // Recognize color profile specified by A2B0 tag.
             const ICCTag* a2b0 = ICCTag::Find(tags.get(), tagCount, kTAG_A2B0);
             if (a2b0) {
                 SkAutoTDelete<SkColorLookUpTable> colorLUT(new SkColorLookUpTable());
                 SkGammaCurve curves[3];
                 SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
                 if (!load_a2b0(colorLUT, curves, &toXYZ, a2b0->addr((const uint8_t*) base),
                                a2b0->fLength)) {
                     return_null("Failed to parse A2B0 tag");
                 }
 
                 sk_sp<SkGammas> gammas(new SkGammas(std::move(curves[0]), std::move(curves[1]),
                                                     std::move(curves[2])));
                 if (colorLUT->fTable) {
-                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(colorLUT.release(), gammas,
-                                                                     toXYZ));
+                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(colorLUT.release(),
+                                                                     std::move(gammas), toXYZ));
                 } else if (gammas->isValues()) {
                     // When we have values, take advantage of the NewFromRGB initializer.
                     // This allows us to check for canonical sRGB and Adobe RGB.
                     float gammaVals[3];
                     gammaVals[0] = gammas->fRed.fValue;
                     gammaVals[1] = gammas->fGreen.fValue;
                     gammaVals[2] = gammas->fBlue.fValue;
                     return SkColorSpace::NewRGB(gammaVals, toXYZ);
                 } else {
-                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(gammas, toXYZ,
+                    return sk_sp<SkColorSpace>(new SkColorSpace_Base(std::move(gammas), toXYZ,
                                                                      kUnknown_Named));
                 }
             }
-
         }
         default:
             break;
     }
 
     return_null("ICC profile contains unsupported colorspace");
 }