Move WebCore into Source
[WebKit-https.git] / Source / WebCore / bridge / runtime_root.cpp
1 /*
2  * Copyright (C) 2004 Apple Computer, 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
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "runtime_root.h"
28
29 #include "Bridge.h"
30 #include "runtime_object.h"
31 #include <runtime/JSGlobalObject.h>
32 #include <wtf/HashCountedSet.h>
33 #include <wtf/HashSet.h>
34 #include <wtf/StdLibExtras.h>
35
36 namespace JSC { namespace Bindings {
37
38 // This code attempts to solve two problems: (1) plug-ins leaking references to 
39 // JS and the DOM; (2) plug-ins holding stale references to JS and the DOM. Previous 
40 // comments in this file claimed that problem #1 was an issue in Java, in particular, 
41 // because Java, allegedly, didn't always call finalize when collecting an object.
42
43 typedef HashSet<RootObject*> RootObjectSet;
44
45 static RootObjectSet* rootObjectSet()
46 {
47     DEFINE_STATIC_LOCAL(RootObjectSet, staticRootObjectSet, ());
48     return &staticRootObjectSet;
49 }
50
51 // FIXME:  These two functions are a potential performance problem.  We could 
52 // fix them by adding a JSObject to RootObject dictionary.
53
54 RootObject* findProtectingRootObject(JSObject* jsObject)
55 {
56     RootObjectSet::const_iterator end = rootObjectSet()->end();
57     for (RootObjectSet::const_iterator it = rootObjectSet()->begin(); it != end; ++it) {
58         if ((*it)->gcIsProtected(jsObject))
59             return *it;
60     }
61     return 0;
62 }
63
64 RootObject* findRootObject(JSGlobalObject* globalObject)
65 {
66     RootObjectSet::const_iterator end = rootObjectSet()->end();
67     for (RootObjectSet::const_iterator it = rootObjectSet()->begin(); it != end; ++it) {
68         if ((*it)->globalObject() == globalObject)
69             return *it;
70     }
71     return 0;
72 }
73
74 RootObject::InvalidationCallback::~InvalidationCallback()
75 {
76 }
77
78 PassRefPtr<RootObject> RootObject::create(const void* nativeHandle, JSGlobalObject* globalObject)
79 {
80     return adoptRef(new RootObject(nativeHandle, globalObject));
81 }
82
83 RootObject::RootObject(const void* nativeHandle, JSGlobalObject* globalObject)
84     : m_isValid(true)
85     , m_nativeHandle(nativeHandle)
86     , m_globalObject(globalObject)
87 {
88     ASSERT(globalObject);
89     rootObjectSet()->add(this);
90 }
91
92 RootObject::~RootObject()
93 {
94     if (m_isValid)
95         invalidate();
96 }
97
98 void RootObject::invalidate()
99 {
100     if (!m_isValid)
101         return;
102
103     {
104         HashSet<RuntimeObject*>::iterator end = m_runtimeObjects.end();
105         for (HashSet<RuntimeObject*>::iterator it = m_runtimeObjects.begin(); it != end; ++it)
106             (*it)->invalidate();
107         
108         m_runtimeObjects.clear();
109     }
110     
111     m_isValid = false;
112
113     m_nativeHandle = 0;
114     m_globalObject = 0;
115
116     {
117         HashSet<InvalidationCallback*>::iterator end = m_invalidationCallbacks.end();
118         for (HashSet<InvalidationCallback*>::iterator iter = m_invalidationCallbacks.begin(); iter != end; ++iter)
119             (**iter)(this);
120
121         m_invalidationCallbacks.clear();
122     }
123
124     ProtectCountSet::iterator end = m_protectCountSet.end();
125     for (ProtectCountSet::iterator it = m_protectCountSet.begin(); it != end; ++it)
126         JSC::gcUnprotect(it->first);
127     m_protectCountSet.clear();
128
129     rootObjectSet()->remove(this);
130 }
131
132 void RootObject::gcProtect(JSObject* jsObject)
133 {
134     ASSERT(m_isValid);
135     
136     if (!m_protectCountSet.contains(jsObject))
137         JSC::gcProtect(jsObject);
138     m_protectCountSet.add(jsObject);
139 }
140
141 void RootObject::gcUnprotect(JSObject* jsObject)
142 {
143     ASSERT(m_isValid);
144     
145     if (!jsObject)
146         return;
147
148     if (m_protectCountSet.count(jsObject) == 1)
149         JSC::gcUnprotect(jsObject);
150     m_protectCountSet.remove(jsObject);
151 }
152
153 bool RootObject::gcIsProtected(JSObject* jsObject)
154 {
155     ASSERT(m_isValid);
156     return m_protectCountSet.contains(jsObject);
157 }
158
159 const void* RootObject::nativeHandle() const 
160
161     ASSERT(m_isValid);
162     return m_nativeHandle; 
163 }
164
165 JSGlobalObject* RootObject::globalObject() const
166 {
167     ASSERT(m_isValid);
168     return m_globalObject;
169 }
170
171 void RootObject::updateGlobalObject(JSGlobalObject* globalObject)
172 {
173     m_globalObject = globalObject;
174 }
175
176 void RootObject::addRuntimeObject(RuntimeObject* object)
177 {
178     ASSERT(m_isValid);
179     ASSERT(!m_runtimeObjects.contains(object));
180     
181     m_runtimeObjects.add(object);
182 }        
183     
184 void RootObject::removeRuntimeObject(RuntimeObject* object)
185 {
186     ASSERT(m_isValid);
187     ASSERT(m_runtimeObjects.contains(object));
188     
189     m_runtimeObjects.remove(object);
190 }
191
192 } } // namespace JSC::Bindings