Add skstd::unique_ptr and use it.

include/private/SkFunction.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkFunction_DEFINED
 #define SkFunction_DEFINED
 
 // TODO: document, more pervasive move support in constructors, small-Fn optimization
 
-#include "SkTemplates.h"
+#include "SkUtility.h"
+#include "SkUniquePtr.h"
 #include "SkTypes.h"
 
 template <typename> class SkFunction;
 
 template <typename R, typename... Args>
 class SkFunction<R(Args...)> {
 public:
     SkFunction() {}
 
     template <typename Fn>
     SkFunction(const Fn& fn)
         : fFunction(new LambdaImpl<Fn>(fn)) {}
 
     SkFunction(R (*fn)(Args...)) : fFunction(new FnPtrImpl(fn)) {}
 
     SkFunction(const SkFunction& other) { *this = other; }
     SkFunction& operator=(const SkFunction& other) {
         if (this != &other) {
-            fFunction.reset(other.fFunction ? other.fFunction->clone() : nullptr);
+            fFunction.reset(other.fFunction.get() ? other.fFunction->clone() : nullptr);
         }
         return *this;
     }
 
     R operator()(Args... args) const {
         SkASSERT(fFunction.get());
         return fFunction->call(skstd::forward<Args>(args)...);
     }
 
 private:
@@ skipping 19 matching lines @@
     public:
         FnPtrImpl(R (*fn)(Args...)) : fFn(fn) {}
 
         R call(Args... args) const override { return fFn(skstd::forward<Args>(args)...); }
         Interface* clone() const override { return new FnPtrImpl(fFn); }
 
     private:
         R (*fFn)(Args...);
     };
 
-    SkAutoTDelete<Interface> fFunction;
+    skstd::unique_ptr<Interface> fFunction;
 };
 
 #endif//SkFunction_DEFINED