a1dc819f892dccc0e0d8b241d20e952feafa06de
[WebKit-https.git] / WebCore / bindings / v8 / V8GCController.cpp
1 /*
2  * Copyright (C) 2009 Google Inc. All rights reserved.
3  * 
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  * 
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  * 
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32 #include "V8GCController.h"
33
34 #include "DOMDataStore.h"
35 #include "DOMObjectsInclude.h"
36 #include "V8DOMMap.h"
37 #include "V8Index.h"
38 #include "V8Proxy.h"
39
40 #include <algorithm>
41 #include <utility>
42 #include <v8.h>
43 #include <v8-debug.h>
44 #include <wtf/HashMap.h>
45 #include <wtf/StdLibExtras.h>
46 #include <wtf/UnusedParam.h>
47
48 namespace WebCore {
49
50 #ifndef NDEBUG
51 // Keeps track of global handles created (not JS wrappers
52 // of DOM objects). Often these global handles are source
53 // of leaks.
54 //
55 // If you want to let a C++ object hold a persistent handle
56 // to a JS object, you should register the handle here to
57 // keep track of leaks.
58 //
59 // When creating a persistent handle, call:
60 //
61 // #ifndef NDEBUG
62 //    V8GCController::registerGlobalHandle(type, host, handle);
63 // #endif
64 //
65 // When releasing the handle, call:
66 //
67 // #ifndef NDEBUG
68 //    V8GCController::unregisterGlobalHandle(type, host, handle);
69 // #endif
70 //
71 typedef HashMap<v8::Value*, GlobalHandleInfo*> GlobalHandleMap;
72
73 static GlobalHandleMap& globalHandleMap()
74 {
75     DEFINE_STATIC_LOCAL(GlobalHandleMap, staticGlobalHandleMap, ());
76     return staticGlobalHandleMap;
77 }
78
79 // The function is the place to set the break point to inspect
80 // live global handles. Leaks are often come from leaked global handles.
81 static void enumerateGlobalHandles()
82 {
83     for (GlobalHandleMap::iterator it = globalHandleMap().begin(), end = globalHandleMap().end(); it != end; ++it) {
84         GlobalHandleInfo* info = it->second;
85         UNUSED_PARAM(info);
86         v8::Value* handle = it->first;
87         UNUSED_PARAM(handle);
88     }
89 }
90
91 void V8GCController::registerGlobalHandle(GlobalHandleType type, void* host, v8::Persistent<v8::Value> handle)
92 {
93     ASSERT(!globalHandleMap().contains(*handle));
94     globalHandleMap().set(*handle, new GlobalHandleInfo(host, type));
95 }
96
97 void V8GCController::unregisterGlobalHandle(void* host, v8::Persistent<v8::Value> handle)
98 {
99     ASSERT(globalHandleMap().contains(*handle));
100     GlobalHandleInfo* info = globalHandleMap().take(*handle);
101     ASSERT(info->m_host == host);
102     delete info;
103 }
104 #endif // ifndef NDEBUG
105
106 typedef HashMap<Node*, v8::Object*> DOMNodeMap;
107 typedef HashMap<void*, v8::Object*> DOMObjectMap;
108
109 #ifndef NDEBUG
110
111 static void enumerateDOMObjectMap(DOMObjectMap& wrapperMap)
112 {
113     for (DOMObjectMap::iterator it = wrapperMap.begin(), end = wrapperMap.end(); it != end; ++it) {
114         v8::Persistent<v8::Object> wrapper(it->second);
115         V8ClassIndex::V8WrapperType type = V8DOMWrapper::domWrapperType(wrapper);
116         void* object = it->first;
117         UNUSED_PARAM(type);
118         UNUSED_PARAM(object);
119     }
120 }
121
122 class DOMObjectVisitor : public DOMWrapperMap<void>::Visitor {
123 public:
124     void visitDOMWrapper(void* object, v8::Persistent<v8::Object> wrapper)
125     {
126         V8ClassIndex::V8WrapperType type = V8DOMWrapper::domWrapperType(wrapper);
127         UNUSED_PARAM(type);
128         UNUSED_PARAM(object);
129     }
130 };
131
132 class EnsureWeakDOMNodeVisitor : public DOMWrapperMap<Node>::Visitor {
133 public:
134     void visitDOMWrapper(Node* object, v8::Persistent<v8::Object> wrapper)
135     {
136         UNUSED_PARAM(object);
137         ASSERT(wrapper.IsWeak());
138     }
139 };
140
141 #endif // NDEBUG
142
143 // A map from a DOM node to its JS wrapper, the wrapper
144 // is kept as a strong reference to survive GCs.
145 static DOMObjectMap& gcProtectedMap()
146 {
147     DEFINE_STATIC_LOCAL(DOMObjectMap, staticGcProtectedMap, ());
148     return staticGcProtectedMap;
149 }
150
151 void V8GCController::gcProtect(void* domObject)
152 {
153     if (!domObject)
154         return;
155     if (gcProtectedMap().contains(domObject))
156         return;
157     if (!getDOMObjectMap().contains(domObject))
158         return;
159
160     // Create a new (strong) persistent handle for the object.
161     v8::Persistent<v8::Object> wrapper = getDOMObjectMap().get(domObject);
162     if (wrapper.IsEmpty())
163         return;
164
165     gcProtectedMap().set(domObject, *v8::Persistent<v8::Object>::New(wrapper));
166 }
167
168 void V8GCController::gcUnprotect(void* domObject)
169 {
170     if (!domObject)
171         return;
172     if (!gcProtectedMap().contains(domObject))
173         return;
174
175     // Dispose the strong reference.
176     v8::Persistent<v8::Object> wrapper(gcProtectedMap().take(domObject));
177     wrapper.Dispose();
178 }
179
180 class GCPrologueVisitor : public DOMWrapperMap<void>::Visitor {
181 public:
182     void visitDOMWrapper(void* object, v8::Persistent<v8::Object> wrapper)
183     {
184         ASSERT(wrapper.IsWeak());
185         V8ClassIndex::V8WrapperType type = V8DOMWrapper::domWrapperType(wrapper);
186         switch (type) {
187 #define MAKE_CASE(TYPE, NAME)                             \
188         case V8ClassIndex::TYPE: {                    \
189             NAME* impl = static_cast<NAME*>(object);  \
190             if (impl->hasPendingActivity())           \
191                 wrapper.ClearWeak();                  \
192             break;                                    \
193         }
194     ACTIVE_DOM_OBJECT_TYPES(MAKE_CASE)
195     default:
196         ASSERT_NOT_REACHED();
197 #undef MAKE_CASE
198         }
199
200     // Additional handling of message port ensuring that entangled ports also
201     // have their wrappers entangled. This should ideally be handled when the
202     // ports are actually entangled in MessagePort::entangle, but to avoid
203     // forking MessagePort.* this is postponed to GC time. Having this postponed
204     // has the drawback that the wrappers are "entangled/unentangled" for each
205     // GC even though their entaglement most likely is still the same.
206     if (type == V8ClassIndex::MESSAGEPORT) {
207         // Get the port and its entangled port.
208         MessagePort* port1 = static_cast<MessagePort*>(object);
209         MessagePort* port2 = port1->locallyEntangledPort();
210
211         // If we are remotely entangled, then mark this object as reachable
212         // (we can't determine reachability directly as the remote object is
213         // out-of-proc).
214         if (port1->isEntangled() && !port2)
215             wrapper.ClearWeak();
216
217         if (port2) {
218             // As ports are always entangled in pairs only perform the entanglement
219             // once for each pair (see ASSERT in MessagePort::unentangle()).
220             if (port1 < port2) {
221                 v8::Handle<v8::Value> port1Wrapper = V8DOMWrapper::jsWrapperForActiveDOMObject(port1);
222                 v8::Handle<v8::Value> port2Wrapper = V8DOMWrapper::jsWrapperForActiveDOMObject(port2);
223                 ASSERT(port1Wrapper->IsObject());
224                 v8::Handle<v8::Object>::Cast(port1Wrapper)->SetInternalField(V8Custom::kMessagePortEntangledPortIndex, port2Wrapper);
225                 ASSERT(port2Wrapper->IsObject());
226                 v8::Handle<v8::Object>::Cast(port2Wrapper)->SetInternalField(V8Custom::kMessagePortEntangledPortIndex, port1Wrapper);
227             }
228         } else {
229             // Remove the wrapper entanglement when a port is not entangled.
230             if (V8DOMWrapper::domObjectHasJSWrapper(port1)) {
231                 v8::Handle<v8::Value> wrapper = V8DOMWrapper::jsWrapperForActiveDOMObject(port1);
232                 ASSERT(wrapper->IsObject());
233                 v8::Handle<v8::Object>::Cast(wrapper)->SetInternalField(V8Custom::kMessagePortEntangledPortIndex, v8::Undefined());
234             }
235         }
236     }
237 }
238 };
239
240 class GrouperItem {
241 public:
242     GrouperItem(uintptr_t groupId, Node* node, v8::Persistent<v8::Object> wrapper) 
243         : m_groupId(groupId)
244         , m_node(node)
245         , m_wrapper(wrapper) 
246         {
247         }
248
249     uintptr_t groupId() const { return m_groupId; }
250     Node* node() const { return m_node; }
251     v8::Persistent<v8::Object> wrapper() const { return m_wrapper; }
252
253 private:
254     uintptr_t m_groupId;
255     Node* m_node;
256     v8::Persistent<v8::Object> m_wrapper;
257 };
258
259 bool operator<(const GrouperItem& a, const GrouperItem& b)
260 {
261     return a.groupId() < b.groupId();
262 }
263
264 typedef Vector<GrouperItem> GrouperList;
265
266 class ObjectGrouperVisitor : public DOMWrapperMap<Node>::Visitor {
267 public:
268     ObjectGrouperVisitor()
269     {
270         // FIXME: grouper_.reserveCapacity(node_map.size());  ?
271     }
272
273     void visitDOMWrapper(Node* node, v8::Persistent<v8::Object> wrapper)
274     {
275
276         // If the node is in document, put it in the ownerDocument's object group.
277         //
278         // If an image element was created by JavaScript "new Image",
279         // it is not in a document. However, if the load event has not
280         // been fired (still onloading), it is treated as in the document.
281         //
282         // Otherwise, the node is put in an object group identified by the root
283         // element of the tree to which it belongs.
284         uintptr_t groupId;
285         if (node->inDocument() || (node->hasTagName(HTMLNames::imgTag) && !static_cast<HTMLImageElement*>(node)->haveFiredLoadEvent()))
286             groupId = reinterpret_cast<uintptr_t>(node->document());
287         else {
288             Node* root = node;
289             while (root->parent())
290                 root = root->parent();
291
292             // If the node is alone in its DOM tree (doesn't have a parent or any
293             // children) then the group will be filtered out later anyway.
294             if (root == node && !node->hasChildNodes())
295                 return;
296
297             groupId = reinterpret_cast<uintptr_t>(root);
298         }
299         m_grouper.append(GrouperItem(groupId, node, wrapper));
300     }
301
302     void applyGrouping()
303     {
304         // Group by sorting by the group id.
305         std::sort(m_grouper.begin(), m_grouper.end());
306
307         // FIXME Should probably work in iterators here, but indexes were easier for my simple mind.
308         for (size_t i = 0; i < m_grouper.size(); ) {
309             // Seek to the next key (or the end of the list).
310             size_t nextKeyIndex = m_grouper.size();
311             for (size_t j = i; j < m_grouper.size(); ++j) {
312                 if (m_grouper[i].groupId() != m_grouper[j].groupId()) {
313                     nextKeyIndex = j;
314                     break;
315                 }
316             }
317
318             ASSERT(nextKeyIndex > i);
319
320             // We only care about a group if it has more than one object. If it only
321             // has one object, it has nothing else that needs to be kept alive.
322             if (nextKeyIndex - i <= 1) {
323                 i = nextKeyIndex;
324                 continue;
325             }
326
327             Vector<v8::Persistent<v8::Value> > group;
328             group.reserveCapacity(nextKeyIndex - i);
329             for (; i < nextKeyIndex; ++i) {
330                 v8::Persistent<v8::Value> wrapper = m_grouper[i].wrapper();
331                 if (!wrapper.IsEmpty())
332                     group.append(wrapper);
333                 /* FIXME: Re-enabled this code to avoid GCing these wrappers!
334                              Currently this depends on looking up the wrapper
335                              during a GC, but we don't know which isolated world
336                              we're in, so it's unclear which map to look in...
337
338                 // If the node is styled and there is a wrapper for the inline
339                 // style declaration, we need to keep that style declaration
340                 // wrapper alive as well, so we add it to the object group.
341                 if (node->isStyledElement()) {
342                   StyledElement* element = reinterpret_cast<StyledElement*>(node);
343                   CSSStyleDeclaration* style = element->inlineStyleDecl();
344                   if (style != NULL) {
345                     wrapper = getDOMObjectMap().get(style);
346                     if (!wrapper.IsEmpty())
347                       group.append(wrapper);
348                   }
349                 }
350                 */
351             }
352
353             if (group.size() > 1)
354                 v8::V8::AddObjectGroup(&group[0], group.size());
355
356             ASSERT(i == nextKeyIndex);
357         }
358     }
359
360 private:
361     GrouperList m_grouper;
362 };
363
364 // Create object groups for DOM tree nodes.
365 void V8GCController::gcPrologue()
366 {
367     v8::HandleScope scope;
368
369 #ifndef NDEBUG
370     DOMObjectVisitor domObjectVisitor;
371     visitDOMObjectsInCurrentThread(&domObjectVisitor);
372 #endif
373
374     // Run through all objects with possible pending activity making their
375     // wrappers non weak if there is pending activity.
376     GCPrologueVisitor prologueVisitor;
377     visitActiveDOMObjectsInCurrentThread(&prologueVisitor);
378
379     // Create object groups.
380     ObjectGrouperVisitor objectGrouperVisitor;
381     visitDOMNodesInCurrentThread(&objectGrouperVisitor);
382     objectGrouperVisitor.applyGrouping();
383 }
384
385 class GCEpilogueVisitor : public DOMWrapperMap<void>::Visitor {
386 public:
387     void visitDOMWrapper(void* object, v8::Persistent<v8::Object> wrapper)
388     {
389         V8ClassIndex::V8WrapperType type = V8DOMWrapper::domWrapperType(wrapper);
390         switch (type) {
391 #define MAKE_CASE(TYPE, NAME)                                                   \
392         case V8ClassIndex::TYPE: {                                              \
393           NAME* impl = static_cast<NAME*>(object);                              \
394           if (impl->hasPendingActivity()) {                                     \
395             ASSERT(!wrapper.IsWeak());                                          \
396             wrapper.MakeWeak(impl, &DOMDataStore::weakActiveDOMObjectCallback); \
397           }                                                                     \
398           break;                                                                \
399         }
400 ACTIVE_DOM_OBJECT_TYPES(MAKE_CASE)
401         default:
402             ASSERT_NOT_REACHED();
403 #undef MAKE_CASE
404         }
405
406         if (type == V8ClassIndex::MESSAGEPORT) {
407             MessagePort* port1 = static_cast<MessagePort*>(object);
408             MessagePort* port2 = port1->locallyEntangledPort();
409             if (port1->isEntangled() && !port2) {
410                 // We marked this port as reachable in GCPrologueVisitor.  Undo this now since the
411                 // port could be not reachable in the future if it gets disentangled (and also
412                 // GCPrologueVisitor expects to see all handles marked as weak).
413                 wrapper.MakeWeak(port1, &DOMDataStore::weakActiveDOMObjectCallback);
414             }
415         }
416     }
417 };
418
419 void V8GCController::gcEpilogue()
420 {
421     v8::HandleScope scope;
422
423     // Run through all objects with pending activity making their wrappers weak
424     // again.
425     GCEpilogueVisitor epilogueVisitor;
426     visitActiveDOMObjectsInCurrentThread(&epilogueVisitor);
427
428 #ifndef NDEBUG
429     // Check all survivals are weak.
430     DOMObjectVisitor domObjectVisitor;
431     visitDOMObjectsInCurrentThread(&domObjectVisitor);
432
433     EnsureWeakDOMNodeVisitor weakDOMNodeVisitor;
434     visitDOMNodesInCurrentThread(&weakDOMNodeVisitor);
435
436     enumerateDOMObjectMap(gcProtectedMap());
437     enumerateGlobalHandles();
438 #endif
439 }
440
441 }  // namespace WebCore