Move off SK_SUPPORT_LEGACY_DATA_FACTORIES.

include/gpu/GrResourceKey.h

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrResourceKey_DEFINED
 #define GrResourceKey_DEFINED
@@ skipping 220 matching lines @@
 
     GrUniqueKey(const GrUniqueKey& that) { *this = that; }
 
     /** reset() returns the key to the invalid state. */
     using INHERITED::reset;
 
     using INHERITED::isValid;
 
     GrUniqueKey& operator=(const GrUniqueKey& that) {
         this->INHERITED::operator=(that);
-        this->setCustomData(that.getCustomData());
+        this->setCustomData(sk_ref_sp(that.getCustomData()));
         return *this;
     }
 
     bool operator==(const GrUniqueKey& that) const {
         return this->INHERITED::operator==(that);
     }
     bool operator!=(const GrUniqueKey& that) const { return !(*this == that); }
 
-    void setCustomData(const SkData* data) {
-        SkSafeRef(data);
-        fData.reset(data);
+    void setCustomData(sk_sp<SkData> data) {
+        fData = std::move(data);
     }
-    const SkData* getCustomData() const {
+    SkData* getCustomData() const {
         return fData.get();
     }
 
     class Builder : public INHERITED::Builder {
     public:
         Builder(GrUniqueKey* key, Domain domain, int data32Count)
             : INHERITED::Builder(key, domain, data32Count) {}
 
         /** Used to build a key that wraps another key and adds additional data. */
         Builder(GrUniqueKey* key, const GrUniqueKey& innerKey, Domain domain,
                 int extraData32Cnt)
             : INHERITED::Builder(key, domain, Data32CntForInnerKey(innerKey) + extraData32Cnt) {
             SkASSERT(&innerKey != key);
             // add the inner key to the end of the key so that op[] can be indexed normally.
             uint32_t* innerKeyData = &this->operator[](extraData32Cnt);
             const uint32_t* srcData = innerKey.data();
             (*innerKeyData++) = innerKey.domain();
             memcpy(innerKeyData, srcData, innerKey.dataSize());
         }
 
     private:
         static int Data32CntForInnerKey(const GrUniqueKey& innerKey) {
             // key data + domain
             return SkToInt((innerKey.dataSize() >> 2) + 1);
         }
     };
 
 private:
-    SkAutoTUnref<const SkData> fData;
+    sk_sp<SkData> fData;
 };
 
 /**
  * It is common to need a frequently reused GrUniqueKey where the only requirement is that the key
  * is unique. These macros create such a key in a thread safe manner so the key can be truly global
  * and only constructed once.
  */
 
 /** Place outside of function/class definitions. */
 #define GR_DECLARE_STATIC_UNIQUE_KEY(name) static SkOnce name##_once
@@ skipping 20 matching lines @@
         fKey = that.fKey;
         return *this;
     }
 
     const GrUniqueKey& key() const { return fKey; }
 
 private:
     GrUniqueKey fKey;
 };
 #endif