Add (back) assignment operator overloads over Persistent<> types.

Source/platform/heap/Handle.h

 /*
  * Copyright (C) 2014 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
@@ skipping 270 matching lines @@
     Persistent(std::nullptr_t) : Parent(nullptr) { }
     Persistent(T* raw) : Parent(raw) { }
     Persistent(T& raw) : Parent(raw) { }
     Persistent(const Persistent& other) : Parent(other) { }
     template<typename U>
     Persistent(const Persistent<U>& other) : Parent(other) { }
     template<typename U>
     Persistent(const Member<U>& other) : Parent(other) { }
     template<typename U>
     Persistent(const RawPtr<U>& other) : Parent(other.get()) { }
+
+    template<typename U>
+    Persistent& operator=(U* other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>

[sof, 2015/09/12 17:26:17]

Cut&paste error - this one shouldn't be parameterized; will fix & pass along
again.

+    Persistent& operator=(std::nullptr_t)
+    {
+        Parent::operator=(nullptr);
+        return *this;
+    }
+
+    Persistent& operator=(const Persistent& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    Persistent& operator=(const Persistent<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    Persistent& operator=(const Member<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    Persistent& operator=(const RawPtr<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
 };
 
 // WeakPersistent is a way to create a weak pointer from an off-heap object
 // to an on-heap object. The m_raw is automatically cleared when the pointee
 // gets collected.
 //
 // We have to construct and destruct WeakPersistent in the same thread.
 //
 // Note that collections of WeakPersistents are not supported. Use a persistent
 // collection of WeakMembers instead.
 //
 //   HashSet<WeakPersistent<T>> m_set; // wrong
 //   PersistentHeapHashSet<WeakMember<T>> m_set; // correct
 template<typename T>
 class WeakPersistent : public PersistentBase<T, WeakPersistentConfiguration, SingleThreadPersistentConfiguration> {
     typedef PersistentBase<T, WeakPersistentConfiguration, SingleThreadPersistentConfiguration> Parent;
 public:
     WeakPersistent() : Parent() { }
     WeakPersistent(std::nullptr_t) : Parent(nullptr) { }
     WeakPersistent(T* raw) : Parent(raw) { }
     WeakPersistent(T& raw) : Parent(raw) { }
     WeakPersistent(const WeakPersistent& other) : Parent(other) { }
     template<typename U>
     WeakPersistent(const WeakPersistent<U>& other) : Parent(other) { }
     template<typename U>
     WeakPersistent(const Member<U>& other) : Parent(other) { }
     template<typename U>
     WeakPersistent(const RawPtr<U>& other) : Parent(other.get()) { }
+
+    template<typename U>
+    WeakPersistent& operator=(U* other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    WeakPersistent& operator=(std::nullptr_t)
+    {
+        Parent::operator=(nullptr);
+        return *this;
+    }
+
+    WeakPersistent& operator=(const WeakPersistent& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    WeakPersistent& operator=(const WeakPersistent<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    WeakPersistent& operator=(const Member<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    WeakPersistent& operator=(const RawPtr<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
 };
 
 // Unlike Persistent, we can destruct a CrossThreadPersistent in a thread
 // different from the construction thread.
 template<typename T>
 class CrossThreadPersistent : public PersistentBase<T, NonWeakPersistentConfiguration, CrossThreadPersistentConfiguration> {
     typedef PersistentBase<T, NonWeakPersistentConfiguration, CrossThreadPersistentConfiguration> Parent;
 public:
     CrossThreadPersistent() : Parent() { }
     CrossThreadPersistent(std::nullptr_t) : Parent(nullptr) { }
     CrossThreadPersistent(T* raw) : Parent(raw) { }
     CrossThreadPersistent(T& raw) : Parent(raw) { }
     CrossThreadPersistent(const CrossThreadPersistent& other) : Parent(other) { }
     template<typename U>
     CrossThreadPersistent(const CrossThreadPersistent<U>& other) : Parent(other) { }
     template<typename U>
     CrossThreadPersistent(const Member<U>& other) : Parent(other) { }
     template<typename U>
     CrossThreadPersistent(const RawPtr<U>& other) : Parent(other.get()) { }
+
+    template<typename U>
+    CrossThreadPersistent& operator=(U* other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    CrossThreadPersistent& operator=(std::nullptr_t)
+    {
+        Parent::operator=(nullptr);
+        return *this;
+    }
+
+    CrossThreadPersistent& operator=(const CrossThreadPersistent& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    CrossThreadPersistent& operator=(const CrossThreadPersistent<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    CrossThreadPersistent& operator=(const Member<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    CrossThreadPersistent& operator=(const RawPtr<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
 };
 
 // Combines the behavior of CrossThreadPersistent and WeakPersistent.
 template<typename T>
 class CrossThreadWeakPersistent : public PersistentBase<T, WeakPersistentConfiguration, CrossThreadPersistentConfiguration> {
     typedef PersistentBase<T, WeakPersistentConfiguration, CrossThreadPersistentConfiguration> Parent;
 public:
     CrossThreadWeakPersistent() : Parent() { }
     CrossThreadWeakPersistent(std::nullptr_t) : Parent(nullptr) { }
     CrossThreadWeakPersistent(T* raw) : Parent(raw) { }
     CrossThreadWeakPersistent(T& raw) : Parent(raw) { }
     CrossThreadWeakPersistent(const CrossThreadWeakPersistent& other) : Parent(other) { }
     template<typename U>
     CrossThreadWeakPersistent(const CrossThreadWeakPersistent<U>& other) : Parent(other) { }
     template<typename U>
     CrossThreadWeakPersistent(const Member<U>& other) : Parent(other) { }
     template<typename U>
     CrossThreadWeakPersistent(const RawPtr<U>& other) : Parent(other.get()) { }
+
+    template<typename U>
+    CrossThreadWeakPersistent& operator=(U* other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    CrossThreadWeakPersistent& operator=(std::nullptr_t)
+    {
+        Parent::operator=(nullptr);
+        return *this;
+    }
+
+    CrossThreadWeakPersistent& operator=(const CrossThreadWeakPersistent& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    CrossThreadWeakPersistent& operator=(const CrossThreadWeakPersistent<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    CrossThreadWeakPersistent& operator=(const Member<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    CrossThreadWeakPersistent& operator=(const RawPtr<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
 };
 
 template<typename Collection>
 class PersistentHeapCollectionBase : public Collection {
     // We overload the various new and delete operators with using the WTF DefaultAllocator to ensure persistent
     // heap collections are always allocated off-heap. This allows persistent collections to be used in
     // DEFINE_STATIC_LOCAL et. al.
     WTF_USE_ALLOCATOR(PersistentHeapCollectionBase, WTF::DefaultAllocator);
 public:
     PersistentHeapCollectionBase()
@@ skipping 843 matching lines @@
     // TODO(sof): extend WTF::FunctionWrapper call overloading to also handle (CrossThread)WeakPersistent.
     static T* unwrap(const StorageType& value) { return value.get(); }
 };
 
 template<typename T>
 PassRefPtr<T> adoptRef(blink::RefCountedGarbageCollected<T>*) = delete;
 
 } // namespace WTF
 
 #endif