Add skstd::move and skstd::forward.

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
 
@@ skipping 17 matching lines @@
     SkFunction(const SkFunction& other) { *this = other; }
     SkFunction& operator=(const SkFunction& other) {
         if (this != &other) {
             fFunction.reset(other.fFunction ? other.fFunction->clone() : nullptr);
         }
         return *this;
     }
 
     R operator()(Args... args) const {
         SkASSERT(fFunction.get());
-        return fFunction->call(Forward(args)...);
+        return fFunction->call(skstd::forward<Args>(args)...);
     }
 
 private:
-    // ~= std::forward.  This moves its argument if possible, falling back to a copy if not.
-    template <typename T> static T&& Forward(T& v) { return (T&&)v; }
-
     struct Interface {
         virtual ~Interface() {}
         virtual R call(Args...) const = 0;
         virtual Interface* clone() const = 0;
     };
 
     template <typename Fn>
     class LambdaImpl final : public Interface {
     public:
         LambdaImpl(const Fn& fn) : fFn(fn) {}
 
-        R call(Args... args) const override { return fFn(Forward(args)...); }
+        R call(Args... args) const override { return fFn(skstd::forward<Args>(args)...); }
         Interface* clone() const override { return SkNEW_ARGS(LambdaImpl<Fn>, (fFn)); }
     private:
         Fn fFn;
     };
 
     class FnPtrImpl final : public Interface {
     public:
         FnPtrImpl(R (*fn)(Args...)) : fFn(fn) {}
 
-        R call(Args... args) const override { return fFn(Forward(args)...); }
+        R call(Args... args) const override { return fFn(skstd::forward<Args>(args)...); }
         Interface* clone() const override { return SkNEW_ARGS(FnPtrImpl, (fFn)); }
     private:
         R (*fFn)(Args...);
     };
 
     SkAutoTDelete<Interface> fFunction;
 };
 
 #endif//SkFunction_DEFINED