Oilpan: move 2D Canvas and WebGL objects to the heap.

Source/core/html/canvas/WebGLContextGroup.cpp

 /*
  * Copyright (C) 2011 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 13 matching lines @@
  */
 
 #include "config.h"
 
 #include "core/html/canvas/WebGLContextGroup.h"
 
 #include "core/html/canvas/WebGLSharedObject.h"
 
 namespace WebCore {
 
-PassRefPtr<WebGLContextGroup> WebGLContextGroup::create()
+PassRefPtrWillBeRawPtr<WebGLContextGroup> WebGLContextGroup::create()
 {
-    RefPtr<WebGLContextGroup> contextGroup = adoptRef(new WebGLContextGroup());
+    RefPtrWillBeRawPtr<WebGLContextGroup> contextGroup = adoptRefWillBeNoop(new WebGLContextGroup());
     return contextGroup.release();

[haraken, 2014/07/02 07:47:37]

return adoptRefWillBeNoop(new WebGLContextGroup());

[sof, 2014/07/02 11:43:52]

I've switched this back to returning PassRefPtr<> & left the method as-is (i.e.,
with an explicit release()).

 }
 
 WebGLContextGroup::WebGLContextGroup()
+#if ENABLE(OILPAN)
+    : m_savedContext(0)
+#endif
 {
 }
 
+#if !ENABLE(OILPAN)
 WebGLContextGroup::~WebGLContextGroup()
 {
     detachAndRemoveAllObjects();
 }
+#endif
 
 blink::WebGraphicsContext3D* WebGLContextGroup::getAWebGraphicsContext3D()
 {
+#if ENABLE(OILPAN)
+    ASSERT(!m_contexts.isEmpty() || m_savedContext);
+    if (m_savedContext)

[haraken, 2014/07/02 07:47:38]

Just help me understand: This branch hits only when WebGLContextGroup is
double-traced, right?

However, basically we want to consider a way to avoid introducing m_savedContext
(but I have no idea at the moment).

[sof, 2014/07/02 11:43:52]

Yes (to the last point), that's what I ended up with also -- having the context
group be garbage collected when all other objects depend on it for their
finalization of their resources, is either going to be hacky (like here) or not
work out at all.

Consequently, I decided to go back to having it be off-heap. Which means caching
a final 'saved context' like here to make detachment of the group objects work
out, is now no longer done. 

+        return m_savedContext;
+#else
     ASSERT(!m_contexts.isEmpty());
-    HashSet<WebGLRenderingContextBase*>::iterator it = m_contexts.begin();
+#endif
+    WillBeHeapHashSet<RawPtrWillBeWeakMember<WebGLRenderingContextBase> >::iterator it = m_contexts.begin();
     return (*it)->webContext();
 }
 
 void WebGLContextGroup::addContext(WebGLRenderingContextBase* context)
 {
     m_contexts.add(context);
 }
 
 void WebGLContextGroup::removeContext(WebGLRenderingContextBase* context)
 {
     // We must call detachAndRemoveAllObjects before removing the last context.
     if (m_contexts.size() == 1 && m_contexts.contains(context))
         detachAndRemoveAllObjects();
 
     m_contexts.remove(context);
 }
 
 void WebGLContextGroup::removeObject(WebGLSharedObject* object)
 {
+#if ENABLE(OILPAN)
+    // Oilpan: if removal happens during weak callback processing, ignore.

[haraken, 2014/07/02 07:47:38]

Specifically, when can the removal happen during weak processing?

[sof, 2014/07/02 11:43:52]

It happens when tracing has determined that no contexts survived the GC, and we
flush the group objects using detachAndRemoveAllObjects().

(This is no longer done.)

+    // Done so as to prevent re-allocation of the backing store; the table
+    // is cleared afterwards instead.
+    if (m_savedContext)
+        return;
+#endif
     m_groupObjects.remove(object);
 }
 
 void WebGLContextGroup::addObject(WebGLSharedObject* object)
 {
     m_groupObjects.add(object);
 }
 
 void WebGLContextGroup::detachAndRemoveAllObjects()
 {
     while (!m_groupObjects.isEmpty()) {
-        HashSet<WebGLSharedObject*>::iterator it = m_groupObjects.begin();
+        WillBeHeapHashSet<RawPtrWillBeWeakMember<WebGLSharedObject> >::iterator it = m_groupObjects.begin();
         (*it)->detachContextGroup();
     }
 }
 
 void WebGLContextGroup::loseContextGroup(WebGLRenderingContextBase::LostContextMode mode)
 {
     // Detach must happen before loseContextImpl, which destroys the GraphicsContext3D
     // and prevents groupObjects from being properly deleted.
     detachAndRemoveAllObjects();
 
-    for (HashSet<WebGLRenderingContextBase*>::iterator it = m_contexts.begin(); it != m_contexts.end(); ++it)
+    for (WillBeHeapHashSet<RawPtrWillBeWeakMember<WebGLRenderingContextBase> >::iterator it = m_contexts.begin(); it != m_contexts.end(); ++it)
         (*it)->loseContextImpl(mode);
 }
 
+void WebGLContextGroup::clearWeakMembers(Visitor*)
+{
+#if ENABLE(OILPAN)
+    // We must call detachAndRemoveAllObjects when there are no contexts left.
+    // In order to be able to provide the group objects with the WebGraphicsContext3D
+    // object they need on detach, one is saved away during tracing.
+    if (!m_contexts.size() && m_savedContext) {
+        detachAndRemoveAllObjects();
+        m_groupObjects.clear();
+    }
+    m_savedContext = 0;
+#endif
+}
+
+void WebGLContextGroup::trace(Visitor* visitor)
+{
+#if ENABLE(OILPAN)
+    // See clearWeakMembers() comment.
+    if (m_contexts.size() && m_groupObjects.size()) {
+        m_savedContext = getAWebGraphicsContext3D();

[haraken, 2014/07/02 07:47:37]

It looks dangerous to do something non-trivial in trace(), since trace() can be
called while the object is not fully constructed.

+        ASSERT(m_savedContext);
+    }
+#endif
+    visitor->trace(m_contexts);
+    visitor->trace(m_groupObjects);
+    visitor->registerWeakMembers<WebGLContextGroup, &WebGLContextGroup::clearWeakMembers>(this);
+}
+
 } // namespace WebCore