Remove RawPtr.h

third_party/WebKit/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 25 matching lines @@
 #include "platform/heap/InlinedGlobalMarkingVisitor.h"
 #include "platform/heap/PersistentNode.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/heap/TraceTraits.h"
 #include "platform/heap/Visitor.h"
 #include "wtf/Allocator.h"
 #include "wtf/Atomics.h"
 #include "wtf/Functional.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/Locker.h"
-#include "wtf/RawPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/TypeTraits.h"
 
 #if defined(LEAK_SANITIZER)
 #include "wtf/LeakAnnotations.h"
 #endif
 
 namespace blink {
 
 // Marker used to annotate persistent objects and collections with,
@@ skipping 54 matching lines @@
         checkPointer();
     }
 
     template<typename U>
     PersistentBase(const Member<U>& other) : m_raw(other)
     {
         initialize();
         checkPointer();
     }
 
-    template<typename U>
-    PersistentBase(const RawPtr<U>& other) : m_raw(other.get())
-    {
-        initialize();
-        checkPointer();
-    }
-
     ~PersistentBase()
     {
         uninitialize();
         m_raw = nullptr;
     }
 
     template<typename VisitorDispatcher>
     void trace(VisitorDispatcher visitor)
     {
         static_assert(sizeof(T), "T must be fully defined");
         static_assert(IsGarbageCollectedType<T>::value, "T needs to be a garbage collected object");
         if (weaknessConfiguration == WeakPersistentConfiguration) {
             visitor->registerWeakCell(&m_raw);
         } else {
             visitor->mark(m_raw);
         }
     }
 
     T* release()
     {
         T* result = m_raw;
         assign(nullptr);
         return result;
     }
 
     void clear() { assign(nullptr); }
     T& operator*() const { return *m_raw; }
     bool operator!() const { return !m_raw; }
     operator T*() const { return m_raw; }
-    operator RawPtr<T>() const { return m_raw; }
     T* operator->() const { return *this; }
     T* get() const { return m_raw; }
 
     template<typename U>
     PersistentBase& operator=(U* other)
     {
         assign(other);
         return *this;
     }
 
@@ skipping 16 matching lines @@
         return *this;
     }
 
     template<typename U>
     PersistentBase& operator=(const Member<U>& other)
     {
         assign(other);
         return *this;
     }
 
-    template<typename U>
-    PersistentBase& operator=(const RawPtr<U>& other)
-    {
-        assign(other);
-        return *this;
-    }
-
 #if defined(LEAK_SANITIZER)
     PersistentBase* registerAsStaticReference()
     {
         if (m_persistentNode) {
             ASSERT(ThreadState::current());
             ThreadState::current()->registerStaticPersistentNode(m_persistentNode);
             LEAK_SANITIZER_IGNORE_OBJECT(this);
         }
         return this;
     }
@@ skipping 95 matching lines @@
 public:
     Persistent() : Parent() { }
     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;
     }
 
     Persistent& operator=(std::nullptr_t)
     {
@@ skipping 13 matching lines @@
         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;
     }
 
     WeakPersistent& operator=(std::nullptr_t)
     {
@@ skipping 13 matching lines @@
         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()) { }
 
     T* atomicGet() { return Parent::atomicGet(); }
 
     template<typename U>
     CrossThreadPersistent& operator=(U* other)
     {
         Parent::operator=(other);
         return *this;
     }
 
@@ skipping 15 matching lines @@
         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;
     }
 
     CrossThreadWeakPersistent& operator=(std::nullptr_t)
     {
@@ skipping 13 matching lines @@
         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 PartitionAllocator 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::PartitionAllocator);
     IS_PERSISTENT_REFERENCE_TYPE();
 public:
@@ skipping 169 matching lines @@
     Member(T* raw) : m_raw(raw)
     {
         checkPointer();
     }
 
     explicit Member(T& raw) : m_raw(&raw)
     {
         checkPointer();
     }
 
-    template<typename U>
-    Member(const RawPtr<U>& other) : m_raw(other.get())
-    {
-        checkPointer();
-    }
-
     Member(WTF::HashTableDeletedValueType) : m_raw(reinterpret_cast<T*>(-1))
     {
     }
 
     bool isHashTableDeletedValue() const { return m_raw == reinterpret_cast<T*>(-1); }
 
     template<typename U>
     Member(const Persistent<U>& other) : m_raw(other)
     {
         checkPointer();
@@ skipping 16 matching lines @@
         m_raw = nullptr;
         return result;
     }
 
     bool operator!() const { return !m_raw; }
 
     operator T*() const { return m_raw; }
 
     T* operator->() const { return m_raw; }
     T& operator*() const { return *m_raw; }
-    template<typename U>
-    operator RawPtr<U>() const { return m_raw; }
 
     template<typename U>
     Member& operator=(const Persistent<U>& other)
     {
         m_raw = other;
         checkPointer();
         return *this;
     }
 
     template<typename U>
     Member& operator=(const Member<U>& other)
     {
         m_raw = other;
         checkPointer();
         return *this;
     }
 
     template<typename U>
     Member& operator=(U* other)
     {
         m_raw = other;
         checkPointer();
         return *this;
     }
 
-    template<typename U>
-    Member& operator=(RawPtr<U> other)
-    {
-        m_raw = other;
-        checkPointer();
-        return *this;
-    }
-
     Member& operator=(std::nullptr_t)
     {
         m_raw = nullptr;
         return *this;
     }
 
     void swap(Member<T>& other)
     {
         std::swap(m_raw, other.m_raw);
         checkPointer();
@@ skipping 79 matching lines @@
     }
 
     template<typename U>
     WeakMember& operator=(U* other)
     {
         this->m_raw = other;
         this->checkPointer();
         return *this;
     }
 
-    template<typename U>
-    WeakMember& operator=(const RawPtr<U>& other)
-    {
-        this->m_raw = other;
-        this->checkPointer();
-        return *this;
-    }
-
     WeakMember& operator=(std::nullptr_t)
     {
         this->m_raw = nullptr;
         return *this;
     }
 
 private:
     T** cell() const { return const_cast<T**>(&this->m_raw); }
 
     template<typename Derived> friend class VisitorHelper;
@@ skipping 10 matching lines @@
 template<typename T>
 class UntracedMember final : public Member<T> {
 public:
     UntracedMember() : Member<T>() { }
 
     UntracedMember(std::nullptr_t) : Member<T>(nullptr) { }
 
     UntracedMember(T* raw) : Member<T>(raw) { }
 
     template<typename U>
-    UntracedMember(const RawPtr<U>& other) : Member<T>(other) { }
-
-    template<typename U>
     UntracedMember(const Persistent<U>& other) : Member<T>(other) { }
 
     template<typename U>
     UntracedMember(const Member<U>& other) : Member<T>(other) { }
 
     UntracedMember(WTF::HashTableDeletedValueType x) : Member<T>(x) { }
 
     template<typename U>
     UntracedMember& operator=(const Persistent<U>& other)
     {
@@ skipping 11 matching lines @@
     }
 
     template<typename U>
     UntracedMember& operator=(U* other)
     {
         this->m_raw = other;
         this->checkPointer();
         return *this;
     }
 
-    template<typename U>
-    UntracedMember& operator=(const RawPtr<U>& other)
-    {
-        this->m_raw = other;
-        this->checkPointer();
-        return *this;
-    }
-
     UntracedMember& operator=(std::nullptr_t)
     {
         this->m_raw = nullptr;
         return *this;
     }
 };
 
 // Comparison operators between (Weak)Members, Persistents, and UntracedMembers.
 template<typename T, typename U> inline bool operator==(const Member<T>& a, const Member<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Member<T>& a, const Member<U>& b) { return a.get() != b.get(); }
 template<typename T, typename U> inline bool operator==(const Persistent<T>& a, const Persistent<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Persistent<T>& a, const Persistent<U>& b) { return a.get() != b.get(); }
 
 template<typename T, typename U> inline bool operator==(const Member<T>& a, const Persistent<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Member<T>& a, const Persistent<U>& b) { return a.get() != b.get(); }
 template<typename T, typename U> inline bool operator==(const Persistent<T>& a, const Member<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Persistent<T>& a, const Member<U>& b) { return a.get() != b.get(); }
 
 template<typename T, bool = IsGarbageCollectedType<T>::value>
 class RawPtrOrMemberTrait {
     STATIC_ONLY(RawPtrOrMemberTrait)
 public:
-    using Type = RawPtr<T>;
+    using Type = T*;
 };
 
 template<typename T>
 class RawPtrOrMemberTrait<T, true> {
     STATIC_ONLY(RawPtrOrMemberTrait)
 public:
     using Type = Member<T>;
 };
 
 // Abstraction for injecting calls to an object's 'dispose()' method
@@ skipping 230 matching lines @@
     static T* unwrap(const StorageType& value) { return value.get(); }
 };
 
 template<typename T>
 struct ParamStorageTraits<T*> : public PointerParamStorageTraits<T*, blink::IsGarbageCollectedType<T>::value> {
     STATIC_ONLY(ParamStorageTraits);
     static_assert(sizeof(T), "T must be fully defined");
 };
 
 template<typename T>
-struct ParamStorageTraits<RawPtr<T>> : public PointerParamStorageTraits<T*, blink::IsGarbageCollectedType<T>::value> {
-    STATIC_ONLY(ParamStorageTraits);
-    static_assert(sizeof(T), "T must be fully defined");
-};
-
-template<typename T>
 struct ParamStorageTraits<blink::WeakPersistentThisPointer<T>> {
     STATIC_ONLY(ParamStorageTraits);
     static_assert(sizeof(T), "T must be fully defined");
     using StorageType = blink::WeakPersistent<T>;
 
     static StorageType wrap(const blink::WeakPersistentThisPointer<T>& value) { return value.value(); }
 
     // WTF::FunctionWrapper<> handles WeakPtr<>, so recast this weak persistent
     // into it.
     //
@@ skipping 14 matching lines @@
     // into it.
     //
     // TODO(sof): remove this hack once wtf/Functional.h can also work with a type like
     // CrossThreadWeakPersistent<>.
     static WeakPtr<T> unwrap(const StorageType& value) { return WeakPtr<T>(WeakReference<T>::create(value.get())); }
 };
 
 } // namespace WTF
 
 #endif