skstd -> std for unique_ptr

include/core/SkRefCnt.h

Index: include/core/SkRefCnt.h
diff --git a/include/core/SkRefCnt.h b/include/core/SkRefCnt.h
index 0e8d857722d2678d8620fe923267fff82b7e197e..abe3fb28278206147693753a5137c40f36e0a4f3 100644
--- a/include/core/SkRefCnt.h
+++ b/include/core/SkRefCnt.h
@@ -9,8 +9,8 @@
 #define SkRefCnt_DEFINED
 
 #include "../private/SkAtomics.h"
-#include "../private/SkUniquePtr.h"
 #include "SkTypes.h"
+#include <memory>
 
 /** \class SkRefCntBase
 
@@ -185,12 +185,15 @@ template <typename T> struct SkTUnref {
 /**
  *  Utility class that simply unref's its argument in the destructor.
  */
-template <typename T> class SkAutoTUnref : public skstd::unique_ptr<T, SkTUnref<T>> {
+template <typename T> class SkAutoTUnref : public std::unique_ptr<T, SkTUnref<T>> {
 public:
-    explicit SkAutoTUnref(T* obj = nullptr) : skstd::unique_ptr<T, SkTUnref<T>>(obj) {}
+    explicit SkAutoTUnref(T* obj = nullptr) : std::unique_ptr<T, SkTUnref<T>>(obj) {}
 
     T* detach() { return this->release(); }
     operator T*() const { return this->get(); }
+

[bungeman-skia, 2015/12/02 22:27:13]

Does adding something like

using inherited_t = std::unique_ptr<T, SkTUnref<T>>;

SkAutoTUnref& operator=(SkAutoTUnref&& that) {
    inherited_t::operator=(std::move(that));
    return *this;
}

work around the issue with libc++? I'm not sure this is even entirely correct,
but it might be interesting as a workaround until we can get good stls.

Just because, here is an old discussion of this very issue
http://lists.llvm.org/pipermail/llvm-dev/2012-September/053876.html and was
fixed with http://llvm.org/viewvc/llvm-project?view=revision&revision=234886 .

+    // unique_ptr's operator bool() is not always be explicit on Android.  Make sure this is.
+    explicit operator bool() const { return this->get() != nullptr; }
 };
 // Can't use the #define trick below to guard a bare SkAutoTUnref(...) because it's templated. :(