ecd016dd80760e0fb46556c1b77aa98d1150e432
[WebKit-https.git] / WebCore / bindings / v8 / custom / V8DOMWindowCustom.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 "DOMWindow.h"
33
34 #include "V8Binding.h"
35 #include "V8BindingState.h"
36 #include "V8CustomBinding.h"
37 #include "V8CustomEventListener.h"
38 #include "V8MessagePortCustom.h"
39 #include "V8Proxy.h"
40 #include "V8Utilities.h"
41
42 #include "Base64.h"
43 #include "ExceptionCode.h"
44 #include "DOMTimer.h"
45 #include "Frame.h"
46 #include "FrameLoadRequest.h"
47 #include "FrameView.h"
48 #include "HTMLCollection.h"
49 #include "MediaPlayer.h"
50 #include "Page.h"
51 #include "PlatformScreen.h"
52 #include "RuntimeEnabledFeatures.h"
53 #include "ScheduledAction.h"
54 #include "ScriptSourceCode.h"
55 #include "SerializedScriptValue.h"
56 #include "Settings.h"
57 #include "SharedWorkerRepository.h"
58 #include "Storage.h"
59 #if ENABLE(WEB_SOCKETS)
60 #include "WebSocket.h"
61 #endif
62 #include "WindowFeatures.h"
63
64 // Horizontal and vertical offset, from the parent content area, around newly
65 // opened popups that don't specify a location.
66 static const int popupTilePixels = 10;
67
68 namespace WebCore {
69
70 v8::Handle<v8::Value> V8Custom::WindowSetTimeoutImpl(const v8::Arguments& args, bool singleShot)
71 {
72     int argumentCount = args.Length();
73
74     if (argumentCount < 1)
75         return v8::Undefined();
76
77     v8::Handle<v8::Value> function = args[0];
78
79     WebCore::String functionString;
80     if (!function->IsFunction()) {
81         if (function->IsString())
82             functionString = toWebCoreString(function);
83         else {
84             v8::Handle<v8::Value> v8String = function->ToString();
85
86             // Bail out if string conversion failed. 
87             if (v8String.IsEmpty()) 
88                 return v8::Undefined(); 
89
90             functionString = toWebCoreString(v8String);
91         }
92
93         // Don't allow setting timeouts to run empty functions!
94         // (Bug 1009597)
95         if (functionString.length() == 0)
96             return v8::Undefined();
97     }
98
99     int32_t timeout = 0;
100     if (argumentCount >= 2)
101         timeout = args[1]->Int32Value();
102
103     DOMWindow* imp = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, args.Holder());
104
105     if (!V8BindingSecurity::canAccessFrame(V8BindingState::Only(), imp->frame(), true))
106         return v8::Undefined();
107
108     ScriptExecutionContext* scriptContext = static_cast<ScriptExecutionContext*>(imp->document());
109
110     if (!scriptContext)
111         return v8::Undefined();
112
113     int id;
114     if (function->IsFunction()) {
115         int paramCount = argumentCount >= 2 ? argumentCount - 2 : 0;
116         v8::Local<v8::Value>* params = 0;
117         if (paramCount > 0) {
118             params = new v8::Local<v8::Value>[paramCount];
119             for (int i = 0; i < paramCount; i++)
120                 // parameters must be globalized
121                 params[i] = args[i+2];
122         }
123
124         // params is passed to action, and released in action's destructor
125         ScheduledAction* action = new ScheduledAction(V8Proxy::context(imp->frame()), v8::Handle<v8::Function>::Cast(function), paramCount, params);
126
127         delete[] params;
128
129         id = DOMTimer::install(scriptContext, action, timeout, singleShot);
130     } else {
131         id = DOMTimer::install(scriptContext, new ScheduledAction(V8Proxy::context(imp->frame()), functionString), timeout, singleShot);
132     }
133
134     return v8::Integer::New(id);
135 }
136
137 static bool isAscii(const String& str)
138 {
139     for (size_t i = 0; i < str.length(); i++) {
140         if (str[i] > 0xFF)
141             return false;
142     }
143     return true;
144 }
145
146 static v8::Handle<v8::Value> convertBase64(const String& str, bool encode)
147 {
148     if (!isAscii(str)) {
149         V8Proxy::setDOMException(INVALID_CHARACTER_ERR);
150         return notHandledByInterceptor();
151     }
152
153     Vector<char> inputCharacters(str.length());
154     for (size_t i = 0; i < str.length(); i++)
155         inputCharacters[i] = static_cast<char>(str[i]);
156     Vector<char> outputCharacters;
157
158     if (encode)
159         base64Encode(inputCharacters, outputCharacters);
160     else {
161         if (!base64Decode(inputCharacters, outputCharacters))
162             return throwError("Cannot decode base64", V8Proxy::GeneralError);
163     }
164
165     return v8String(String(outputCharacters.data(), outputCharacters.size()));
166 }
167
168 ACCESSOR_GETTER(DOMWindowEvent)
169 {
170     v8::Handle<v8::Object> holder = V8DOMWrapper::lookupDOMWrapper(V8ClassIndex::DOMWINDOW, info.This());
171     if (holder.IsEmpty())
172         return v8::Undefined();
173
174     Frame* frame = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, holder)->frame();
175     if (!V8BindingSecurity::canAccessFrame(V8BindingState::Only(), frame, true))
176         return v8::Undefined();
177
178     v8::Local<v8::Context> context = V8Proxy::context(frame);
179     if (context.IsEmpty())
180         return v8::Undefined();
181
182     v8::Local<v8::String> eventSymbol = v8::String::NewSymbol("event");
183     v8::Handle<v8::Value> jsEvent = context->Global()->GetHiddenValue(eventSymbol);
184     if (jsEvent.IsEmpty())
185         return v8::Undefined();
186     return jsEvent;
187 }
188
189 ACCESSOR_SETTER(DOMWindowEvent)
190 {
191     v8::Handle<v8::Object> holder = V8DOMWrapper::lookupDOMWrapper(V8ClassIndex::DOMWINDOW, info.This());
192     if (holder.IsEmpty())
193         return;
194
195     Frame* frame = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, holder)->frame();
196     if (!V8BindingSecurity::canAccessFrame(V8BindingState::Only(), frame, true))
197         return;
198
199     v8::Local<v8::Context> context = V8Proxy::context(frame);
200     if (context.IsEmpty())
201         return;
202
203     v8::Local<v8::String> eventSymbol = v8::String::NewSymbol("event");
204     context->Global()->SetHiddenValue(eventSymbol, value);
205 }
206
207 ACCESSOR_GETTER(DOMWindowCrypto)
208 {
209     // FIXME: Implement me.
210     return v8::Undefined();
211 }
212
213 ACCESSOR_SETTER(DOMWindowLocation)
214 {
215     DOMWindow* imp = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, info.Holder());
216     WindowSetLocation(imp, toWebCoreString(value));
217 }
218
219
220 ACCESSOR_SETTER(DOMWindowOpener)
221 {
222     DOMWindow* imp = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, info.Holder());
223
224     if (!V8BindingSecurity::canAccessFrame(V8BindingState::Only(), imp->frame(), true))
225         return;
226   
227     // Opener can be shadowed if it is in the same domain.
228     // Have a special handling of null value to behave
229     // like Firefox. See bug http://b/1224887 & http://b/791706.
230     if (value->IsNull()) {
231         // imp->frame() cannot be null,
232         // otherwise, SameOrigin check would have failed.
233         ASSERT(imp->frame());
234         imp->frame()->loader()->setOpener(0);
235     }
236
237     // Delete the accessor from this object.
238     info.Holder()->Delete(name);
239
240     // Put property on the front (this) object.
241     info.This()->Set(name, value);
242 }
243
244 #if ENABLE(VIDEO)
245
246 ACCESSOR_GETTER(DOMWindowAudio)
247 {
248     DOMWindow* window = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, info.Holder());
249     return V8DOMWrapper::getConstructor(V8ClassIndex::AUDIO, window);
250 }
251
252 ACCESSOR_RUNTIME_ENABLER(DOMWindowAudio)
253 {
254     return MediaPlayer::isAvailable();
255 }
256
257 ACCESSOR_RUNTIME_ENABLER(DOMWindowHTMLMediaElement)
258 {
259     return MediaPlayer::isAvailable();
260 }
261
262 ACCESSOR_RUNTIME_ENABLER(DOMWindowHTMLAudioElement)
263 {
264     return MediaPlayer::isAvailable();
265 }
266
267 ACCESSOR_RUNTIME_ENABLER(DOMWindowHTMLVideoElement)
268 {
269     return MediaPlayer::isAvailable();
270 }
271
272 ACCESSOR_RUNTIME_ENABLER(DOMWindowMediaError)
273 {
274     return MediaPlayer::isAvailable();
275 }
276
277 #endif
278
279 #if ENABLE(SHARED_WORKERS)
280 ACCESSOR_RUNTIME_ENABLER(DOMWindowSharedWorker)
281 {
282     return SharedWorkerRepository::isAvailable();
283 }
284 #endif
285
286 #if ENABLE(WEB_SOCKETS)
287 ACCESSOR_RUNTIME_ENABLER(DOMWindowWebSocket)
288 {
289     return WebSocket::isAvailable();
290 }
291 #endif
292
293 #if ENABLE(DATABASE)
294 ACCESSOR_RUNTIME_ENABLER(DOMWindowOpenDatabase)
295 {
296     return WebCore::RuntimeEnabledFeatures::databaseEnabled();
297 }
298 #endif
299
300 #if ENABLE(DOM_STORAGE)
301 ACCESSOR_RUNTIME_ENABLER(DOMWindowLocalStorage)
302 {
303     return RuntimeEnabledFeatures::localStorageEnabled();
304 }
305
306 ACCESSOR_RUNTIME_ENABLER(DOMWindowSessionStorage)
307 {
308     return RuntimeEnabledFeatures::sessionStorageEnabled();
309 }
310 #endif
311
312 #if ENABLE(NOTIFICATIONS)
313 ACCESSOR_RUNTIME_ENABLER(DOMWindowWebkitNotifications)
314 {
315     return RuntimeEnabledFeatures::notificationsEnabled();
316 }
317 #endif
318
319 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
320 ACCESSOR_RUNTIME_ENABLER(DOMWindowApplicationCache)
321 {
322     return RuntimeEnabledFeatures::applicationCacheEnabled();
323 }
324 #endif
325
326 ACCESSOR_GETTER(DOMWindowImage)
327 {
328     DOMWindow* window = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, info.Holder());
329     return V8DOMWrapper::getConstructor(V8ClassIndex::IMAGE, window);
330 }
331
332 ACCESSOR_GETTER(DOMWindowOption)
333 {
334     DOMWindow* window = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, info.Holder());
335     return V8DOMWrapper::getConstructor(V8ClassIndex::OPTION, window);
336 }
337
338 CALLBACK_FUNC_DECL(DOMWindowAddEventListener)
339 {
340     INC_STATS("DOM.DOMWindow.addEventListener()");
341
342     String eventType = toWebCoreString(args[0]);
343     bool useCapture = args[2]->BooleanValue();
344
345     DOMWindow* imp = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, args.Holder());
346
347     if (!V8BindingSecurity::canAccessFrame(V8BindingState::Only(), imp->frame(), true))
348         return v8::Undefined();
349
350     Document* doc = imp->document();
351
352     if (!doc)
353         return v8::Undefined();
354
355     // FIXME: Check if there is not enough arguments
356     V8Proxy* proxy = V8Proxy::retrieve(imp->frame());
357     if (!proxy)
358         return v8::Undefined();
359
360     RefPtr<EventListener> listener = V8DOMWrapper::getEventListener(proxy, args[1], false, ListenerFindOrCreate);
361
362     if (listener) {
363         imp->addEventListener(eventType, listener, useCapture);
364         createHiddenDependency(args.Holder(), args[1], V8Custom::kDOMWindowEventListenerCacheIndex);
365     }
366
367     return v8::Undefined();
368 }
369
370
371 CALLBACK_FUNC_DECL(DOMWindowRemoveEventListener)
372 {
373     INC_STATS("DOM.DOMWindow.removeEventListener()");
374
375     String eventType = toWebCoreString(args[0]);
376     bool useCapture = args[2]->BooleanValue();
377
378     DOMWindow* imp = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, args.Holder());
379
380     if (!V8BindingSecurity::canAccessFrame(V8BindingState::Only(), imp->frame(), true))
381         return v8::Undefined();
382
383     Document* doc = imp->document();
384
385     if (!doc)
386         return v8::Undefined();
387
388     V8Proxy* proxy = V8Proxy::retrieve(imp->frame());
389     if (!proxy)
390         return v8::Undefined();
391
392     RefPtr<EventListener> listener = V8DOMWrapper::getEventListener(proxy, args[1], false, ListenerFindOnly);
393
394     if (listener) {
395         imp->removeEventListener(eventType, listener.get(), useCapture);
396         removeHiddenDependency(args.Holder(), args[1], V8Custom::kDOMWindowEventListenerCacheIndex);
397     }
398
399     return v8::Undefined();
400 }
401
402 CALLBACK_FUNC_DECL(DOMWindowPostMessage)
403 {
404     INC_STATS("DOM.DOMWindow.postMessage()");
405     DOMWindow* window = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, args.Holder());
406
407     DOMWindow* source = V8Proxy::retrieveFrameForCallingContext()->domWindow();
408     ASSERT(source->frame());
409
410     v8::TryCatch tryCatch;
411     RefPtr<SerializedScriptValue> message = SerializedScriptValue::create(toWebCoreString(args[0]));
412     MessagePortArray portArray;
413     String targetOrigin;
414
415     // This function has variable arguments and can either be:
416     //   postMessage(message, port, targetOrigin);
417     // or
418     //   postMessage(message, targetOrigin);
419     if (args.Length() > 2) {
420         if (!getMessagePortArray(args[1], portArray))
421             return v8::Undefined();
422         targetOrigin = toWebCoreStringWithNullOrUndefinedCheck(args[2]);
423     } else {
424         targetOrigin = toWebCoreStringWithNullOrUndefinedCheck(args[1]);
425     }
426
427     if (tryCatch.HasCaught())
428         return v8::Undefined();
429
430     ExceptionCode ec = 0;
431     window->postMessage(message.release(), &portArray, targetOrigin, source, ec);
432     return throwError(ec);
433 }
434
435 CALLBACK_FUNC_DECL(DOMWindowAtob)
436 {
437     INC_STATS("DOM.DOMWindow.atob()");
438
439     if (args[0]->IsNull())
440         return v8String("");
441     String str = toWebCoreString(args[0]);
442
443     DOMWindow* imp = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, args.Holder());
444
445     if (!V8BindingSecurity::canAccessFrame(V8BindingState::Only(), imp->frame(), true))
446         return v8::Undefined();
447
448     if (args.Length() < 1)
449         return throwError("Not enough arguments", V8Proxy::SyntaxError);
450
451     return convertBase64(str, false);
452 }
453
454 CALLBACK_FUNC_DECL(DOMWindowBtoa)
455 {
456     INC_STATS("DOM.DOMWindow.btoa()");
457
458     if (args[0]->IsNull())
459         return v8String("");
460     String str = toWebCoreString(args[0]);
461
462     DOMWindow* imp = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, args.Holder());
463
464     if (!V8BindingSecurity::canAccessFrame(V8BindingState::Only(), imp->frame(), true))
465         return v8::Undefined();
466
467     if (args.Length() < 1)
468         return throwError("Not enough arguments", V8Proxy::SyntaxError);
469
470     return convertBase64(str, true);
471 }
472
473 // FIXME(fqian): returning string is cheating, and we should
474 // fix this by calling toString function on the receiver.
475 // However, V8 implements toString in JavaScript, which requires
476 // switching context of receiver. I consider it is dangerous.
477 CALLBACK_FUNC_DECL(DOMWindowToString)
478 {
479     INC_STATS("DOM.DOMWindow.toString()");
480     v8::Handle<v8::Object> domWrapper = V8DOMWrapper::lookupDOMWrapper(V8ClassIndex::DOMWINDOW, args.This());
481     if (domWrapper.IsEmpty())
482         return args.This()->ObjectProtoToString();
483     return domWrapper->ObjectProtoToString();
484 }
485
486 CALLBACK_FUNC_DECL(DOMWindowNOP)
487 {
488     INC_STATS("DOM.DOMWindow.nop()");
489     return v8::Undefined();
490 }
491
492 static bool canShowModalDialogNow(const Frame* frame)
493 {
494     // A frame can out live its page. See bug 1219613.
495     if (!frame || !frame->page())
496         return false;
497     return frame->page()->chrome()->canRunModalNow();
498 }
499
500 static bool allowPopUp()
501 {
502     Frame* frame = V8Proxy::retrieveFrameForEnteredContext();
503
504     ASSERT(frame);
505     if (frame->script()->processingUserGesture())
506         return true;
507     Settings* settings = frame->settings();
508     return settings && settings->javaScriptCanOpenWindowsAutomatically();
509 }
510
511 static HashMap<String, String> parseModalDialogFeatures(const String& featuresArg)
512 {
513     HashMap<String, String> map;
514
515     Vector<String> features;
516     featuresArg.split(';', features);
517     Vector<String>::const_iterator end = features.end();
518     for (Vector<String>::const_iterator it = features.begin(); it != end; ++it) {
519         String featureString = *it;
520         int pos = featureString.find('=');
521         int colonPos = featureString.find(':');
522         if (pos >= 0 && colonPos >= 0)
523             continue;  // ignore any strings that have both = and :
524         if (pos < 0)
525             pos = colonPos;
526         if (pos < 0) {
527             // null string for value means key without value
528             map.set(featureString.stripWhiteSpace().lower(), String());
529         } else {
530             String key = featureString.left(pos).stripWhiteSpace().lower();
531             String val = featureString.substring(pos + 1).stripWhiteSpace().lower();
532             int spacePos = val.find(' ');
533             if (spacePos != -1)
534                 val = val.left(spacePos);
535             map.set(key, val);
536         }
537     }
538
539     return map;
540 }
541
542
543 static Frame* createWindow(Frame* callingFrame,
544                            Frame* enteredFrame,
545                            Frame* openerFrame,
546                            const String& url,
547                            const String& frameName,
548                            const WindowFeatures& windowFeatures,
549                            v8::Local<v8::Value> dialogArgs)
550 {
551     ASSERT(callingFrame);
552     ASSERT(enteredFrame);
553
554     // Sandboxed iframes cannot open new auxiliary browsing contexts.
555     if (callingFrame && callingFrame->loader()->isSandboxed(SandboxNavigation))
556         return 0;
557
558     ResourceRequest request;
559
560     // For whatever reason, Firefox uses the entered frame to determine
561     // the outgoingReferrer.  We replicate that behavior here.
562     String referrer = enteredFrame->loader()->outgoingReferrer();
563     request.setHTTPReferrer(referrer);
564     FrameLoader::addHTTPOriginIfNeeded(request, enteredFrame->loader()->outgoingOrigin());
565     FrameLoadRequest frameRequest(request, frameName);
566
567     // FIXME: It's much better for client API if a new window starts with a URL,
568     // here where we know what URL we are going to open. Unfortunately, this
569     // code passes the empty string for the URL, but there's a reason for that.
570     // Before loading we have to set up the opener, openedByDOM,
571     // and dialogArguments values. Also, to decide whether to use the URL
572     // we currently do an allowsAccessFrom call using the window we create,
573     // which can't be done before creating it. We'd have to resolve all those
574     // issues to pass the URL instead of "".
575
576     bool created;
577     // We pass in the opener frame here so it can be used for looking up the
578     // frame name, in case the active frame is different from the opener frame,
579     // and the name references a frame relative to the opener frame, for example
580     // "_self" or "_parent".
581     Frame* newFrame = callingFrame->loader()->createWindow(openerFrame->loader(), frameRequest, windowFeatures, created);
582     if (!newFrame)
583         return 0;
584
585     newFrame->loader()->setOpener(openerFrame);
586     newFrame->page()->setOpenedByDOM();
587
588     // Set dialog arguments on the global object of the new frame.
589     if (!dialogArgs.IsEmpty()) {
590         v8::Local<v8::Context> context = V8Proxy::context(newFrame);
591         if (!context.IsEmpty()) {
592             v8::Context::Scope scope(context);
593             context->Global()->Set(v8::String::New("dialogArguments"), dialogArgs);
594         }
595     }
596
597     if (protocolIsJavaScript(url) || ScriptController::isSafeScript(newFrame)) {
598         KURL completedUrl =
599             url.isEmpty() ? KURL(ParsedURLString, "") : completeURL(url);
600         bool userGesture = processingUserGesture();
601
602         if (created)
603             newFrame->loader()->changeLocation(completedUrl, referrer, false, false, userGesture);
604         else if (!url.isEmpty())
605             newFrame->redirectScheduler()->scheduleLocationChange(completedUrl.string(), referrer, false, userGesture);
606     }
607
608     return newFrame;
609 }
610
611
612
613 CALLBACK_FUNC_DECL(DOMWindowShowModalDialog)
614 {
615     INC_STATS("DOM.DOMWindow.showModalDialog()");
616
617     String url = toWebCoreStringWithNullOrUndefinedCheck(args[0]);
618     v8::Local<v8::Value> dialogArgs = args[1];
619     String featureArgs = toWebCoreStringWithNullOrUndefinedCheck(args[2]);
620
621     DOMWindow* window = V8DOMWrapper::convertToNativeObject<DOMWindow>(
622         V8ClassIndex::DOMWINDOW, args.Holder());
623     Frame* frame = window->frame();
624
625     if (!V8BindingSecurity::canAccessFrame(V8BindingState::Only(), frame, true))
626         return v8::Undefined();
627
628     Frame* callingFrame = V8Proxy::retrieveFrameForCallingContext();
629     if (!callingFrame)
630         return v8::Undefined();
631
632     Frame* enteredFrame = V8Proxy::retrieveFrameForEnteredContext();
633     if (!enteredFrame)
634         return v8::Undefined();
635
636     if (!canShowModalDialogNow(frame) || !allowPopUp())
637         return v8::Undefined();
638
639     const HashMap<String, String> features = parseModalDialogFeatures(featureArgs);
640
641     const bool trusted = false;
642
643     FloatRect screenRect = screenAvailableRect(frame->view());
644
645     WindowFeatures windowFeatures;
646     // default here came from frame size of dialog in MacIE.
647     windowFeatures.width = WindowFeatures::floatFeature(features, "dialogwidth", 100, screenRect.width(), 620);
648     windowFeatures.widthSet = true;
649     // default here came from frame size of dialog in MacIE.
650     windowFeatures.height = WindowFeatures::floatFeature(features, "dialogheight", 100, screenRect.height(), 450);
651     windowFeatures.heightSet = true;
652   
653     windowFeatures.x = WindowFeatures::floatFeature(features, "dialogleft", screenRect.x(), screenRect.right() - windowFeatures.width, -1);
654     windowFeatures.xSet = windowFeatures.x > 0;
655     windowFeatures.y = WindowFeatures::floatFeature(features, "dialogtop", screenRect.y(), screenRect.bottom() - windowFeatures.height, -1);
656     windowFeatures.ySet = windowFeatures.y > 0;
657
658     if (WindowFeatures::boolFeature(features, "center", true)) {
659         if (!windowFeatures.xSet) {
660             windowFeatures.x = screenRect.x() + (screenRect.width() - windowFeatures.width) / 2;
661             windowFeatures.xSet = true;
662         }
663         if (!windowFeatures.ySet) {
664             windowFeatures.y = screenRect.y() + (screenRect.height() - windowFeatures.height) / 2;
665             windowFeatures.ySet = true;
666         }
667     }
668
669     windowFeatures.dialog = true;
670     windowFeatures.resizable = WindowFeatures::boolFeature(features, "resizable");
671     windowFeatures.scrollbarsVisible = WindowFeatures::boolFeature(features, "scroll", true);
672     windowFeatures.statusBarVisible = WindowFeatures::boolFeature(features, "status", !trusted);
673     windowFeatures.menuBarVisible = false;
674     windowFeatures.toolBarVisible = false;
675     windowFeatures.locationBarVisible = false;
676     windowFeatures.fullscreen = false;
677
678     Frame* dialogFrame = createWindow(callingFrame, enteredFrame, frame, url, "", windowFeatures, dialogArgs);
679     if (!dialogFrame)
680         return v8::Undefined();
681
682     // Hold on to the context of the dialog window long enough to retrieve the
683     // value of the return value property.
684     v8::Local<v8::Context> context = V8Proxy::context(dialogFrame);
685
686     // Run the dialog.
687     dialogFrame->page()->chrome()->runModal();
688
689     // Extract the return value property from the dialog window.
690     v8::Local<v8::Value> returnValue;
691     if (!context.IsEmpty()) {
692         v8::Context::Scope scope(context);
693         returnValue = context->Global()->Get(v8::String::New("returnValue"));
694     }
695
696     if (!returnValue.IsEmpty())
697         return returnValue;
698
699     return v8::Undefined();
700 }
701
702
703 CALLBACK_FUNC_DECL(DOMWindowOpen)
704 {
705     INC_STATS("DOM.DOMWindow.open()");
706
707     String urlString = toWebCoreStringWithNullOrUndefinedCheck(args[0]);
708     AtomicString frameName = (args[1]->IsUndefined() || args[1]->IsNull()) ? "_blank" : AtomicString(toWebCoreString(args[1]));
709
710     DOMWindow* parent = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, args.Holder());
711     Frame* frame = parent->frame();
712
713     if (!V8BindingSecurity::canAccessFrame(V8BindingState::Only(), frame, true))
714         return v8::Undefined();
715
716     Frame* enteredFrame = V8Proxy::retrieveFrameForEnteredContext();
717     if (!enteredFrame)
718         return v8::Undefined();
719
720     Frame* callingFrame = V8Proxy::retrieveFrameForCallingContext();
721     // We may not have a calling context if we are invoked by a plugin via NPAPI.
722     if (!callingFrame)
723         callingFrame = enteredFrame;
724
725     Page* page = frame->page();
726     if (!page)
727         return v8::Undefined();
728
729     // Because FrameTree::find() returns true for empty strings, we must check
730     // for empty framenames. Otherwise, illegitimate window.open() calls with
731     // no name will pass right through the popup blocker.
732     if (!allowPopUp() &&
733         (frameName.isEmpty() || !frame->tree()->find(frameName))) {
734         return v8::Undefined();
735     }
736
737     // Get the target frame for the special cases of _top and _parent.  In those
738     // cases, we can schedule a location change right now and return early.
739     bool topOrParent = false;
740     if (frameName == "_top") {
741         frame = frame->tree()->top();
742         topOrParent = true;
743     } else if (frameName == "_parent") {
744         if (Frame* parent = frame->tree()->parent())
745             frame = parent;
746         topOrParent = true;
747     }
748     if (topOrParent) {
749         if (!shouldAllowNavigation(frame))
750             return v8::Undefined();
751     
752         String completedUrl;
753         if (!urlString.isEmpty())
754             completedUrl = completeURL(urlString);
755     
756         if (!completedUrl.isEmpty() &&
757             (!protocolIsJavaScript(completedUrl) || ScriptController::isSafeScript(frame))) {
758             bool userGesture = processingUserGesture();
759
760             // For whatever reason, Firefox uses the entered frame to determine
761             // the outgoingReferrer.  We replicate that behavior here.
762             String referrer = enteredFrame->loader()->outgoingReferrer();
763
764             frame->redirectScheduler()->scheduleLocationChange(completedUrl, referrer, false, userGesture);
765         }
766         return V8DOMWrapper::convertToV8Object(V8ClassIndex::DOMWINDOW, frame->domWindow());
767     }
768
769     // In the case of a named frame or a new window, we'll use the
770     // createWindow() helper.
771
772     // Parse the values, and then work with a copy of the parsed values
773     // so we can restore the values we may not want to overwrite after
774     // we do the multiple monitor fixes.
775     WindowFeatures rawFeatures(toWebCoreStringWithNullOrUndefinedCheck(args[2]));
776     WindowFeatures windowFeatures(rawFeatures);
777     FloatRect screenRect = screenAvailableRect(page->mainFrame()->view());
778
779     // Set default size and location near parent window if none were specified.
780     // These may be further modified by adjustWindowRect, below.
781     if (!windowFeatures.xSet) {
782         windowFeatures.x = parent->screenX() - screenRect.x() + popupTilePixels;
783         windowFeatures.xSet = true;
784     }
785     if (!windowFeatures.ySet) {
786         windowFeatures.y = parent->screenY() - screenRect.y() + popupTilePixels;
787         windowFeatures.ySet = true;
788     }
789     if (!windowFeatures.widthSet) {
790         windowFeatures.width = parent->innerWidth();
791         windowFeatures.widthSet = true;
792     }
793     if (!windowFeatures.heightSet) {
794         windowFeatures.height = parent->innerHeight();
795         windowFeatures.heightSet = true;
796     }
797
798     FloatRect windowRect(windowFeatures.x, windowFeatures.y, windowFeatures.width, windowFeatures.height);
799
800     // The new window's location is relative to its current screen, so shift
801     // it in case it's on a secondary monitor. See http://b/viewIssue?id=967905.
802     windowRect.move(screenRect.x(), screenRect.y());
803     WebCore::DOMWindow::adjustWindowRect(screenRect, windowRect, windowRect);
804
805     windowFeatures.x = windowRect.x();
806     windowFeatures.y = windowRect.y();
807     windowFeatures.height = windowRect.height();
808     windowFeatures.width = windowRect.width();
809
810     // If either of the origin coordinates weren't set in the original
811     // string, make sure they aren't set now.
812     if (!rawFeatures.xSet) {
813         windowFeatures.x = 0;
814         windowFeatures.xSet = false;
815     }
816     if (!rawFeatures.ySet) {
817         windowFeatures.y = 0;
818         windowFeatures.ySet = false;
819     }
820
821     frame = createWindow(callingFrame, enteredFrame, frame, urlString, frameName, windowFeatures, v8::Local<v8::Value>());
822
823     if (!frame)
824         return v8::Undefined();
825
826     return V8DOMWrapper::convertToV8Object(V8ClassIndex::DOMWINDOW, frame->domWindow());
827 }
828
829
830 INDEXED_PROPERTY_GETTER(DOMWindow)
831 {
832     INC_STATS("DOM.DOMWindow.IndexedPropertyGetter");
833
834     DOMWindow* window = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, info.Holder());
835     if (!window)
836         return notHandledByInterceptor();
837
838     Frame* frame = window->frame();
839     if (!frame)
840         return notHandledByInterceptor();
841
842     Frame* child = frame->tree()->child(index);
843     if (child)
844         return V8DOMWrapper::convertToV8Object(V8ClassIndex::DOMWINDOW, child->domWindow());
845
846     return notHandledByInterceptor();
847 }
848
849
850 NAMED_PROPERTY_GETTER(DOMWindow)
851 {
852     INC_STATS("DOM.DOMWindow.NamedPropertyGetter");
853
854     // TODO(antonm): investigate what convertToNativeObject does for the case of DOMWINDOW.
855     DOMWindow* window = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, info.Holder());
856     if (!window)
857         return notHandledByInterceptor();
858
859     Frame* frame = window->frame();
860     // window is detached from a frame.
861     if (!frame)
862         return notHandledByInterceptor();
863
864     // Search sub-frames.
865     AtomicString propName = v8StringToAtomicWebCoreString(name);
866     Frame* child = frame->tree()->child(propName);
867     if (child)
868         return V8DOMWrapper::convertToV8Object(V8ClassIndex::DOMWINDOW, child->domWindow());
869
870     // Search IDL functions defined in the prototype
871     v8::Handle<v8::Value> result = info.Holder()->GetRealNamedProperty(name);
872     if (!result.IsEmpty())
873         return result;
874
875     // Search named items in the document.
876     Document* doc = frame->document();
877
878     if (doc) {
879         RefPtr<HTMLCollection> items = doc->windowNamedItems(propName);
880         if (items->length() >= 1) {
881             if (items->length() == 1)
882                 return V8DOMWrapper::convertNodeToV8Object(items->firstItem());
883             else
884                 return V8DOMWrapper::convertToV8Object(V8ClassIndex::HTMLCOLLECTION, items.release());
885         }
886     }
887
888     return notHandledByInterceptor();
889 }
890
891
892 void V8Custom::WindowSetLocation(DOMWindow* window, const String& relativeURL)
893 {
894     Frame* frame = window->frame();
895     if (!frame)
896         return;
897
898     KURL url = completeURL(relativeURL);
899     if (url.isNull())
900         return;
901
902     if (!shouldAllowNavigation(frame))
903         return;
904
905     navigateIfAllowed(frame, url, false, false);
906 }
907
908
909 CALLBACK_FUNC_DECL(DOMWindowSetTimeout)
910 {
911     INC_STATS("DOM.DOMWindow.setTimeout()");
912     return WindowSetTimeoutImpl(args, true);
913 }
914
915
916 CALLBACK_FUNC_DECL(DOMWindowSetInterval)
917 {
918     INC_STATS("DOM.DOMWindow.setInterval()");
919     return WindowSetTimeoutImpl(args, false);
920 }
921
922
923 void V8Custom::ClearTimeoutImpl(const v8::Arguments& args)
924 {
925     int handle = toInt32(args[0]);
926
927     v8::Handle<v8::Object> holder = args.Holder();
928     DOMWindow* imp = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, holder);
929     if (!V8BindingSecurity::canAccessFrame(V8BindingState::Only(), imp->frame(), true))
930         return;
931     ScriptExecutionContext* context = static_cast<ScriptExecutionContext*>(imp->document());
932     if (!context)
933         return;
934     DOMTimer::removeById(context, handle);
935 }
936
937
938 CALLBACK_FUNC_DECL(DOMWindowClearTimeout)
939 {
940     INC_STATS("DOM.DOMWindow.clearTimeout");
941     ClearTimeoutImpl(args);
942     return v8::Undefined();
943 }
944
945 CALLBACK_FUNC_DECL(DOMWindowClearInterval)
946 {
947     INC_STATS("DOM.DOMWindow.clearInterval");
948     ClearTimeoutImpl(args);
949     return v8::Undefined();
950 }
951
952 NAMED_ACCESS_CHECK(DOMWindow)
953 {
954     ASSERT(V8ClassIndex::FromInt(data->Int32Value()) == V8ClassIndex::DOMWINDOW);
955     v8::Handle<v8::Object> window = V8DOMWrapper::lookupDOMWrapper(V8ClassIndex::DOMWINDOW, host);
956     if (window.IsEmpty())
957         return false;  // the frame is gone.
958
959     DOMWindow* targetWindow = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, window);
960
961     ASSERT(targetWindow);
962
963     Frame* target = targetWindow->frame();
964     if (!target)
965         return false;
966
967     if (key->IsString()) {
968         String name = toWebCoreString(key);
969
970         // Allow access of GET and HAS if index is a subframe.
971         if ((type == v8::ACCESS_GET || type == v8::ACCESS_HAS) && target->tree()->child(name))
972             return true;
973     }
974
975     return V8BindingSecurity::canAccessFrame(V8BindingState::Only(), target, false);
976 }
977
978 INDEXED_ACCESS_CHECK(DOMWindow)
979 {
980     ASSERT(V8ClassIndex::FromInt(data->Int32Value()) == V8ClassIndex::DOMWINDOW);
981     v8::Handle<v8::Object> window = V8DOMWrapper::lookupDOMWrapper(V8ClassIndex::DOMWINDOW, host);
982     if (window.IsEmpty())
983         return false;
984
985     DOMWindow* targetWindow = V8DOMWrapper::convertToNativeObject<DOMWindow>(V8ClassIndex::DOMWINDOW, window);
986
987     ASSERT(targetWindow);
988
989     Frame* target = targetWindow->frame();
990     if (!target)
991         return false;
992
993     // Allow access of GET and HAS if index is a subframe.
994     if ((type == v8::ACCESS_GET || type == v8::ACCESS_HAS) && target->tree()->child(index))
995         return true;
996
997     return V8BindingSecurity::canAccessFrame(V8BindingState::Only(), target, false);
998 }
999
1000 } // namespace WebCore