isolate sk_sp from larger cl

include/core/SkRefCnt.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkRefCnt_DEFINED
 #define SkRefCnt_DEFINED
 
@@ skipping 209 matching lines @@
             SkDEBUGCODE(fRefCnt = 1;)  // restore the 1 for our destructor's assert
             delete (const Derived*)this;
         }
     }
     void  deref() const { this->unref(); }
 
 private:
     mutable int32_t fRefCnt;
 };
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+template <typename T> class sk_sp {
+public:

[fmalita_google_do_not_use, 2016/03/01 05:23:25]

Default ctor?

[mtklein, 2016/03/01 13:25:36]

(T* obj = nullptr) serves as the default.

+    sk_sp(std::nullptr_t) : fPtr(nullptr) {}
+    sk_sp(const sk_sp<T>& that) : fPtr(SkSafeRef(that.get())) {}
+    sk_sp(sk_sp<T>&& that) : fPtr(that.release()) {}
+    explicit sk_sp(T* obj = nullptr) : fPtr(obj) {}

[fmalita_google_do_not_use, 2016/03/01 05:23:25]

The adoption is not self documenting, and it's bound to be confusing in
Chromium/Blink land.  How about an explicit Adopt() instead?

[f(malita), 2016/03/01 12:53:49]

OTOH this makes sk_sp a drop-in replacment for SkAutoTUnref, which I think is
desirable.  Don't let me slow this down, we can tweak later.  LGTM.

[mtklein, 2016/03/01 13:25:36]

Let's plan for very few bare pointers escape into Chromium/Blink land.  The
usual interaction should be with the other constructors and operators.  But I
think it can't hurt to move this up a bit on its own and write something like

// Adopts ownership of the reference of an existing bare T*, mostly for
transitional compatibility.

+    ~sk_sp() {
+        SkSafeUnref(fPtr);
+    }
+
+    sk_sp<T>& operator=(const sk_sp<T>& that) {
+        this->reset(SkSafeRef(that.get()));
+        return *this;
+    }
+    sk_sp<T>& operator=(sk_sp<T>&& that) {
+        this->reset(that.release());
+        return *this;
+    }
+
+    bool operator==(std::nullptr_t) const { return this->get() == nullptr; }
+    bool operator!=(std::nullptr_t) const { return this->get() != nullptr; }
+
+    bool operator==(const sk_sp<T>& that) const { return this->get() == that.get(); }
+    bool operator!=(const sk_sp<T>& that) const { return this->get() != that.get(); }
+
+    explicit operator bool() const { return this->get() != nullptr; }
+
+    T* get() const { return fPtr; }
+    T* operator->() const { return fPtr; }
+
+    void reset(T* ptr) {
+        SkSafeUnref(fPtr);
+        fPtr = ptr;
+    }
+
+    T* release() {
+        T* ptr = fPtr;
+        fPtr = nullptr;
+        return ptr;
+    }
+
+private:
+    T*  fPtr;
+};
+
 #endif