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

src/core/SkFindAndPlaceGlyph.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 SkFindAndPositionGlyph_DEFINED
 #define SkFindAndPositionGlyph_DEFINED
 
 #include "SkAutoKern.h"
 #include "SkGlyph.h"
 #include "SkGlyphCache.h"
 #include "SkPaint.h"
 #include "SkTemplates.h"
 #include "SkUtils.h"
+#include <utility>
 
 // Calculate a type with the same size as the max of all the Ts.
 // This must be top level because the is no specialization of inner classes.
 template<typename... Ts> struct SkMaxSizeOf;
 
 template<>
 struct SkMaxSizeOf<> {
     static const size_t value = 0;
 };
 
@@ skipping 57 matching lines @@
         UntaggedVariant(UntaggedVariant&&) = delete;
         UntaggedVariant& operator=(UntaggedVariant&&) = delete;
 
         template<typename Variant, typename... Args>
         void initialize(Args&&... args) {
             SkASSERT(sizeof(Variant) <= sizeof(fSpace));
         #if defined(_MSC_VER) && _MSC_VER < 1900
             #define alignof __alignof
         #endif
             SkASSERT(alignof(Variant) <= alignof(Space));
-            new(&fSpace) Variant(skstd::forward<Args>(args)...);
+            new(&fSpace) Variant(std::forward<Args>(args)...);
         }
 
     private:
         typedef SkAlignedSStorage<SkMaxSizeOf<Ts...>::value> Space;
         Space fSpace;
     };
 
     // PolymorphicVariant holds subclasses of Base without slicing. Ts must be subclasses of Base.
     template<typename Base, typename... Ts>
     class PolymorphicVariant {
@@ skipping 497 matching lines @@
             ProcessOneGlyph, SkPaint::kLeft_Align, kX_SkAxisAlignment> Positioner;
         HorizontalPositions positions{pos};
         TranslationMapper mapper{matrix, offset};
         Positioner positioner(glyphFinder);
         const char* cursor = text;
         const char* stop = text + byteLength;
         while (cursor < stop) {
             SkPoint mappedPoint = mapper.TranslationMapper::map(
                 positions.HorizontalPositions::nextPoint());
             positioner.Positioner::findAndPositionGlyph(
-                &cursor, mappedPoint, skstd::forward<ProcessOneGlyph>(processOneGlyph));
+                &cursor, mappedPoint, std::forward<ProcessOneGlyph>(processOneGlyph));
         }
         return;
     }
 
     PositionReader positionReader{
         [&](PositionReader::Variants* to_init) {
             if (2 == scalarsPerPosition) {
                 to_init->initialize<ArbitraryPositions>(pos);
             } else {
                 to_init->initialize<HorizontalPositions>(pos);
@@ skipping 51 matching lines @@
                         break;
                 }
             }
         }
     };
 
     const char* stop = text + byteLength;
     while (text < stop) {
         SkPoint mappedPoint = mapper->map(positionReader->nextPoint());
         findAndPosition->findAndPositionGlyph(
-            &text, mappedPoint, skstd::forward<ProcessOneGlyph>(processOneGlyph));
+            &text, mappedPoint, std::forward<ProcessOneGlyph>(processOneGlyph));
     }
 }
 
 template<typename ProcessOneGlyph>
 inline void SkFindAndPlaceGlyph::ProcessText(
     SkPaint::TextEncoding textEncoding, const char text[], size_t byteLength,
     SkPoint offset, const SkMatrix& matrix, SkPaint::Align textAlignment,
     SkGlyphCache* cache, ProcessOneGlyph&& processOneGlyph) {
 
     // transform the starting point
@@ skipping 23 matching lines @@
                         ProcessOneGlyph, SkPaint::kLeft_Align, kUseKerning>>(glyphFinder);
             }
         }
     };
 
     const char* stop = text + byteLength;
     SkPoint current = offset;
     while (text < stop) {
         current =
             findAndPosition->findAndPositionGlyph(
-                &text, current, skstd::forward<ProcessOneGlyph>(processOneGlyph));
+                &text, current, std::forward<ProcessOneGlyph>(processOneGlyph));
 
     }
 }
 
 #endif  // SkFindAndPositionGlyph_DEFINED