2010-09-28 Johnny Ding <jnd@chromium.org>
[WebKit-https.git] / WebCore / bindings / v8 / ScriptController.cpp
1 /*
2  * Copyright (C) 2008, 2009 Google Inc. All rights reserved.
3  * Copyright (C) 2009 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include "config.h"
33 #include "ScriptController.h"
34
35 #include "PlatformBridge.h"
36 #include "Document.h"
37 #include "ScriptCallStack.h"
38 #include "ScriptableDocumentParser.h"
39 #include "DOMWindow.h"
40 #include "Event.h"
41 #include "EventListener.h"
42 #include "EventNames.h"
43 #include "Frame.h"
44 #include "FrameLoaderClient.h"
45 #include "Node.h"
46 #include "NotImplemented.h"
47 #include "npruntime_impl.h"
48 #include "npruntime_priv.h"
49 #include "NPV8Object.h"
50 #include "ScriptSourceCode.h"
51 #include "Settings.h"
52 #include "UserGestureIndicator.h"
53 #include "V8Binding.h"
54 #include "V8BindingState.h"
55 #include "V8DOMWindow.h"
56 #include "V8Event.h"
57 #include "V8HiddenPropertyName.h"
58 #include "V8HTMLEmbedElement.h"
59 #include "V8IsolatedContext.h"
60 #include "V8NPObject.h"
61 #include "V8Proxy.h"
62 #include "Widget.h"
63 #include "XSSAuditor.h"
64 #include <wtf/StdLibExtras.h>
65 #include <wtf/text/CString.h>
66
67 #if PLATFORM(QT)
68 #include <QScriptEngine>
69 #endif
70
71 namespace WebCore {
72
73 void ScriptController::initializeThreading()
74 {
75     static bool initializedThreading = false;
76     if (!initializedThreading) {
77         WTF::initializeThreading();
78         WTF::initializeMainThread();
79         initializedThreading = true;
80     }
81 }
82
83 void ScriptController::setFlags(const char* string, int length)
84 {
85     v8::V8::SetFlagsFromString(string, length);
86 }
87
88 Frame* ScriptController::retrieveFrameForEnteredContext()
89 {
90     return V8Proxy::retrieveFrameForEnteredContext();
91 }
92
93 Frame* ScriptController::retrieveFrameForCurrentContext()
94 {
95     return V8Proxy::retrieveFrameForCurrentContext();
96 }
97
98 bool ScriptController::canAccessFromCurrentOrigin(Frame *frame)
99 {
100     return !v8::Context::InContext() || V8BindingSecurity::canAccessFrame(V8BindingState::Only(), frame, true);
101 }
102
103 bool ScriptController::isSafeScript(Frame* target)
104 {
105     return V8BindingSecurity::canAccessFrame(V8BindingState::Only(), target, true);
106 }
107
108 void ScriptController::gcProtectJSWrapper(void* domObject)
109 {
110     V8GCController::gcProtect(domObject);
111 }
112
113 void ScriptController::gcUnprotectJSWrapper(void* domObject)
114 {
115     V8GCController::gcUnprotect(domObject);
116 }
117
118 ScriptController::ScriptController(Frame* frame)
119     : m_frame(frame)
120     , m_sourceURL(0)
121     , m_inExecuteScript(false)
122     , m_processingTimerCallback(false)
123     , m_paused(false)
124     , m_allowPopupsFromPlugin(false)
125     , m_proxy(new V8Proxy(frame))
126 #if ENABLE(NETSCAPE_PLUGIN_API)
127     , m_windowScriptNPObject(0)
128 #endif
129     , m_XSSAuditor(new XSSAuditor(frame))
130 {
131 }
132
133 ScriptController::~ScriptController()
134 {
135     m_proxy->disconnectFrame();
136 }
137
138 void ScriptController::clearScriptObjects()
139 {
140     PluginObjectMap::iterator it = m_pluginObjects.begin();
141     for (; it != m_pluginObjects.end(); ++it) {
142         _NPN_UnregisterObject(it->second);
143         _NPN_ReleaseObject(it->second);
144     }
145     m_pluginObjects.clear();
146
147 #if ENABLE(NETSCAPE_PLUGIN_API)
148     if (m_windowScriptNPObject) {
149         // Call _NPN_DeallocateObject() instead of _NPN_ReleaseObject() so that we don't leak if a plugin fails to release the window
150         // script object properly.
151         // This shouldn't cause any problems for plugins since they should have already been stopped and destroyed at this point.
152         _NPN_DeallocateObject(m_windowScriptNPObject);
153         m_windowScriptNPObject = 0;
154     }
155 #endif
156 }
157
158 void ScriptController::updateSecurityOrigin()
159 {
160     m_proxy->windowShell()->updateSecurityOrigin();
161 }
162
163 void ScriptController::updatePlatformScriptObjects()
164 {
165     notImplemented();
166 }
167
168 bool ScriptController::processingUserGesture()
169 {
170     Frame* activeFrame = V8Proxy::retrieveFrameForEnteredContext();
171     // No script is running, so it is user-initiated unless the gesture stack
172     // explicitly says it is not.
173     if (!activeFrame)
174         return UserGestureIndicator::getUserGestureState() != DefinitelyNotProcessingUserGesture;
175
176     V8Proxy* activeProxy = activeFrame->script()->proxy();
177
178     v8::HandleScope handleScope;
179     v8::Handle<v8::Context> v8Context = V8Proxy::mainWorldContext(activeFrame);
180     // FIXME: find all cases context can be empty:
181     //  1) JS is disabled;
182     //  2) page is NULL;
183     if (v8Context.IsEmpty())
184         return true;
185
186     v8::Context::Scope scope(v8Context);
187
188     v8::Handle<v8::Object> global = v8Context->Global();
189     v8::Handle<v8::String> eventSymbol = V8HiddenPropertyName::event();
190     v8::Handle<v8::Value> jsEvent = global->GetHiddenValue(eventSymbol);
191     Event* event = V8DOMWrapper::isValidDOMObject(jsEvent) ? V8Event::toNative(v8::Handle<v8::Object>::Cast(jsEvent)) : 0;
192
193     // Based on code from JSC's ScriptController::processingUserGesture.
194     // Note: This is more liberal than Firefox's implementation.
195     if (event) {
196         // Event::fromUserGesture will return false when UserGestureIndicator::processingUserGesture() returns false.
197         return event->fromUserGesture();
198     }
199     // FIXME: We check the javascript anchor navigation from the last entered
200     // frame becuase it should only be initiated on the last entered frame in
201     // which execution began if it does happen.    
202     const String* sourceURL = activeFrame->script()->sourceURL();
203     if (sourceURL && sourceURL->isNull() && !activeProxy->timerCallback()) {
204         // This is the <a href="javascript:window.open('...')> case -> we let it through.
205         return true;
206     }
207     if (activeFrame->script()->allowPopupsFromPlugin())
208         return true;
209     // This is the <script>window.open(...)</script> case or a timer callback -> block it.
210     // Based on JSC version, use returned value of UserGestureIndicator::processingUserGesture for all other situations. 
211     return UserGestureIndicator::processingUserGesture();
212 }
213
214 bool ScriptController::anyPageIsProcessingUserGesture() const
215 {
216     // FIXME: is this right?
217     return ScriptController::processingUserGesture();
218 }
219
220 void ScriptController::evaluateInIsolatedWorld(unsigned worldID, const Vector<ScriptSourceCode>& sources)
221 {
222     m_proxy->evaluateInIsolatedWorld(worldID, sources, 0);
223 }
224
225 void ScriptController::evaluateInIsolatedWorld(unsigned worldID, const Vector<ScriptSourceCode>& sources, int extensionGroup)
226 {
227     m_proxy->evaluateInIsolatedWorld(worldID, sources, extensionGroup);
228 }
229
230 // Evaluate a script file in the environment of this proxy.
231 ScriptValue ScriptController::evaluate(const ScriptSourceCode& sourceCode, ShouldAllowXSS shouldAllowXSS)
232 {
233     String sourceURL = sourceCode.url();
234     const String* savedSourceURL = m_sourceURL;
235     m_sourceURL = &sourceURL;
236
237     if (shouldAllowXSS == DoNotAllowXSS && !m_XSSAuditor->canEvaluate(sourceCode.source())) {
238         // This script is not safe to be evaluated.
239         return ScriptValue();
240     }
241
242     v8::HandleScope handleScope;
243     v8::Handle<v8::Context> v8Context = V8Proxy::mainWorldContext(m_proxy->frame());
244     if (v8Context.IsEmpty())
245         return ScriptValue();
246
247     v8::Context::Scope scope(v8Context);
248
249     RefPtr<Frame> protect(m_frame);
250
251     v8::Local<v8::Value> object = m_proxy->evaluate(sourceCode, 0);
252
253     // Evaluating the JavaScript could cause the frame to be deallocated
254     // so we start the keep alive timer here.
255     m_frame->keepAlive();
256
257     m_sourceURL = savedSourceURL;
258
259     if (object.IsEmpty() || object->IsUndefined())
260         return ScriptValue();
261
262     return ScriptValue(object);
263 }
264
265 int ScriptController::eventHandlerLineNumber() const
266 {
267     ScriptableDocumentParser* parser = m_frame->document()->scriptableDocumentParser();
268     if (parser)
269         return parser->lineNumber();
270     return 0;
271 }
272
273 int ScriptController::eventHandlerColumnNumber() const
274 {
275     ScriptableDocumentParser* parser = m_frame->document()->scriptableDocumentParser();
276     if (parser)
277         return parser->columnNumber();
278     return 0;
279 }
280
281 void ScriptController::finishedWithEvent(Event* event)
282 {
283     m_proxy->finishedWithEvent(event);
284 }
285
286 // Create a V8 object with an interceptor of NPObjectPropertyGetter.
287 void ScriptController::bindToWindowObject(Frame* frame, const String& key, NPObject* object)
288 {
289     v8::HandleScope handleScope;
290
291     v8::Handle<v8::Context> v8Context = V8Proxy::mainWorldContext(frame);
292     if (v8Context.IsEmpty())
293         return;
294
295     v8::Context::Scope scope(v8Context);
296
297     v8::Handle<v8::Object> value = createV8ObjectForNPObject(object, 0);
298
299     // Attach to the global object.
300     v8::Handle<v8::Object> global = v8Context->Global();
301     global->Set(v8String(key), value);
302 }
303
304 void ScriptController::collectGarbage()
305 {
306     v8::HandleScope handleScope;
307
308     v8::Persistent<v8::Context> v8Context = v8::Context::New();
309     if (v8Context.IsEmpty())
310         return;
311     {
312         v8::Context::Scope scope(v8Context);
313         v8::Local<v8::String> source = v8::String::New("if (gc) gc();");
314         v8::Local<v8::String> name = v8::String::New("gc");
315         v8::Handle<v8::Script> script = v8::Script::Compile(source, name);
316         if (!script.IsEmpty())
317             script->Run();
318     }
319     v8Context.Dispose();
320 }
321
322 void ScriptController::lowMemoryNotification()
323 {
324     v8::V8::LowMemoryNotification();
325 }
326
327 bool ScriptController::haveInterpreter() const
328 {
329     return m_proxy->windowShell()->isContextInitialized();
330 }
331
332 PassScriptInstance ScriptController::createScriptInstanceForWidget(Widget* widget)
333 {
334     ASSERT(widget);
335
336     if (widget->isFrameView())
337         return 0;
338
339     NPObject* npObject = PlatformBridge::pluginScriptableObject(widget);
340
341     if (!npObject)
342         return 0;
343
344     // Frame Memory Management for NPObjects
345     // -------------------------------------
346     // NPObjects are treated differently than other objects wrapped by JS.
347     // NPObjects can be created either by the browser (e.g. the main
348     // window object) or by the plugin (the main plugin object
349     // for a HTMLEmbedElement). Further, unlike most DOM Objects, the frame
350     // is especially careful to ensure NPObjects terminate at frame teardown because
351     // if a plugin leaks a reference, it could leak its objects (or the browser's objects).
352     //
353     // The Frame maintains a list of plugin objects (m_pluginObjects)
354     // which it can use to quickly find the wrapped embed object.
355     //
356     // Inside the NPRuntime, we've added a few methods for registering
357     // wrapped NPObjects. The purpose of the registration is because
358     // javascript garbage collection is non-deterministic, yet we need to
359     // be able to tear down the plugin objects immediately. When an object
360     // is registered, javascript can use it. When the object is destroyed,
361     // or when the object's "owning" object is destroyed, the object will
362     // be un-registered, and the javascript engine must not use it.
363     //
364     // Inside the javascript engine, the engine can keep a reference to the
365     // NPObject as part of its wrapper. However, before accessing the object
366     // it must consult the _NPN_Registry.
367
368     v8::Local<v8::Object> wrapper = createV8ObjectForNPObject(npObject, 0);
369
370     // Track the plugin object. We've been given a reference to the object.
371     m_pluginObjects.set(widget, npObject);
372
373     return V8ScriptInstance::create(wrapper);
374 }
375
376 void ScriptController::cleanupScriptObjectsForPlugin(Widget* nativeHandle)
377 {
378     PluginObjectMap::iterator it = m_pluginObjects.find(nativeHandle);
379     if (it == m_pluginObjects.end())
380         return;
381     _NPN_UnregisterObject(it->second);
382     _NPN_ReleaseObject(it->second);
383     m_pluginObjects.remove(it);
384 }
385
386 void ScriptController::getAllWorlds(Vector<DOMWrapperWorld*>& worlds)
387 {
388     worlds.append(mainThreadNormalWorld());
389 }
390
391 void ScriptController::evaluateInWorld(const ScriptSourceCode& source,
392                                        DOMWrapperWorld* world)
393 {
394     Vector<ScriptSourceCode> sources;
395     sources.append(source);
396     // FIXME: Get an ID from the world param.
397     evaluateInIsolatedWorld(0, sources);
398 }
399
400 static NPObject* createNoScriptObject()
401 {
402     notImplemented();
403     return 0;
404 }
405
406 static NPObject* createScriptObject(Frame* frame)
407 {
408     v8::HandleScope handleScope;
409     v8::Handle<v8::Context> v8Context = V8Proxy::mainWorldContext(frame);
410     if (v8Context.IsEmpty())
411         return createNoScriptObject();
412
413     v8::Context::Scope scope(v8Context);
414     DOMWindow* window = frame->domWindow();
415     v8::Handle<v8::Value> global = toV8(window);
416     ASSERT(global->IsObject());
417     return npCreateV8ScriptObject(0, v8::Handle<v8::Object>::Cast(global), window);
418 }
419
420 NPObject* ScriptController::windowScriptNPObject()
421 {
422     if (m_windowScriptNPObject)
423         return m_windowScriptNPObject;
424
425     if (canExecuteScripts(NotAboutToExecuteScript)) {
426         // JavaScript is enabled, so there is a JavaScript window object.
427         // Return an NPObject bound to the window object.
428         m_windowScriptNPObject = createScriptObject(m_frame);
429         _NPN_RegisterObject(m_windowScriptNPObject, 0);
430     } else {
431         // JavaScript is not enabled, so we cannot bind the NPObject to the
432         // JavaScript window object. Instead, we create an NPObject of a
433         // different class, one which is not bound to a JavaScript object.
434         m_windowScriptNPObject = createNoScriptObject();
435     }
436     return m_windowScriptNPObject;
437 }
438
439 NPObject* ScriptController::createScriptObjectForPluginElement(HTMLPlugInElement* plugin)
440 {
441     // Can't create NPObjects when JavaScript is disabled.
442     if (!canExecuteScripts(NotAboutToExecuteScript))
443         return createNoScriptObject();
444
445     v8::HandleScope handleScope;
446     v8::Handle<v8::Context> v8Context = V8Proxy::mainWorldContext(m_frame);
447     if (v8Context.IsEmpty())
448         return createNoScriptObject();
449     v8::Context::Scope scope(v8Context);
450
451     DOMWindow* window = m_frame->domWindow();
452     v8::Handle<v8::Value> v8plugin = toV8(static_cast<HTMLEmbedElement*>(plugin));
453     if (!v8plugin->IsObject())
454         return createNoScriptObject();
455
456     return npCreateV8ScriptObject(0, v8::Handle<v8::Object>::Cast(v8plugin), window);
457 }
458
459
460 void ScriptController::clearWindowShell(bool)
461 {
462     // V8 binding expects ScriptController::clearWindowShell only be called
463     // when a frame is loading a new page. V8Proxy::clearForNavigation
464     // creates a new context for the new page.
465     m_proxy->clearForNavigation();
466 }
467
468 #if ENABLE(INSPECTOR)
469 void ScriptController::setCaptureCallStackForUncaughtExceptions(bool)
470 {
471     v8::V8::SetCaptureStackTraceForUncaughtExceptions(true, ScriptCallStack::maxCallStackSizeToCapture);
472 }
473 #endif
474
475 void ScriptController::attachDebugger(void*)
476 {
477     notImplemented();
478 }
479
480 void ScriptController::updateDocument()
481 {
482     m_proxy->windowShell()->updateDocument();
483 }
484
485 void ScriptController::namedItemAdded(HTMLDocument* doc, const AtomicString& name)
486 {
487     m_proxy->windowShell()->namedItemAdded(doc, name);
488 }
489
490 void ScriptController::namedItemRemoved(HTMLDocument* doc, const AtomicString& name)
491 {
492     m_proxy->windowShell()->namedItemRemoved(doc, name);
493 }
494
495 } // namespace WebCore