Issue 4125 - [emscripten] Convert filter classes to C++

compiled/intrusive_ptr.h

 // Parts of this code have been copied from boost/smart_ptr/intrusive_ptr.hpp.
 //
 //  Copyright (c) 2001, 2002 Peter Dimov
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef ADBLOCK_PLUS_INTRUSIVE_PTR_H
-#define ADBLOCK_PLUS_INTRUSIVE_PTR_H
-
+#pragma once
+
+#include <algorithm>
 #include <type_traits>
+
+#include "debug.h"
 
 class ref_counted
 {
 public:
   void AddRef()
   {
     mRefCount++;
   }
 
   void ReleaseRef()
   {
+    assert(mRefCount > 0, u"Unexpected zero or negative reference count"_str);
     if (--mRefCount == 0)

[René Jeschke, 2016/02/02 11:11:23]

Nit: having a check on `0` here feels wrong and may lead to unwanted behaviour
if one tries to release a `0` ref. I suggest using `--mRefCount <= 0`.

[Wladimir Palant, 2016/02/02 17:55:19]

It's quite the opposite I think - if we are already in the destructor (mRefCount
is 0) and somebody releases the ref again by mistake we won't delete a second
time. Either way, ref count dropping below 0 is always a bug - not sure whether
we can do anything sane in that case, other than crashing maybe.

       delete this;
   }
 
 protected:
   ref_counted()
-      : mRefCount(0)
-  {
-  }
-
-  // We need this virtual destructor, otherwise pointers to ref_counted and
-  // pointers to derived classes won't have the same value (e.g. converting from
-  // Filter* to ref_counted* decreases pointer value by 4).
+      : mRefCount(1)
+  {
+  }
+
   virtual ~ref_counted()
   {
+    assert(mRefCount == 0, u"Destroying a ref-counted object with a non-zero reference count"_str);
   }
 
 private:
   int mRefCount;
 };
 
-template<class T,
+template<typename T,
     class = typename std::enable_if<std::is_base_of<ref_counted,T>::value>::type>
 class intrusive_ptr
 {
 public:
-  intrusive_ptr()
+  explicit intrusive_ptr()
       : mPointer(nullptr)
   {
   }
 
-  intrusive_ptr(T* pointer)
+  explicit intrusive_ptr(T* pointer)
       : mPointer(pointer)
+  {
+    // Raw pointers always had their reference count increased by whatever gave
+    // us the pointer so we don't need to do it here.
+  }
+
+  intrusive_ptr(const intrusive_ptr& other)
+      : mPointer(other.mPointer)
   {
     if (mPointer)
       mPointer->AddRef();
   }
 
-  intrusive_ptr(const intrusive_ptr& other)
-      : mPointer(other.mPointer)
-  {
-    if (mPointer)
-      mPointer->AddRef();
-  }
-
   intrusive_ptr(intrusive_ptr&& other)
       : mPointer(other.mPointer)
   {
     other.mPointer = nullptr;
   }
 
   ~intrusive_ptr()
   {
     if (mPointer)
       mPointer->ReleaseRef();
   }
 
   intrusive_ptr& operator=(intrusive_ptr& other)
   {
     intrusive_ptr(other).swap(*this);
     return *this;
   }
 
   intrusive_ptr& operator=(intrusive_ptr&& other)
   {
+    intrusive_ptr(std::move(other)).swap(*this);
+    return *this;
+  }
+
+  intrusive_ptr& operator=(T* other)
+  {
     intrusive_ptr(other).swap(*this);
     return *this;
   }
 
-  intrusive_ptr& operator=(T* other)
+  void reset()
+  {
+    intrusive_ptr().swap(*this);
+  }
+
+  void reset(T* other)
   {
     intrusive_ptr(other).swap(*this);
   }
 
-  void reset()
-  {
-    intrusive_ptr().swap(*this);
-  }
-
-  void reset(T* other)
-  {
-    intrusive_ptr(other).swap(*this);
-  }
-
-  T* get() const
-  {
-    return mPointer;
-  }
-
-  T& operator*() const
+  const T* get() const
+  {
+    return mPointer;
+  }
+
+  T* get()
+  {
+    return mPointer;
+  }
+
+  const T& operator*() const
   {
     return *mPointer;
   }
 
-  T* operator->() const
-  {
-    return mPointer;
-  }
-
-  operator bool() const
+  T& operator*()
+  {
+    return *mPointer;
+  }
+
+  const T* operator->() const
+  {
+    return mPointer;
+  }
+
+  T* operator->()
+  {
+    return mPointer;
+  }
+
+  explicit operator bool() const
   {
     return mPointer != nullptr;
   }
 
-  operator T*() const
-  {
-    return mPointer;
-  }
-
   bool operator!() const
   {
     return mPointer == nullptr;
   }
 
+  T* release()
+  {
+    T* result = mPointer;
+    mPointer = nullptr;
+    return result;
+  }
+
   void swap(intrusive_ptr& other)
   {
-    T* tmp = mPointer;

[René Jeschke, 2016/02/02 11:11:24]

Nit: is there a specific reason why you're not using `std::swap` here?

[Wladimir Palant, 2016/02/02 17:55:19]

You have to ask Boost devs :)

I haven't heard about std::swap() before but I'll happily use it now.

-    mPointer = other.mPointer;
-    other.mPointer = tmp;
+    std::swap(mPointer, other.mPointer);
   }
 
 private:
   T* mPointer;
 };
 
-template<class T, class U>
+template<typename T, typename U>
 inline bool operator==(const intrusive_ptr<T>& a, const intrusive_ptr<U>& b)
 {
   return a.get() == b.get();
 }
 
-template<class T, class U>
+template<typename T, typename U>
 inline bool operator!=(const intrusive_ptr<T>& a, const intrusive_ptr<U>& b)
 {
   return a.get() != b.get();
 }
 
-template<class T, class U>
+template<typename T, typename U>
 inline bool operator==(const intrusive_ptr<T>& a, const U* b)
 {
   return a.get() == b;
 }
 
-template<class T, class U>
+template<typename T, typename U>
 inline bool operator!=(const intrusive_ptr<T>& a, const U* b)
 {
     return a.get() != b;
 }
 
-template<class T, class U>
+template<typename T, typename U>
 inline bool operator==(const T* a, const intrusive_ptr<U>& b)
 {
   return a == b.get();
 }
 
-template<class T, class U>
+template<typename T, typename U>
 inline bool operator!=(const T* a, intrusive_ptr<U> const& b)
 {
   return a != b.get();
 }
-
-#endif