skstd -> std for unique_ptr

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
 
 #include "../private/SkAtomics.h"
-#include "../private/SkUniquePtr.h"
 #include "SkTypes.h"
+#include <memory>
 
 /** \class SkRefCntBase
 
     SkRefCntBase is the base class for objects that may be shared by multiple
     objects. When an existing owner wants to share a reference, it calls ref().
     When an owner wants to release its reference, it calls unref(). When the
     shared object's reference count goes to zero as the result of an unref()
     call, its (virtual) destructor is called. It is an error for the
     destructor to be called explicitly (or via the object going out of scope on
     the stack or calling delete) if getRefCnt() > 1.
@@ skipping 154 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 template <typename T> struct SkTUnref {
     void operator()(T* t) { t->unref(); }
 };
 
 /**
  *  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. :(
 
 class SkAutoUnref : public SkAutoTUnref<SkRefCnt> {
 public:
     SkAutoUnref(SkRefCnt* obj) : SkAutoTUnref<SkRefCnt>(obj) {}
 };
 #define SkAutoUnref(...) SK_REQUIRE_LOCAL_VAR(SkAutoUnref)
 
 // This is a variant of SkRefCnt that's Not Virtual, so weighs 4 bytes instead of 8 or 16.
@@ skipping 17 matching lines @@
                     delete (const Derived*)this;
         }
     }
     void  deref() const { this->unref(); }
 
 private:
     mutable int32_t fRefCnt;
 };
 
 #endif