[Chromium] IndexedDB: Assertion failure when storing File objects
[WebKit-https.git] / Source / WebCore / bindings / v8 / V8DOMWrapper.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 "V8DOMWrapper.h"
33
34 #include "ArrayBufferView.h"
35 #include "DocumentLoader.h"
36 #include "EventTargetHeaders.h"
37 #include "EventTargetInterfaces.h"
38 #include "FrameLoaderClient.h"
39 #include "StylePropertySet.h"
40 #include "V8AbstractEventListener.h"
41 #include "V8Binding.h"
42 #include "V8Collection.h"
43 #include "V8EventListener.h"
44 #include "V8EventListenerList.h"
45 #include "V8HTMLCollection.h"
46 #include "V8HTMLDocument.h"
47 #include "V8HiddenPropertyName.h"
48 #include "V8Location.h"
49 #include "V8NamedNodeMap.h"
50 #include "V8NodeFilterCondition.h"
51 #include "V8NodeList.h"
52 #include "V8Proxy.h"
53 #include "V8StyleSheet.h"
54 #include "V8WorkerContextEventListener.h"
55 #include "WebGLContextAttributes.h"
56 #include "WebGLUniformLocation.h"
57 #include "WorkerContextExecutionProxy.h"
58 #include "WrapperTypeInfo.h"
59 #include <algorithm>
60 #include <utility>
61 #include <v8-debug.h>
62 #include <wtf/Assertions.h>
63 #include <wtf/OwnArrayPtr.h>
64 #include <wtf/StdLibExtras.h>
65 #include <wtf/UnusedParam.h>
66
67 namespace WebCore {
68
69 // The caller must have increased obj's ref count.
70 void V8DOMWrapper::setJSWrapperForDOMObject(void* object, v8::Persistent<v8::Object> wrapper)
71 {
72     ASSERT(V8DOMWrapper::maybeDOMWrapper(wrapper));
73     ASSERT(!domWrapperType(wrapper)->toActiveDOMObjectFunction);
74     getDOMObjectMap().set(object, wrapper);
75 }
76
77 // The caller must have increased obj's ref count.
78 void V8DOMWrapper::setJSWrapperForActiveDOMObject(void* object, v8::Persistent<v8::Object> wrapper)
79 {
80     ASSERT(V8DOMWrapper::maybeDOMWrapper(wrapper));
81     ASSERT(domWrapperType(wrapper)->toActiveDOMObjectFunction);
82     getActiveDOMObjectMap().set(object, wrapper);
83 }
84
85 // The caller must have increased node's ref count.
86 void V8DOMWrapper::setJSWrapperForDOMNode(Node* node, v8::Persistent<v8::Object> wrapper)
87 {
88     ASSERT(V8DOMWrapper::maybeDOMWrapper(wrapper));
89     if (node->isActiveNode())
90         getActiveDOMNodeMap().set(node, wrapper);
91     else
92         getDOMNodeMap().set(node, wrapper);
93 }
94
95 v8::Local<v8::Function> V8DOMWrapper::getConstructor(WrapperTypeInfo* type, v8::Handle<v8::Value> objectPrototype)
96 {
97     // A DOM constructor is a function instance created from a DOM constructor
98     // template. There is one instance per context. A DOM constructor is
99     // different from a normal function in two ways:
100     //   1) it cannot be called as constructor (aka, used to create a DOM object)
101     //   2) its __proto__ points to Object.prototype rather than
102     //      Function.prototype.
103     // The reason for 2) is that, in Safari, a DOM constructor is a normal JS
104     // object, but not a function. Hotmail relies on the fact that, in Safari,
105     // HTMLElement.__proto__ == Object.prototype.
106     v8::Handle<v8::FunctionTemplate> functionTemplate = type->getTemplate();
107     // Getting the function might fail if we're running out of
108     // stack or memory.
109     v8::TryCatch tryCatch;
110     v8::Local<v8::Function> value = functionTemplate->GetFunction();
111     if (value.IsEmpty())
112         return v8::Local<v8::Function>();
113     // Hotmail fix, see comments above.
114     if (!objectPrototype.IsEmpty())
115         value->SetPrototype(objectPrototype);
116     return value;
117 }
118
119 v8::Local<v8::Function> V8DOMWrapper::getConstructorForContext(WrapperTypeInfo* type, v8::Handle<v8::Context> context)
120 {
121     // Enter the scope for this context to get the correct constructor.
122     v8::Context::Scope scope(context);
123
124     return getConstructor(type, V8DOMWindowShell::getHiddenObjectPrototype(context));
125 }
126
127 v8::Local<v8::Function> V8DOMWrapper::getConstructor(WrapperTypeInfo* type, DOMWindow* window)
128 {
129     Frame* frame = window->frame();
130     if (!frame)
131         return v8::Local<v8::Function>();
132
133     v8::Handle<v8::Context> context = V8Proxy::context(frame);
134     if (context.IsEmpty())
135         return v8::Local<v8::Function>();
136
137     return getConstructorForContext(type, context);
138 }
139
140 #if ENABLE(WORKERS)
141 v8::Local<v8::Function> V8DOMWrapper::getConstructor(WrapperTypeInfo* type, WorkerContext*)
142 {
143     WorkerScriptController* controller = WorkerScriptController::controllerForContext();
144     WorkerContextExecutionProxy* proxy = controller ? controller->proxy() : 0;
145     if (!proxy)
146         return v8::Local<v8::Function>();
147
148     v8::Handle<v8::Context> context = proxy->context();
149     if (context.IsEmpty())
150         return v8::Local<v8::Function>();
151
152     return getConstructorForContext(type, context);
153 }
154 #endif
155
156
157 void V8DOMWrapper::setNamedHiddenReference(v8::Handle<v8::Object> parent, const char* name, v8::Handle<v8::Value> child)
158 {
159     parent->SetHiddenValue(V8HiddenPropertyName::hiddenReferenceName(name), child);
160 }
161
162 void V8DOMWrapper::setNamedHiddenWindowReference(Frame* frame, const char* name, v8::Handle<v8::Value> jsObject)
163 {
164     // Get DOMWindow
165     if (!frame)
166         return; // Object might be detached from window
167     v8::Handle<v8::Context> context = V8Proxy::context(frame);
168     if (context.IsEmpty())
169         return;
170
171     v8::Handle<v8::Object> global = context->Global();
172     // Look for real DOM wrapper.
173     global = V8DOMWrapper::lookupDOMWrapper(V8DOMWindow::GetTemplate(), global);
174     ASSERT(!global.IsEmpty());
175
176     setNamedHiddenReference(global, name, jsObject);
177 }
178
179 WrapperTypeInfo* V8DOMWrapper::domWrapperType(v8::Handle<v8::Object> object)
180 {
181     ASSERT(V8DOMWrapper::maybeDOMWrapper(object));
182     return static_cast<WrapperTypeInfo*>(object->GetPointerFromInternalField(v8DOMWrapperTypeIndex));
183 }
184
185 PassRefPtr<NodeFilter> V8DOMWrapper::wrapNativeNodeFilter(v8::Handle<v8::Value> filter)
186 {
187     // A NodeFilter is used when walking through a DOM tree or iterating tree
188     // nodes.
189     // FIXME: we may want to cache NodeFilterCondition and NodeFilter
190     // object, but it is minor.
191     // NodeFilter is passed to NodeIterator that has a ref counted pointer
192     // to NodeFilter. NodeFilter has a ref counted pointer to NodeFilterCondition.
193     // In NodeFilterCondition, filter object is persisted in its constructor,
194     // and disposed in its destructor.
195     return NodeFilter::create(V8NodeFilterCondition::create(filter));
196 }
197
198 v8::Local<v8::Object> V8DOMWrapper::instantiateV8Object(V8Proxy* proxy, WrapperTypeInfo* type, void* impl)
199 {
200 #if ENABLE(WORKERS)
201     WorkerContext* workerContext = 0;
202 #endif
203     if (V8IsolatedContext::getEntered()) {
204         // This effectively disables the wrapper cache for isolated worlds.
205         proxy = 0;
206         // FIXME: Do we need a wrapper cache for the isolated world?  We should
207         //        see if the performance gains are worth while.
208         // We'll get one once we give the isolated context a proper window shell.
209     } else if (!proxy) {
210         v8::Handle<v8::Context> context = v8::Context::GetCurrent();
211         if (!context.IsEmpty()) {
212             v8::Handle<v8::Object> globalPrototype = v8::Handle<v8::Object>::Cast(context->Global()->GetPrototype());
213             if (isWrapperOfType(globalPrototype, &V8DOMWindow::info)) {
214                 Frame* frame = V8DOMWindow::toNative(globalPrototype)->frame();
215                 if (frame && frame->script()->canExecuteScripts(NotAboutToExecuteScript))
216                     proxy = V8Proxy::retrieve(frame);
217             }
218 #if ENABLE(WORKERS)
219             else if (isWrapperOfType(globalPrototype, &V8WorkerContext::info))
220                 workerContext = V8WorkerContext::toNative(lookupDOMWrapper(V8WorkerContext::GetTemplate(), context->Global()));
221 #endif
222         }
223     }
224
225     v8::Local<v8::Object> instance;
226     if (proxy)
227         // FIXME: Fix this to work properly with isolated worlds (see above).
228         instance = proxy->windowShell()->createWrapperFromCache(type);
229     else {
230         v8::Local<v8::Function> function;
231 #if ENABLE(WORKERS)
232         if (workerContext)
233             function = getConstructor(type, workerContext);
234         else
235 #endif
236             function = type->getTemplate()->GetFunction();
237         instance = SafeAllocation::newInstance(function);
238     }
239     if (!instance.IsEmpty()) {
240         // Avoid setting the DOM wrapper for failed allocations.
241         setDOMWrapper(instance, type, impl);
242         if (type == &V8HTMLDocument::info)
243             instance = V8HTMLDocument::WrapInShadowObject(instance, static_cast<Node*>(impl));
244     }
245     return instance;
246 }
247
248 #ifndef NDEBUG
249 bool V8DOMWrapper::maybeDOMWrapper(v8::Handle<v8::Value> value)
250 {
251     if (value.IsEmpty() || !value->IsObject())
252         return false;
253
254     v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(value);
255     if (!object->InternalFieldCount())
256         return false;
257
258     ASSERT(object->InternalFieldCount() >= v8DefaultWrapperInternalFieldCount);
259
260     v8::Handle<v8::Value> wrapper = object->GetInternalField(v8DOMWrapperObjectIndex);
261     ASSERT(wrapper->IsNumber() || wrapper->IsExternal());
262
263     return true;
264 }
265 #endif
266
267 bool V8DOMWrapper::isValidDOMObject(v8::Handle<v8::Value> value)
268 {
269     if (value.IsEmpty() || !value->IsObject())
270         return false;
271     return v8::Handle<v8::Object>::Cast(value)->InternalFieldCount();
272 }
273
274 bool V8DOMWrapper::isWrapperOfType(v8::Handle<v8::Value> value, WrapperTypeInfo* type)
275 {
276     if (!isValidDOMObject(value))
277         return false;
278
279     v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(value);
280     ASSERT(object->InternalFieldCount() >= v8DefaultWrapperInternalFieldCount);
281
282     v8::Handle<v8::Value> wrapper = object->GetInternalField(v8DOMWrapperObjectIndex);
283     ASSERT_UNUSED(wrapper, wrapper->IsNumber() || wrapper->IsExternal());
284
285     WrapperTypeInfo* typeInfo = static_cast<WrapperTypeInfo*>(object->GetPointerFromInternalField(v8DOMWrapperTypeIndex));
286     return typeInfo == type;
287 }
288
289 #define TRY_TO_WRAP_WITH_INTERFACE(interfaceName) \
290     if (eventNames().interfaceFor##interfaceName == desiredInterface) \
291         return toV8(static_cast<interfaceName*>(target));
292
293 // A JS object of type EventTarget is limited to a small number of possible classes.
294 v8::Handle<v8::Value> V8DOMWrapper::convertEventTargetToV8Object(EventTarget* target)
295 {
296     if (!target)
297         return v8::Null();
298
299     AtomicString desiredInterface = target->interfaceName();
300     DOM_EVENT_TARGET_INTERFACES_FOR_EACH(TRY_TO_WRAP_WITH_INTERFACE)
301
302     ASSERT_NOT_REACHED();
303     return notHandledByInterceptor();
304 }
305
306 PassRefPtr<EventListener> V8DOMWrapper::getEventListener(v8::Local<v8::Value> value, bool isAttribute, ListenerLookupType lookup)
307 {
308     v8::Handle<v8::Context> context = v8::Context::GetCurrent();
309     if (context.IsEmpty())
310         return 0;
311     if (lookup == ListenerFindOnly)
312         return V8EventListenerList::findWrapper(value, isAttribute);
313     v8::Handle<v8::Object> globalPrototype = v8::Handle<v8::Object>::Cast(context->Global()->GetPrototype());
314     if (isWrapperOfType(globalPrototype, &V8DOMWindow::info))
315         return V8EventListenerList::findOrCreateWrapper<V8EventListener>(value, isAttribute);
316 #if ENABLE(WORKERS)
317     return V8EventListenerList::findOrCreateWrapper<V8WorkerContextEventListener>(value, isAttribute);
318 #else
319     return 0;
320 #endif
321 }
322
323 // XPath-related utilities
324 RefPtr<XPathNSResolver> V8DOMWrapper::getXPathNSResolver(v8::Handle<v8::Value> value, V8Proxy* proxy)
325 {
326     RefPtr<XPathNSResolver> resolver;
327     if (V8XPathNSResolver::HasInstance(value))
328         resolver = V8XPathNSResolver::toNative(v8::Handle<v8::Object>::Cast(value));
329     else if (value->IsObject())
330         resolver = V8CustomXPathNSResolver::create(value->ToObject());
331     return resolver;
332 }
333
334 }  // namespace WebCore