Add m-esr52 at 52.6.0

1 files changed, 449 insertions, 0 deletions

diff --git a/parser/html/nsHtml5RefPtr.h b/parser/html/nsHtml5RefPtr.h
new file mode 100644
index 0000000000..bc0477ba60
--- /dev/null
+++ b/parser/html/nsHtml5RefPtr.h
@@ -0,0 +1,449 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsHtml5RefPtr_h
+#define nsHtml5RefPtr_h
+
+#include "nsThreadUtils.h"
+
+template <class T>
+class nsHtml5RefPtrReleaser : public mozilla::Runnable
+  {
+    private:
+      T* mPtr;
+    public:
+      explicit nsHtml5RefPtrReleaser(T* aPtr)
+          : mPtr(aPtr)
+        {}
+      NS_IMETHOD Run() override
+        {
+          mPtr->Release();
+          return NS_OK;
+        }
+  };
+
+// template <class T> class nsHtml5RefPtrGetterAddRefs;
+
+/**
+ * Like nsRefPtr except release is proxied to the main thread. Mostly copied
+ * from nsRefPtr.
+ */
+template <class T>
+class nsHtml5RefPtr
+  {
+    private:
+
+      void
+      assign_with_AddRef( T* rawPtr )
+        {
+          if ( rawPtr )
+            rawPtr->AddRef();
+          assign_assuming_AddRef(rawPtr);
+        }
+
+      void**
+      begin_assignment()
+        {
+          assign_assuming_AddRef(0);
+          return reinterpret_cast<void**>(&mRawPtr);
+        }
+
+      void
+      assign_assuming_AddRef( T* newPtr )
+        {
+          T* oldPtr = mRawPtr;
+          mRawPtr = newPtr;
+          if ( oldPtr )
+            release(oldPtr);
+        }
+
+      void
+      release( T* aPtr )
+        {
+          nsCOMPtr<nsIRunnable> releaser = new nsHtml5RefPtrReleaser<T>(aPtr);
+          if (NS_FAILED(NS_DispatchToMainThread(releaser))) 
+            {
+              NS_WARNING("Failed to dispatch releaser event.");
+            }
+        }
+
+    private:
+      T* mRawPtr;
+
+    public:
+      typedef T element_type;
+      
+     ~nsHtml5RefPtr()
+        {
+          if ( mRawPtr )
+            release(mRawPtr);
+        }
+
+        // Constructors
+
+      nsHtml5RefPtr()
+            : mRawPtr(0)
+          // default constructor
+        {
+        }
+
+      nsHtml5RefPtr( const nsHtml5RefPtr<T>& aSmartPtr )
+            : mRawPtr(aSmartPtr.mRawPtr)
+          // copy-constructor
+        {
+          if ( mRawPtr )
+            mRawPtr->AddRef();
+        }
+
+      explicit nsHtml5RefPtr( T* aRawPtr )
+            : mRawPtr(aRawPtr)
+          // construct from a raw pointer (of the right type)
+        {
+          if ( mRawPtr )
+            mRawPtr->AddRef();
+        }
+
+      explicit nsHtml5RefPtr( const already_AddRefed<T>& aSmartPtr )
+            : mRawPtr(aSmartPtr.mRawPtr)
+          // construct from |dont_AddRef(expr)|
+        {
+        }
+
+        // Assignment operators
+
+      nsHtml5RefPtr<T>&
+      operator=( const nsHtml5RefPtr<T>& rhs )
+          // copy assignment operator
+        {
+          assign_with_AddRef(rhs.mRawPtr);
+          return *this;
+        }
+
+      nsHtml5RefPtr<T>&
+      operator=( T* rhs )
+          // assign from a raw pointer (of the right type)
+        {
+          assign_with_AddRef(rhs);
+          return *this;
+        }
+
+      nsHtml5RefPtr<T>&
+      operator=( const already_AddRefed<T>& rhs )
+          // assign from |dont_AddRef(expr)|
+        {
+          assign_assuming_AddRef(rhs.mRawPtr);
+          return *this;
+        }
+
+        // Other pointer operators
+
+      void
+      swap( nsHtml5RefPtr<T>& rhs )
+          // ...exchange ownership with |rhs|; can save a pair of refcount operations
+        {
+          T* temp = rhs.mRawPtr;
+          rhs.mRawPtr = mRawPtr;
+          mRawPtr = temp;
+        }
+
+      void
+      swap( T*& rhs )
+          // ...exchange ownership with |rhs|; can save a pair of refcount operations
+        {
+          T* temp = rhs;
+          rhs = mRawPtr;
+          mRawPtr = temp;
+        }
+
+      already_AddRefed<T>
+      forget()
+          // return the value of mRawPtr and null out mRawPtr. Useful for
+          // already_AddRefed return values.
+        {
+          T* temp = 0;
+          swap(temp);
+          return temp;
+        }
+
+      template <typename I>
+      void
+      forget( I** rhs)
+          // Set the target of rhs to the value of mRawPtr and null out mRawPtr.
+          // Useful to avoid unnecessary AddRef/Release pairs with "out"
+          // parameters where rhs bay be a T** or an I** where I is a base class
+          // of T.
+        {
+          NS_ASSERTION(rhs, "Null pointer passed to forget!");
+          *rhs = mRawPtr;
+          mRawPtr = 0;
+        }
+
+      T*
+      get() const
+          /*
+            Prefer the implicit conversion provided automatically by |operator T*() const|.
+            Use |get()| to resolve ambiguity or to get a castable pointer.
+          */
+        {
+          return const_cast<T*>(mRawPtr);
+        }
+
+      operator T*() const
+          /*
+            ...makes an |nsHtml5RefPtr| act like its underlying raw pointer type whenever it
+            is used in a context where a raw pointer is expected.  It is this operator
+            that makes an |nsHtml5RefPtr| substitutable for a raw pointer.
+
+            Prefer the implicit use of this operator to calling |get()|, except where
+            necessary to resolve ambiguity.
+          */
+        {
+          return get();
+        }
+
+      T*
+      operator->() const MOZ_NO_ADDREF_RELEASE_ON_RETURN
+        {
+          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsHtml5RefPtr with operator->().");
+          return get();
+        }
+
+      nsHtml5RefPtr<T>*
+      get_address()
+          // This is not intended to be used by clients.  See |address_of|
+          // below.
+        {
+          return this;
+        }
+
+      const nsHtml5RefPtr<T>*
+      get_address() const
+          // This is not intended to be used by clients.  See |address_of|
+          // below.
+        {
+          return this;
+        }
+
+    public:
+      T&
+      operator*() const
+        {
+          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsHtml5RefPtr with operator*().");
+          return *get();
+        }
+
+      T**
+      StartAssignment()
+        {
+#ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
+          return reinterpret_cast<T**>(begin_assignment());
+#else
+          assign_assuming_AddRef(0);
+          return reinterpret_cast<T**>(&mRawPtr);
+#endif
+        }
+  };
+
+template <class T>
+inline
+nsHtml5RefPtr<T>*
+address_of( nsHtml5RefPtr<T>& aPtr )
+  {
+    return aPtr.get_address();
+  }
+
+template <class T>
+inline
+const nsHtml5RefPtr<T>*
+address_of( const nsHtml5RefPtr<T>& aPtr )
+  {
+    return aPtr.get_address();
+  }
+
+template <class T>
+class nsHtml5RefPtrGetterAddRefs
+    /*
+      ...
+
+      This class is designed to be used for anonymous temporary objects in the
+      argument list of calls that return COM interface pointers, e.g.,
+
+        nsHtml5RefPtr<IFoo> fooP;
+        ...->GetAddRefedPointer(getter_AddRefs(fooP))
+
+      DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_AddRefs()| instead.
+
+      When initialized with a |nsHtml5RefPtr|, as in the example above, it returns
+      a |void**|, a |T**|, or an |nsISupports**| as needed, that the
+      outer call (|GetAddRefedPointer| in this case) can fill in.
+
+      This type should be a nested class inside |nsHtml5RefPtr<T>|.
+    */
+  {
+    public:
+      explicit
+      nsHtml5RefPtrGetterAddRefs( nsHtml5RefPtr<T>& aSmartPtr )
+          : mTargetSmartPtr(aSmartPtr)
+        {
+          // nothing else to do
+        }
+
+      operator void**()
+        {
+          return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+        }
+
+      operator T**()
+        {
+          return mTargetSmartPtr.StartAssignment();
+        }
+
+      T*&
+      operator*()
+        {
+          return *(mTargetSmartPtr.StartAssignment());
+        }
+
+    private:
+      nsHtml5RefPtr<T>& mTargetSmartPtr;
+  };
+
+template <class T>
+inline
+nsHtml5RefPtrGetterAddRefs<T>
+getter_AddRefs( nsHtml5RefPtr<T>& aSmartPtr )
+    /*
+      Used around a |nsHtml5RefPtr| when 
+      ...makes the class |nsHtml5RefPtrGetterAddRefs<T>| invisible.
+    */
+  {
+    return nsHtml5RefPtrGetterAddRefs<T>(aSmartPtr);
+  }
+
+
+
+  // Comparing two |nsHtml5RefPtr|s
+
+template <class T, class U>
+inline
+bool
+operator==( const nsHtml5RefPtr<T>& lhs, const nsHtml5RefPtr<U>& rhs )
+  {
+    return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs.get());
+  }
+
+
+template <class T, class U>
+inline
+bool
+operator!=( const nsHtml5RefPtr<T>& lhs, const nsHtml5RefPtr<U>& rhs )
+  {
+    return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs.get());
+  }
+
+
+  // Comparing an |nsHtml5RefPtr| to a raw pointer
+
+template <class T, class U>
+inline
+bool
+operator==( const nsHtml5RefPtr<T>& lhs, const U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator==( const U* lhs, const nsHtml5RefPtr<T>& rhs )
+  {
+    return static_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( const nsHtml5RefPtr<T>& lhs, const U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( const U* lhs, const nsHtml5RefPtr<T>& rhs )
+  {
+    return static_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+  }
+
+template <class T, class U>
+inline
+bool
+operator==( const nsHtml5RefPtr<T>& lhs, U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) == const_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator==( U* lhs, const nsHtml5RefPtr<T>& rhs )
+  {
+    return const_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( const nsHtml5RefPtr<T>& lhs, U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) != const_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( U* lhs, const nsHtml5RefPtr<T>& rhs )
+  {
+    return const_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+  }
+
+
+
+  // Comparing an |nsHtml5RefPtr| to |0|
+
+template <class T>
+inline
+bool
+operator==( const nsHtml5RefPtr<T>& lhs, decltype(nullptr) )
+  {
+    return lhs.get() == nullptr;
+  }
+
+template <class T>
+inline
+bool
+operator==( decltype(nullptr), const nsHtml5RefPtr<T>& rhs )
+  {
+    return nullptr == rhs.get();
+  }
+
+template <class T>
+inline
+bool
+operator!=( const nsHtml5RefPtr<T>& lhs, decltype(nullptr) )
+  {
+    return lhs.get() != nullptr;
+  }
+
+template <class T>
+inline
+bool
+operator!=( decltype(nullptr), const nsHtml5RefPtr<T>& rhs )
+  {
+    return nullptr != rhs.get();
+  }
+
+#endif // !defined(nsHtml5RefPtr_h)