Start using <type_traits> and <utility> (C++11).

include/core/SkTLazy.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkTLazy_DEFINED
 #define SkTLazy_DEFINED
 
 #include "../private/SkTemplates.h"
 #include "SkTypes.h"
 #include <new>
+#include <utility>
 
 /**
  *  Efficient way to defer allocating/initializing a class until it is needed
  *  (if ever).
  */
 template <typename T> class SkTLazy {
 public:
     SkTLazy() : fPtr(NULL) {}
 
     explicit SkTLazy(const T* src) : fPtr(NULL) {
@@ skipping 19 matching lines @@
     /**
      *  Return a pointer to an instance of the class initialized with 'args'.
      *  If a previous instance had been initialized (either from init() or
      *  set()) it will first be destroyed, so that a freshly initialized
      *  instance is always returned.
      */
     template <typename... Args> T* init(Args&&... args) {
         if (this->isValid()) {
             fPtr->~T();
         }
-        fPtr = new (SkTCast<T*>(fStorage.get())) T(skstd::forward<Args>(args)...);
+        fPtr = new (SkTCast<T*>(fStorage.get())) T(std::forward<Args>(args)...);
         return fPtr;
     }
 
     /**
      *  Copy src into this, and return a pointer to a copy of it. Note this
      *  will always return the same pointer, so if it is called on a lazy that
      *  has already been initialized, then this will copy over the previous
      *  contents.
      */
     T* set(const T& src) {
@@ skipping 97 matching lines @@
     operator const T*() const { return fObj; }
 
     const T& operator *() const { return *fObj; }
 
 private:
     const T*    fObj;
     SkTLazy<T>  fLazy;
 };
 
 #endif