Add nonstd::unique_ptr move assigment operator.

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 158 matching lines @@
   // this->reset(this->get()) works.
   void reset(C* p = NULL) {
     if (p != ptr_) {
       enum { type_must_be_complete = sizeof(C) };
       C* old_ptr = ptr_;
       ptr_ = p;
       delete old_ptr;
     }
   }
 
+  // Move assignment.
+  unique_ptr<C>& operator=(unique_ptr<C>&& that) {
+    if (that.ptr_ != ptr_)
+      reset(that.release());
+    return *this;
+  }
+
 private:
   // Forbid comparison of unique_ptr types.  If C2 != C, it totally doesn't
   // make sense, and if C2 == C, it still doesn't make sense because you should
   // never have the same object owned by two different unique_ptrs.
   template <class C2> bool operator==(unique_ptr<C2> const& p2) const;
   template <class C2> bool operator!=(unique_ptr<C2> const& p2) const;
 
   // Disallow evil constructors. It doesn't make sense to make a copy of
   // something that's allegedly unique.
   unique_ptr(const unique_ptr&) = delete;
@@ skipping 26 matching lines @@
   // this->reset(this->get()) works.
   void reset(C* p = NULL) {
     if (p != ptr_) {
       enum { type_must_be_complete = sizeof(C) };
       C* old_ptr = ptr_;
       ptr_ = p;
       delete[] old_ptr;
     }
   }
 
+  // Move assignment.
+  unique_ptr<C>& operator=(unique_ptr<C>&& that) {
+    if (that.ptr_ != ptr_)
+      reset(that.release());
+    return *this;
+  }
+
   // Support indexing since it is holding array.
   C& operator[] (size_t i) { return ptr_[i]; }
 
 private:
   // Forbid comparison of unique_ptr types.  If C2 != C, it totally doesn't
   // make sense, and if C2 == C, it still doesn't make sense because you should
   // never have the same object owned by two different unique_ptrs.
   template <class C2> bool operator==(unique_ptr<C2> const& p2) const;
   template <class C2> bool operator!=(unique_ptr<C2> const& p2) const;
 
@@ skipping 15 matching lines @@
 }
 
 template <class C>
 bool operator!=(C* p1, const unique_ptr<C>& p2) {
   return p1 != p2.get();
 }
 
 }  // namespace nonstd
 
 #endif  // NONSTD_UNIQUE_PTR_H_