Merge Crashpad to the 42.0.2311 branch

base/scoped_generic.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_SCOPED_GENERIC_H_
 #define BASE_SCOPED_GENERIC_H_
 
 #include <stdlib.h>
 
 #include <algorithm>
@@ skipping 35 matching lines @@
 //
 //     // This free function will not be called if f == InvalidValue()!
 //     static void Free(int f) {
 //       ::FreeFoo(f);
 //     }
 //   };
 //
 //   typedef ScopedGeneric<int, FooScopedTraits> ScopedFoo;
 template<typename T, typename Traits>
 class ScopedGeneric {
-  MOVE_ONLY_TYPE_FOR_CPP_03(ScopedGeneric, RValue)
+  MOVE_ONLY_TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03(ScopedGeneric)
 
  private:
   // This must be first since it's used inline below.
   //
   // Use the empty base class optimization to allow us to have a D
   // member, while avoiding any space overhead for it when D is an
   // empty class.  See e.g. http://www.cantrip.org/emptyopt.html for a good
   // discussion of this technique.
   struct Data : public Traits {
     explicit Data(const T& in) : generic(in) {}
     Data(const T& in, const Traits& other) : Traits(other), generic(in) {}
     T generic;
   };
 
  public:
   typedef T element_type;
   typedef Traits traits_type;
 
   ScopedGeneric() : data_(traits_type::InvalidValue()) {}
 
   // Constructor. Takes responsibility for freeing the resource associated with
   // the object T.
   explicit ScopedGeneric(const element_type& value) : data_(value) {}
 
   // Constructor. Allows initialization of a stateful traits object.
   ScopedGeneric(const element_type& value, const traits_type& traits)
       : data_(value, traits) {
   }
 
-  // Move constructor for C++03 move emulation.
-  ScopedGeneric(RValue rvalue)
-      : data_(rvalue.object->release(), rvalue.object->get_traits()) {
+  // Move constructor. Allows initialization from a ScopedGeneric rvalue.
+  ScopedGeneric(ScopedGeneric<T, Traits>&& rvalue)
+      : data_(rvalue.release(), rvalue.get_traits()) {
   }
 
   ~ScopedGeneric() {
     FreeIfNecessary();
   }
 
+  // operator=. Allows assignment from a ScopedGeneric rvalue.
+  ScopedGeneric& operator=(ScopedGeneric<T, Traits>&& rvalue) {
+    reset(rvalue.release());
+    return *this;
+  }
+
   // Frees the currently owned object, if any. Then takes ownership of a new
   // object, if given. Self-resets are not allowd as on scoped_ptr. See
   // http://crbug.com/162971
   void reset(const element_type& value = traits_type::InvalidValue()) {
     if (data_.generic != traits_type::InvalidValue() && data_.generic == value)
       abort();
     FreeIfNecessary();
     data_.generic = value;
   }
 
@@ skipping 62 matching lines @@
 }
 
 template<class T, class Traits>
 bool operator!=(const T& value, const ScopedGeneric<T, Traits>& scoped) {
   return value != scoped.get();
 }
 
 }  // namespace base
 
 #endif  // BASE_SCOPED_GENERIC_H_