This patch has been merged upstream. Drop next update.
Commit: ee09d4e696aa530e100b840428ab9c358032c744

Index: src/Gui/ViewProvider.h
--- src/Gui/ViewProvider.h.orig
+++ src/Gui/ViewProvider.h
@@ -87,26 +87,102 @@ enum ViewStatus
 };
 
 
+/** Convenience smart pointer to manage the lifetime of coin nodes.
+ *
+ * This class is copied from Inventor/misc/SoRefPtr.h and can be removed when the
+ * minimum supported coin version provides this header.
+ */
+template<typename T>
+class SoRefPtr
+{
+public:
+    SoRefPtr(void) noexcept
+        : ptr(NULL)
+    {}
+
+    explicit SoRefPtr(T* p)
+        : ptr(p)
+    {
+        if (this->ptr) {
+            this->ptr->ref();
+        }
+    }
+
+    SoRefPtr(const SoRefPtr& other)
+        : ptr(other.ptr)
+    {
+        if (this->ptr) {
+            this->ptr->ref();
+        }
+    }
+
+    SoRefPtr(SoRefPtr&& other) noexcept
+        : ptr(other.ptr)
+    {
+        other.ptr = NULL;
+    }
+
+    ~SoRefPtr(void)
+    {
+        if (this->ptr) {
+            this->ptr->unref();
+        }
+    }
+
+    SoRefPtr& operator=(SoRefPtr other) noexcept
+    {
+        this->swap(other);
+        return *this;
+    }
+
+    void reset(T* p = NULL)
+    {
+        SoRefPtr tmp(p);
+        this->swap(tmp);
+    }
+
+    T* get(void) const noexcept
+    {
+        return this->ptr;
+    }
+    T& operator*(void) const
+    {
+        return *this->ptr;
+    }
+    T* operator->(void) const noexcept
+    {
+        return this->ptr;
+    }
+    explicit operator bool(void) const noexcept
+    {
+        return this->ptr != NULL;
+    }
+
+    void swap(SoRefPtr& other) noexcept
+    {
+        using std::swap;
+        swap(this->ptr, other.ptr);
+    }
+
+private:
+    T* ptr;
+};
+
 /** Convenience smart pointer to wrap coin node.
  *
- * It is basically boost::intrusive plus implicit pointer conversion to save the
- * trouble of typing get() all the time.
+ * This class isn't merged with SoRefPtr because it can be removed in the future
  */
 template<class T>
-class CoinPtr: public boost::intrusive_ptr<T>
+class CoinPtr: public SoRefPtr<T>
 {
 public:
-    // Too bad, VC2013 does not support constructor inheritance
-    // using boost::intrusive_ptr<T>::intrusive_ptr;
-    using inherited = boost::intrusive_ptr<T>;
-    CoinPtr() = default;
-    CoinPtr(T* p, bool add_ref = true)
-        : inherited(p, add_ref)
-    {}
-    template<class Y>
-    CoinPtr(CoinPtr<Y> const& r)
-        : inherited(r)
-    {}
+    using SoRefPtr<T>::SoRefPtr;
+
+    CoinPtr& operator=(T* ptr)
+    {
+        SoRefPtr<T>::reset(ptr);
+        return *this;
+    }
 
     operator T*() const
     {
