Start using allowed C++11 features.

third_party/base/nonstd_unique_ptr.h

 // Copyright 2013 Google Inc. All Rights Reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
@@ skipping 56 matching lines @@
 #define NONSTD_UNIQUE_PTR_H_
 
 // This is an implementation designed to match the anticipated future C++11
 // implementation of the unique_ptr class.
 
 #include <assert.h>
 #include <stddef.h>
 #include <stdlib.h>
 
 #include <ostream>
+#include <utility>
 
 #include "template_util.h"
 
 namespace nonstd {
 
-// Replacement for move, but doesn't allow things that are already
-// rvalue references.
-template <class T>
-T&& move(T& t) {
-  return static_cast<T&&>(t);
-}
-
 // Function object which deletes its parameter, which must be a pointer.
 // If C is an array type, invokes 'delete[]' on the parameter; otherwise,
 // invokes 'delete'. The default deleter for unique_ptr<T>.
 template <class T>
 struct DefaultDeleter {
   DefaultDeleter() {}
   template <typename U>
   DefaultDeleter(const DefaultDeleter<U>& other) {
     // IMPLEMENTATION NOTE: C++11 20.7.1.1.2p2 only provides this constructor
     // if U* is implicitly convertible to T* and U is not an array type.
@@ skipping 138 matching lines @@
   explicit unique_ptr(C* p) : internal::unique_ptr_base<C, D>(p) {}
 
   // Constructor.  Allows initialization of a stateful deleter.
   unique_ptr(C* p, const D& d) : internal::unique_ptr_base<C, D>(p, d) {}
 
   // Constructor.  Allows construction from a nullptr.
   unique_ptr(decltype(nullptr)) : internal::unique_ptr_base<C, D>(nullptr) {}
 
   // Move constructor.
   unique_ptr(unique_ptr&& that)
-      : internal::unique_ptr_base<C, D>(nonstd::move(that)) {}
+      : internal::unique_ptr_base<C, D>(std::move(that)) {}
 
   // operator=.  Allows assignment from a nullptr. Deletes the currently owned
   // object, if any.
   unique_ptr& operator=(decltype(nullptr)) {
     this->reset();
     return *this;
   }
 
   // Move assignment.
   unique_ptr<C>& operator=(unique_ptr<C>&& that) {
@@ skipping 52 matching lines @@
   // - it cannot be const-qualified differently from T per unique_ptr spec
   //   (http://cplusplus.github.com/LWG/lwg-active.html#2118). Users wanting
   //   to work around this may use const_cast<const T*>().
   explicit unique_ptr(C* p) : internal::unique_ptr_base<C, D>(p) {}
 
   // Constructor.  Allows construction from a nullptr.
   unique_ptr(decltype(nullptr)) : internal::unique_ptr_base<C, D>(nullptr) {}
 
   // Move constructor.
   unique_ptr(unique_ptr&& that)
-      : internal::unique_ptr_base<C, D>(nonstd::move(that)) {}
+      : internal::unique_ptr_base<C, D>(std::move(that)) {}
 
   // operator=.  Allows assignment from a nullptr. Deletes the currently owned
   // array, if any.
   unique_ptr& operator=(decltype(nullptr)) {
     this->reset();
     return *this;
   }
 
   // Move assignment.
   unique_ptr<C>& operator=(unique_ptr<C>&& that) {
@@ skipping 64 matching lines @@
 }
 
 template <typename T>
 std::ostream& operator<<(std::ostream& out, const unique_ptr<T>& p) {
   return out << p.get();
 }
 
 }  // namespace nonstd
 
 #endif  // NONSTD_UNIQUE_PTR_H_