Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(509)

Unified Diff: public/platform/WebPrivateGarbageCollectedPtr.h

Issue 168963003: Make WebPrivatePtr capable of wrapping garbage collected objects. (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master
Patch Set: Qualify PassRefPtrWillBeRawPtr by its namespace, WebCore. Created 6 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: public/platform/WebPrivateGarbageCollectedPtr.h
diff --git a/public/platform/WebPrivateGarbageCollectedPtr.h b/public/platform/WebPrivateGarbageCollectedPtr.h
new file mode 100644
index 0000000000000000000000000000000000000000..e7b62cc956dfa5c748ab92431926184ac16922a2
--- /dev/null
+++ b/public/platform/WebPrivateGarbageCollectedPtr.h
@@ -0,0 +1,182 @@
+/* Copyright (c) 2014 The Chromium Authors. All rihts reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef WebPrivateGarbageCollectedPtr_h
+#define WebPrivateGarbageCollectedPtr_h
+
+#include "WebCommon.h"
+
+#if INSIDE_BLINK
+#include "heap/Handle.h"
+#include "wtf/PassRefPtr.h"
+
+// FIXME: oilpan: If the WebCore-qualified PassRefPtrWillBeRawPtr
sof 2014/02/17 15:19:10 Addressing some clang compilation breakage..referr
Mads Ager (chromium) 2014/02/17 15:23:35 How about having the define expand to a fully qual
sof 2014/02/17 15:27:40 I don't see how that would work with template alia
+// used below map to CPP #defines, move the type names it can expand
+// to into the WebCore namespace. When Oilpan is always enabled, this
+// block can be removed.
+namespace WebCore {
+using WTF::RawPtr;
+using WTF::PassRefPtr;
+}
+#endif
+
+namespace blink {
+
+// A variant of WebPrivatePtr that holds a Blink object that's garbage
+// collected, without exposing the details of how (and with what
+// types.) If no support for having such objects (i.e., no Oilpan),
+// WebPrivateGarbageCollectedPtr is equal to WebPrivatePtr and the
+// object will be reference counted.
+//
+// See WebPrivatePtr.h comment for how to make use of
+// WebPrivateGarbageCollectedPtr; same pattern applies, but for one
+// detail. Instead of declaring & defining,
+//
+// #if INSIDE_BLINK
+// WebFoo(const WTF::PassRefPtr<WebCore::Foo>&);
+// #endif
+//
+// provide
+//
+// #if INSIDE_BLINK
+// WebFoo(const WebCore::PassRefPtrWillBeRawPtr<WebCore::Foo>&);
+// #endif
+//
+template <typename T>
+class WebPrivateGarbageCollectedPtr {
+public:
+ WebPrivateGarbageCollectedPtr() : m_ptr(0) { }
+ ~WebPrivateGarbageCollectedPtr()
+ {
+ // We don't destruct the object pointed by m_ptr here because we don't
+ // want to expose destructors of core classes to embedders. We should
+ // call reset() manually in destructors of classes with WebPrivateGarbageCollectedPtr
+ // members.
+ BLINK_ASSERT(!m_ptr);
+ }
+
+ bool isNull() const { return !m_ptr; }
+
+#if INSIDE_BLINK
+#if ENABLE(OILPAN)
+ WebPrivateGarbageCollectedPtr(const WebCore::PassRefPtrWillBeRawPtr<T>& p)
+ {
+ assign(p);
+ }
+
+ void reset()
+ {
+ if (m_ptr) {
+ delete reinterpret_cast<WebCore::Persistent<T>*>(m_ptr);
+ m_ptr = 0;
+ }
+ }
+
+ WebPrivateGarbageCollectedPtr<T>& operator=(const WebPrivateGarbageCollectedPtr<T>& other)
+ {
+ assign(other.get());
+ return *this;
+ }
+
+ WebPrivateGarbageCollectedPtr<T>& operator=(const WebCore::PassRefPtrWillBeRawPtr<T>& p)
+ {
+ assign(p);
+ return *this;
+ }
+
+ T* get() const
+ {
+ if (!m_ptr)
+ return 0;
+ return (reinterpret_cast<WebCore::Persistent<T>* >(m_ptr))->get();
+ }
+
+ T* operator->() const
+ {
+ ASSERT(m_ptr);
+ return (reinterpret_cast<WebCore::Persistent<T>* >(m_ptr))->get();
+ }
+#else
+ WebPrivateGarbageCollectedPtr(const WebCore::PassRefPtrWillBeRawPtr<T>& p)
+ {
+ m_ptr = p.leakRef();
+ }
+
+ void reset()
+ {
+ assign(0);
+ }
+
+ WebPrivateGarbageCollectedPtr<T>& operator=(const WebPrivateGarbageCollectedPtr<T>& other)
+ {
+ T* p = other.m_ptr;
+ if (p)
+ p->ref();
+ assign(p);
+ return *this;
+ }
+
+ WebPrivateGarbageCollectedPtr<T>& operator=(const WebCore::PassRefPtrWillBeRawPtr<T>& p)
+ {
+ assign(p.leakRef());
+ return *this;
+ }
+
+ T* get() const
+ {
+ return m_ptr;
+ }
+
+ T* operator->() const
+ {
+ ASSERT(m_ptr);
+ return m_ptr;
+ }
+#endif
+#endif
+
+private:
+#if INSIDE_BLINK
+#if ENABLE(OILPAN)
+ void assign(T* p)
+ {
+ if (!p) {
+ reset();
+ return;
+ }
+ // Keep an opaque pointer object pointer to avoid exposing
+ // representation details.
+ if (!m_ptr)
+ m_ptr = reinterpret_cast<T*>(new WebCore::Persistent<T>(p));
+ else
+ *reinterpret_cast<WebCore::Persistent<T>*>(m_ptr) = p;
+ }
+#else
+ void assign(T* p)
+ {
+ // p is already ref'd for us by the caller
+ if (m_ptr)
+ m_ptr->deref();
+ m_ptr = p;
+ }
+#endif
+#else
+ // Disable the assignment operator; we define it above for when
+ // INSIDE_BLINK is set, but we need to make sure that it is not
+ // used outside there; the compiler-provided version won't handle reference
+ // counting properly.
+ WebPrivateGarbageCollectedPtr<T>& operator=(const WebPrivateGarbageCollectedPtr<T>& other);
+#endif
+ // Disable the copy constructor; classes that contain a
+ // WebPrivateGarbageCollectedPtr should implement their copy
+ // constructor using assign().
+ WebPrivateGarbageCollectedPtr(const WebPrivateGarbageCollectedPtr<T>&);
+
+ T* m_ptr;
+};
+
+} // namespace blink
+
+#endif

Powered by Google App Engine
This is Rietveld 408576698