Make appendToVarDeclarationList static
[WebKit-https.git] / WebCore / bindings / js / kjs_window.cpp
1 // -*- c-basic-offset: 4 -*-
2 /*
3  *  Copyright (C) 2000 Harri Porten (porten@kde.org)
4  *  Copyright (C) 2006 Jon Shier (jshier@iastate.edu)
5  *  Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc. All rights reseved.
6  *  Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
7  *
8  *  This library is free software; you can redistribute it and/or
9  *  modify it under the terms of the GNU Lesser General Public
10  *  License as published by the Free Software Foundation; either
11  *  version 2 of the License, or (at your option) any later version.
12  *
13  *  This library is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  *  Lesser General Public License for more details.
17  *
18  *  You should have received a copy of the GNU Lesser General Public
19  *  License along with this library; if not, write to the Free Software
20  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
21  *  USA
22  */
23
24 #include "config.h"
25 #include "kjs_window.h"
26
27 #include "Base64.h"
28 #include "CString.h"
29 #include "Chrome.h"
30 #include "DOMWindow.h"
31 #include "Element.h"
32 #include "EventListener.h"
33 #include "EventNames.h"
34 #include "ExceptionCode.h"
35 #include "FloatRect.h"
36 #include "Frame.h"
37 #include "FrameLoadRequest.h"
38 #include "FrameLoader.h"
39 #include "FrameTree.h"
40 #include "GCController.h"
41 #include "HTMLDocument.h"
42 #include "JSDOMExceptionConstructor.h"
43 #include "JSDOMWindow.h"
44 #include "JSEvent.h"
45 #include "JSHTMLAudioElementConstructor.h"
46 #include "JSHTMLCollection.h"
47 #include "JSHTMLOptionElementConstructor.h"
48 #include "JSXMLHttpRequest.h"
49 #include "JSLocation.h"
50 #include "Logging.h"
51 #include "Page.h"
52 #include "PausedTimeouts.h"
53 #include "PlatformScreen.h"
54 #include "PlugInInfoStore.h"
55 #include "RenderView.h"
56 #include "ScheduledAction.h"
57 #include "SecurityOrigin.h"
58 #include "Settings.h"
59 #include "WindowFeatures.h"
60 #include "htmlediting.h"
61 #include "kjs_css.h"
62 #include "kjs_events.h"
63 #include "kjs_navigator.h"
64 #include "kjs_proxy.h"
65 #include <wtf/MathExtras.h>
66
67 #if ENABLE(XSLT)
68 #include "JSXSLTProcessor.h"
69 #endif
70
71 using namespace WebCore;
72 using namespace EventNames;
73
74 namespace KJS {
75
76 static int lastUsedTimeoutId;
77
78 static int timerNestingLevel = 0;
79 const int cMaxTimerNestingLevel = 5;
80 const double cMinimumTimerInterval = 0.010;
81
82 struct WindowPrivate {
83     WindowPrivate()
84         : loc(0)
85         , m_evt(0)
86         , m_returnValueSlot(0)
87     {
88     }
89
90     Window::ListenersMap jsEventListeners;
91     Window::ListenersMap jsHTMLEventListeners;
92     Window::UnprotectedListenersMap jsUnprotectedEventListeners;
93     Window::UnprotectedListenersMap jsUnprotectedHTMLEventListeners;
94     mutable WebCore::JSLocation* loc;
95     WebCore::Event* m_evt;
96     JSValue** m_returnValueSlot;
97
98     typedef HashMap<int, DOMWindowTimer*> TimeoutsMap;
99     TimeoutsMap m_timeouts;
100 };
101
102 class DOMWindowTimer : public TimerBase {
103 public:
104     DOMWindowTimer(int timeoutId, int nestingLevel, Window* object, WebCore::ScheduledAction* action)
105         : m_timeoutId(timeoutId)
106         , m_nestingLevel(nestingLevel)
107         , m_object(object)
108         , m_action(action)
109     {
110     }
111
112     virtual ~DOMWindowTimer()
113     {
114         JSLock lock;
115         delete m_action;
116     }
117
118     int timeoutId() const { return m_timeoutId; }
119
120     int nestingLevel() const { return m_nestingLevel; }
121     void setNestingLevel(int n) { m_nestingLevel = n; }
122
123     WebCore::ScheduledAction* action() const { return m_action; }
124     WebCore::ScheduledAction* takeAction() { WebCore::ScheduledAction* a = m_action; m_action = 0; return a; }
125
126 private:
127     virtual void fired();
128
129     int m_timeoutId;
130     int m_nestingLevel;
131     Window* m_object;
132     WebCore::ScheduledAction* m_action;
133 };
134
135 } // namespace KJS
136
137 #include "kjs_window.lut.h"
138
139 namespace KJS {
140
141 ////////////////////// Window Object ////////////////////////
142
143 const ClassInfo Window::info = { "Window", 0, &WindowTable };
144
145 /*
146 @begin WindowTable 118
147 # Warning, when adding a function to this object you need to add a case in Window::get
148 # -- Functions --
149   atob                  &WindowProtoFuncAToB::create                DontDelete|Function 1
150   btoa                  &WindowProtoFuncBToA::create                DontDelete|Function 1
151   open                  &WindowProtoFuncOpen::create                DontDelete|Function 3
152   setTimeout            &WindowProtoFuncSetTimeout::create          DontDelete|Function 2
153   clearTimeout          &WindowProtoFuncClearTimeout::create        DontDelete|Function 1
154   setInterval           &WindowProtoFuncSetInterval::create         DontDelete|Function 2
155   clearInterval         &WindowProtoFuncClearTimeout::create        DontDelete|Function 1
156   addEventListener      &WindowProtoFuncAddEventListener::create    DontDelete|Function 3
157   removeEventListener   &WindowProtoFuncRemoveEventListener::create DontDelete|Function 3
158   showModalDialog       &WindowProtoFuncShowModalDialog::create     DontDelete|Function 1
159 # Not implemented
160   captureEvents         &WindowProtoFuncNotImplemented::create      DontDelete|Function 0
161   releaseEvents         &WindowProtoFuncNotImplemented::create      DontDelete|Function 0
162
163 # -- Attributes --
164   crypto                Window::Crypto              DontDelete|ReadOnly
165   event                 Window::Event_              DontDelete
166   location              Window::Location_           DontDelete
167   navigator             Window::Navigator_          DontDelete|ReadOnly
168   clientInformation     Window::ClientInformation   DontDelete|ReadOnly
169 # -- Event Listeners --
170   onabort               Window::Onabort             DontDelete
171   onblur                Window::Onblur              DontDelete
172   onchange              Window::Onchange            DontDelete
173   onclick               Window::Onclick             DontDelete
174   ondblclick            Window::Ondblclick          DontDelete
175   onerror               Window::Onerror             DontDelete
176   onfocus               Window::Onfocus             DontDelete
177   onkeydown             Window::Onkeydown           DontDelete
178   onkeypress            Window::Onkeypress          DontDelete
179   onkeyup               Window::Onkeyup             DontDelete
180   onload                Window::Onload              DontDelete
181   onmousedown           Window::Onmousedown         DontDelete
182   onmousemove           Window::Onmousemove         DontDelete
183   onmouseout            Window::Onmouseout          DontDelete
184   onmouseover           Window::Onmouseover         DontDelete
185   onmouseup             Window::Onmouseup           DontDelete
186   onmousewheel          Window::OnWindowMouseWheel  DontDelete
187   onreset               Window::Onreset             DontDelete
188   onresize              Window::Onresize            DontDelete
189   onscroll              Window::Onscroll            DontDelete
190   onsearch              Window::Onsearch            DontDelete
191   onselect              Window::Onselect            DontDelete
192   onsubmit              Window::Onsubmit            DontDelete
193   onunload              Window::Onunload            DontDelete
194   onbeforeunload        Window::Onbeforeunload      DontDelete
195 # -- Constructors --
196   Audio                 Window::Audio               DontDelete
197   DOMException          Window::DOMException        DontDelete
198   Image                 Window::Image               DontDelete
199   Option                Window::Option              DontDelete
200   XMLHttpRequest        Window::XMLHttpRequest      DontDelete
201   XSLTProcessor         Window::XSLTProcessor_      DontDelete
202 @end
203 */
204
205 Window::Window(DOMWindow* window)
206     : m_impl(window)
207     , d(new WindowPrivate)
208 {
209     // Window destruction is not thread-safe because of
210     // the non-thread-safe WebCore structures it references.
211     Collector::collectOnMainThreadOnly(this);
212
213     // Time in milliseconds before the script timeout handler kicks in.
214     setTimeoutTime(10000);
215 }
216
217 Window::~Window()
218 {
219     clearAllTimeouts();
220
221     // Clear any backpointers to the window
222
223     ListenersMap::iterator i2 = d->jsEventListeners.begin();
224     ListenersMap::iterator e2 = d->jsEventListeners.end();
225     for (; i2 != e2; ++i2)
226         i2->second->clearWindowObj();
227     i2 = d->jsHTMLEventListeners.begin();
228     e2 = d->jsHTMLEventListeners.end();
229     for (; i2 != e2; ++i2)
230         i2->second->clearWindowObj();
231
232     UnprotectedListenersMap::iterator i1 = d->jsUnprotectedEventListeners.begin();
233     UnprotectedListenersMap::iterator e1 = d->jsUnprotectedEventListeners.end();
234     for (; i1 != e1; ++i1)
235         i1->second->clearWindowObj();
236     i1 = d->jsUnprotectedHTMLEventListeners.begin();
237     e1 = d->jsUnprotectedHTMLEventListeners.end();
238     for (; i1 != e1; ++i1)
239         i1->second->clearWindowObj();
240 }
241
242 Window* Window::retrieveWindow(Frame* frame)
243 {
244     JSObject* o = retrieve(frame)->getObject();
245
246     ASSERT(o || !frame->settings() || !frame->settings()->isJavaScriptEnabled());
247     return static_cast<Window*>(o);
248 }
249
250 Window* Window::retrieveActive(ExecState* exec)
251 {
252     JSGlobalObject* globalObject = exec->dynamicGlobalObject();
253     ASSERT(globalObject);
254     return static_cast<Window*>(globalObject);
255 }
256
257 JSValue* Window::retrieve(Frame* frame)
258 {
259     ASSERT(frame);
260     if (KJSProxy* proxy = frame->scriptProxy())
261         return proxy->globalObject(); // the Global object is the "window"
262
263     return jsUndefined(); // This can happen with JS disabled on the domain of that window
264 }
265
266 WebCore::JSLocation* Window::location() const
267 {
268     if (!d->loc)
269         d->loc = new JSLocation(impl()->frame());
270     return d->loc;
271 }
272
273 // reference our special objects during garbage collection
274 void Window::mark()
275 {
276     JSGlobalObject::mark();
277     if (d->loc && !d->loc->marked())
278         d->loc->mark();
279 }
280
281 static bool allowPopUp(Frame* frame)
282 {
283     if (!frame)
284         return false;
285     if (frame->scriptProxy()->processingUserGesture())
286         return true;
287     Settings* settings = frame->settings();
288     return settings && settings->JavaScriptCanOpenWindowsAutomatically();
289 }
290
291 static HashMap<String, String> parseModalDialogFeatures(const String& featuresArg)
292 {
293     HashMap<String, String> map;
294
295     Vector<String> features = featuresArg.split(';');
296     Vector<String>::const_iterator end = features.end();
297     for (Vector<String>::const_iterator it = features.begin(); it != end; ++it) {
298         String s = *it;
299         int pos = s.find('=');
300         int colonPos = s.find(':');
301         if (pos >= 0 && colonPos >= 0)
302             continue; // ignore any strings that have both = and :
303         if (pos < 0)
304             pos = colonPos;
305         if (pos < 0) {
306             // null string for value means key without value
307             map.set(s.stripWhiteSpace().lower(), String());
308         } else {
309             String key = s.left(pos).stripWhiteSpace().lower();
310             String val = s.substring(pos + 1).stripWhiteSpace().lower();
311             int spacePos = val.find(' ');
312             if (spacePos != -1)
313                 val = val.left(spacePos);
314             map.set(key, val);
315         }
316     }
317
318     return map;
319 }
320
321 static Frame* createWindow(ExecState* exec, Frame* openerFrame, const String& url,
322     const String& frameName, const WindowFeatures& windowFeatures, JSValue* dialogArgs)
323 {
324     Frame* activeFrame = Window::retrieveActive(exec)->impl()->frame();
325
326     ResourceRequest request;
327     if (activeFrame)
328         request.setHTTPReferrer(activeFrame->loader()->outgoingReferrer());
329     FrameLoadRequest frameRequest(request, frameName);
330
331     // FIXME: It's much better for client API if a new window starts with a URL, here where we
332     // know what URL we are going to open. Unfortunately, this code passes the empty string
333     // for the URL, but there's a reason for that. Before loading we have to set up the opener,
334     // openedByDOM, and dialogArguments values. Also, to decide whether to use the URL we currently
335     // do an allowsAccessFrom call using the window we create, which can't be done before creating it.
336     // We'd have to resolve all those issues to pass the URL instead of "".
337
338     bool created;
339     Frame* newFrame = openerFrame->loader()->createWindow(frameRequest, windowFeatures, created);
340     if (!newFrame)
341         return 0;
342
343     newFrame->loader()->setOpener(openerFrame);
344     newFrame->loader()->setOpenedByDOM();
345
346     Window* newWindow = Window::retrieveWindow(newFrame);
347
348     if (dialogArgs)
349         newWindow->putDirect("dialogArguments", dialogArgs);
350
351     if (!url.startsWith("javascript:", false) || newWindow->allowsAccessFrom(exec)) {
352         String completedURL = url.isEmpty() ? url : activeFrame->document()->completeURL(url);
353         bool userGesture = activeFrame->scriptProxy()->processingUserGesture();
354
355         if (created) {
356             newFrame->loader()->changeLocation(KURL(completedURL.deprecatedString()), activeFrame->loader()->outgoingReferrer(), false, userGesture);
357             if (Document* oldDoc = openerFrame->document()) {
358                 newFrame->document()->setDomainInternal(oldDoc->domain());
359                 newFrame->document()->setBaseURL(oldDoc->baseURL());
360             }
361         } else if (!url.isEmpty())
362             newFrame->loader()->scheduleLocationChange(completedURL, activeFrame->loader()->outgoingReferrer(), false, userGesture);
363     }
364
365     return newFrame;
366 }
367
368 static bool canShowModalDialog(const Frame* frame)
369 {
370     if (!frame)
371         return false;
372     return frame->page()->chrome()->canRunModal();
373 }
374
375 static bool canShowModalDialogNow(const Frame* frame)
376 {
377     if (!frame)
378         return false;
379     return frame->page()->chrome()->canRunModalNow();
380 }
381
382 static JSValue* showModalDialog(ExecState* exec, Frame* frame, const String& url, JSValue* dialogArgs, const String& featureArgs)
383 {
384     if (!canShowModalDialogNow(frame) || !allowPopUp(frame))
385         return jsUndefined();
386
387     const HashMap<String, String> features = parseModalDialogFeatures(featureArgs);
388
389     const bool trusted = false;
390
391     // The following features from Microsoft's documentation are not implemented:
392     // - default font settings
393     // - width, height, left, and top specified in units other than "px"
394     // - edge (sunken or raised, default is raised)
395     // - dialogHide: trusted && boolFeature(features, "dialoghide"), makes dialog hide when you print
396     // - help: boolFeature(features, "help", true), makes help icon appear in dialog (what does it do on Windows?)
397     // - unadorned: trusted && boolFeature(features, "unadorned");
398
399     if (!frame)
400         return jsUndefined();
401
402     FloatRect screenRect = screenAvailableRect(frame->view());
403
404     WindowFeatures wargs;
405     wargs.width = WindowFeatures::floatFeature(features, "dialogwidth", 100, screenRect.width(), 620); // default here came from frame size of dialog in MacIE
406     wargs.widthSet = true;
407     wargs.height = WindowFeatures::floatFeature(features, "dialogheight", 100, screenRect.height(), 450); // default here came from frame size of dialog in MacIE
408     wargs.heightSet = true;
409
410     wargs.x = WindowFeatures::floatFeature(features, "dialogleft", screenRect.x(), screenRect.right() - wargs.width, -1);
411     wargs.xSet = wargs.x > 0;
412     wargs.y = WindowFeatures::floatFeature(features, "dialogtop", screenRect.y(), screenRect.bottom() - wargs.height, -1);
413     wargs.ySet = wargs.y > 0;
414
415     if (WindowFeatures::boolFeature(features, "center", true)) {
416         if (!wargs.xSet) {
417             wargs.x = screenRect.x() + (screenRect.width() - wargs.width) / 2;
418             wargs.xSet = true;
419         }
420         if (!wargs.ySet) {
421             wargs.y = screenRect.y() + (screenRect.height() - wargs.height) / 2;
422             wargs.ySet = true;
423         }
424     }
425
426     wargs.dialog = true;
427     wargs.resizable = WindowFeatures::boolFeature(features, "resizable");
428     wargs.scrollbarsVisible = WindowFeatures::boolFeature(features, "scroll", true);
429     wargs.statusBarVisible = WindowFeatures::boolFeature(features, "status", !trusted);
430     wargs.menuBarVisible = false;
431     wargs.toolBarVisible = false;
432     wargs.locationBarVisible = false;
433     wargs.fullscreen = false;
434
435     Frame* dialogFrame = createWindow(exec, frame, url, "", wargs, dialogArgs);
436     if (!dialogFrame)
437         return jsUndefined();
438
439     Window* dialogWindow = Window::retrieveWindow(dialogFrame);
440
441     // Get the return value either just before clearing the dialog window's
442     // properties (in Window::clear), or when on return from runModal.
443     JSValue* returnValue = 0;
444     dialogWindow->setReturnValueSlot(&returnValue);
445     dialogFrame->page()->chrome()->runModal();
446     dialogWindow->setReturnValueSlot(0);
447
448     // If we don't have a return value, get it now.
449     // Either Window::clear was not called yet, or there was no return value,
450     // and in that case, there's no harm in trying again (no benefit either).
451     if (!returnValue)
452         returnValue = dialogWindow->getDirect("returnValue");
453
454     return returnValue ? returnValue : jsUndefined();
455 }
456
457 JSValue *Window::getValueProperty(ExecState *exec, int token) const
458 {
459    ASSERT(impl()->frame());
460
461    switch (token) {
462    case Crypto:
463       return jsUndefined(); // FIXME: implement this
464    case DOMException:
465       if (!allowsAccessFrom(exec))
466         return jsUndefined();
467       return getDOMExceptionConstructor(exec);
468     case Event_:
469       if (!allowsAccessFrom(exec))
470         return jsUndefined();
471       if (!d->m_evt)
472         return jsUndefined();
473       return toJS(exec, d->m_evt);
474     case Location_:
475       return location();
476     case Navigator_:
477     case ClientInformation: {
478       if (!allowsAccessFrom(exec))
479         return jsUndefined();
480       // Store the navigator in the object so we get the same one each time.
481       Navigator *n = new Navigator(exec, impl()->frame());
482       // FIXME: this will make the "navigator" object accessible from windows that fail
483       // the security check the first time, but not subsequent times, seems weird.
484       const_cast<Window *>(this)->putDirect("navigator", n, DontDelete|ReadOnly);
485       const_cast<Window *>(this)->putDirect("clientInformation", n, DontDelete|ReadOnly);
486       return n;
487     }
488     case Image:
489       if (!allowsAccessFrom(exec))
490         return jsUndefined();
491       // FIXME: this property (and the few below) probably shouldn't create a new object every
492       // time
493       return new ImageConstructorImp(exec, impl()->frame()->document());
494     case Option:
495       if (!allowsAccessFrom(exec))
496         return jsUndefined();
497       return new JSHTMLOptionElementConstructor(exec, impl()->frame()->document());
498     case XMLHttpRequest:
499       if (!allowsAccessFrom(exec))
500         return jsUndefined();
501       return new JSXMLHttpRequestConstructorImp(exec, impl()->frame()->document());
502     case Audio:
503 #if ENABLE(VIDEO)
504       return new JSHTMLAudioElementConstructor(exec, impl()->frame()->document());
505 #else
506       return jsUndefined();
507 #endif
508 #if ENABLE(XSLT)
509     case XSLTProcessor_:
510       if (!allowsAccessFrom(exec))
511         return jsUndefined();
512       return new XSLTProcessorConstructorImp(exec);
513 #else
514     case XSLTProcessor_:
515       return jsUndefined();
516 #endif
517    }
518
519    if (!allowsAccessFrom(exec))
520      return jsUndefined();
521
522    switch (token) {
523    case Onabort:
524      return getListener(exec, abortEvent);
525    case Onblur:
526      return getListener(exec, blurEvent);
527    case Onchange:
528      return getListener(exec, changeEvent);
529    case Onclick:
530      return getListener(exec, clickEvent);
531    case Ondblclick:
532      return getListener(exec, dblclickEvent);
533    case Onerror:
534      return getListener(exec, errorEvent);
535    case Onfocus:
536      return getListener(exec, focusEvent);
537    case Onkeydown:
538      return getListener(exec, keydownEvent);
539    case Onkeypress:
540      return getListener(exec, keypressEvent);
541    case Onkeyup:
542      return getListener(exec, keyupEvent);
543    case Onload:
544      return getListener(exec, loadEvent);
545    case Onmousedown:
546      return getListener(exec, mousedownEvent);
547    case Onmousemove:
548      return getListener(exec, mousemoveEvent);
549    case Onmouseout:
550      return getListener(exec, mouseoutEvent);
551    case Onmouseover:
552      return getListener(exec, mouseoverEvent);
553    case Onmouseup:
554      return getListener(exec, mouseupEvent);
555    case OnWindowMouseWheel:
556      return getListener(exec, mousewheelEvent);
557    case Onreset:
558      return getListener(exec, resetEvent);
559    case Onresize:
560      return getListener(exec,resizeEvent);
561    case Onscroll:
562      return getListener(exec,scrollEvent);
563    case Onsearch:
564      return getListener(exec,searchEvent);
565    case Onselect:
566      return getListener(exec,selectEvent);
567    case Onsubmit:
568      return getListener(exec,submitEvent);
569    case Onbeforeunload:
570      return getListener(exec, beforeunloadEvent);
571    case Onunload:
572      return getListener(exec, unloadEvent);
573    }
574    ASSERT_NOT_REACHED();
575    return jsUndefined();
576 }
577
578 JSValue* Window::childFrameGetter(ExecState*, JSObject*, const Identifier& propertyName, const PropertySlot& slot)
579 {
580     return retrieve(static_cast<Window*>(slot.slotBase())->impl()->frame()->tree()->child(AtomicString(propertyName)));
581 }
582
583 JSValue* Window::indexGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot& slot)
584 {
585     return retrieve(static_cast<Window*>(slot.slotBase())->impl()->frame()->tree()->child(slot.index()));
586 }
587
588 JSValue *Window::namedItemGetter(ExecState *exec, JSObject *originalObject, const Identifier& propertyName, const PropertySlot& slot)
589 {
590   Window *thisObj = static_cast<Window *>(slot.slotBase());
591   Document *doc = thisObj->impl()->frame()->document();
592   ASSERT(thisObj->allowsAccessFrom(exec) && doc && doc->isHTMLDocument());
593
594   String name = propertyName;
595   RefPtr<WebCore::HTMLCollection> collection = doc->windowNamedItems(name);
596   if (collection->length() == 1)
597     return toJS(exec, collection->firstItem());
598   return toJS(exec, collection.get());
599 }
600
601 bool Window::getOwnPropertySlot(ExecState *exec, const Identifier& propertyName, PropertySlot& slot)
602 {
603   // Check for child frames by name before built-in properties to
604   // match Mozilla. This does not match IE, but some sites end up
605   // naming frames things that conflict with window properties that
606   // are in Moz but not IE. Since we have some of these, we have to do
607   // it the Moz way.
608   if (impl()->frame()->tree()->child(propertyName)) {
609     slot.setCustom(this, childFrameGetter);
610     return true;
611   }
612
613   const HashEntry* entry = Lookup::findEntry(&WindowTable, propertyName);
614   if (entry) {
615     if (entry->attr & Function) {
616       if (entry->value.functionValue == &WindowProtoFuncShowModalDialog::create) {
617         if (!canShowModalDialog(impl()->frame()))
618           return false;
619       }
620       if (allowsAccessFrom(exec))
621         slot.setStaticEntry(this, entry, staticFunctionGetter);
622       else
623         slot.setUndefined(this);
624     } else
625       slot.setStaticEntry(this, entry, staticValueGetter<Window>);
626     return true;
627   }
628
629   // FIXME: Search the whole frame hierachy somewhere around here.
630   // We need to test the correct priority order.
631
632   // allow window[1] or parent[1] etc. (#56983)
633   bool ok;
634   unsigned i = propertyName.toArrayIndex(&ok);
635   if (ok && i < impl()->frame()->tree()->childCount()) {
636     slot.setCustomIndex(this, i, indexGetter);
637     return true;
638   }
639
640   // allow shortcuts like 'Image1' instead of document.images.Image1
641   Document* doc = impl()->frame()->document();
642   if (doc && doc->isHTMLDocument()) {
643     if (!allowsAccessFrom(exec)) {
644       slot.setUndefined(this);
645       return true;
646     }
647
648     AtomicString atomicPropertyName = propertyName;
649     if (static_cast<HTMLDocument*>(doc)->hasNamedItem(atomicPropertyName) || doc->getElementById(atomicPropertyName)) {
650       slot.setCustom(this, namedItemGetter);
651       return true;
652     }
653   }
654
655   if (!allowsAccessFrom(exec)) {
656     slot.setUndefined(this);
657     return true;
658   }
659
660   return JSObject::getOwnPropertySlot(exec, propertyName, slot);
661 }
662
663 void Window::put(ExecState* exec, const Identifier& propertyName, JSValue* value, int attr)
664 {
665   const HashEntry* entry = Lookup::findEntry(&WindowTable, propertyName);
666   if (entry) {
667      if (entry->attr & Function) {
668        if (allowsAccessFrom(exec))
669          JSObject::put(exec, propertyName, value, attr);
670        return;
671     }
672     if (entry->attr & ReadOnly)
673       return;
674
675     switch (entry->value.intValue) {
676     case Location_: {
677       Frame* p = Window::retrieveActive(exec)->impl()->frame();
678       if (p) {
679         if (!p->loader()->shouldAllowNavigation(impl()->frame()))
680           return;
681         String dstUrl = p->loader()->completeURL(value->toString(exec)).string();
682         if (!dstUrl.startsWith("javascript:", false) || allowsAccessFrom(exec)) {
683           bool userGesture = p->scriptProxy()->processingUserGesture();
684           // We want a new history item if this JS was called via a user gesture
685           impl()->frame()->loader()->scheduleLocationChange(dstUrl, p->loader()->outgoingReferrer(), false, userGesture);
686         }
687       }
688       return;
689     }
690     case Onabort:
691       if (allowsAccessFrom(exec))
692         setListener(exec, abortEvent,value);
693       return;
694     case Onblur:
695       if (allowsAccessFrom(exec))
696         setListener(exec, blurEvent,value);
697       return;
698     case Onchange:
699       if (allowsAccessFrom(exec))
700         setListener(exec, changeEvent,value);
701       return;
702     case Onclick:
703       if (allowsAccessFrom(exec))
704         setListener(exec,clickEvent,value);
705       return;
706     case Ondblclick:
707       if (allowsAccessFrom(exec))
708         setListener(exec, dblclickEvent,value);
709       return;
710     case Onerror:
711       if (allowsAccessFrom(exec))
712         setListener(exec, errorEvent, value);
713       return;
714     case Onfocus:
715       if (allowsAccessFrom(exec))
716         setListener(exec,focusEvent,value);
717       return;
718     case Onkeydown:
719       if (allowsAccessFrom(exec))
720         setListener(exec,keydownEvent,value);
721       return;
722     case Onkeypress:
723       if (allowsAccessFrom(exec))
724         setListener(exec,keypressEvent,value);
725       return;
726     case Onkeyup:
727       if (allowsAccessFrom(exec))
728         setListener(exec,keyupEvent,value);
729       return;
730     case Onload:
731       if (allowsAccessFrom(exec))
732         setListener(exec,loadEvent,value);
733       return;
734     case Onmousedown:
735       if (allowsAccessFrom(exec))
736         setListener(exec,mousedownEvent,value);
737       return;
738     case Onmousemove:
739       if (allowsAccessFrom(exec))
740         setListener(exec,mousemoveEvent,value);
741       return;
742     case Onmouseout:
743       if (allowsAccessFrom(exec))
744         setListener(exec,mouseoutEvent,value);
745       return;
746     case Onmouseover:
747       if (allowsAccessFrom(exec))
748         setListener(exec,mouseoverEvent,value);
749       return;
750     case Onmouseup:
751       if (allowsAccessFrom(exec))
752         setListener(exec,mouseupEvent,value);
753       return;
754     case OnWindowMouseWheel:
755       if (allowsAccessFrom(exec))
756         setListener(exec, mousewheelEvent,value);
757       return;
758     case Onreset:
759       if (allowsAccessFrom(exec))
760         setListener(exec,resetEvent,value);
761       return;
762     case Onresize:
763       if (allowsAccessFrom(exec))
764         setListener(exec,resizeEvent,value);
765       return;
766     case Onscroll:
767       if (allowsAccessFrom(exec))
768         setListener(exec,scrollEvent,value);
769       return;
770     case Onsearch:
771         if (allowsAccessFrom(exec))
772             setListener(exec,searchEvent,value);
773         return;
774     case Onselect:
775       if (allowsAccessFrom(exec))
776         setListener(exec,selectEvent,value);
777       return;
778     case Onsubmit:
779       if (allowsAccessFrom(exec))
780         setListener(exec,submitEvent,value);
781       return;
782     case Onbeforeunload:
783       if (allowsAccessFrom(exec))
784         setListener(exec, beforeunloadEvent, value);
785       return;
786     case Onunload:
787       if (allowsAccessFrom(exec))
788         setListener(exec, unloadEvent, value);
789       return;
790     default:
791       break;
792     }
793   }
794   if (allowsAccessFrom(exec))
795     JSObject::put(exec, propertyName, value, attr);
796 }
797
798 bool Window::allowsAccessFrom(const JSGlobalObject* other) const
799 {
800     const Frame* originFrame = static_cast<const Window*>(other)->impl()->frame();
801     if (!originFrame)
802         return false;
803
804     const Frame* targetFrame = impl()->frame();
805     if (!targetFrame)
806         return false;
807
808     if (originFrame == targetFrame)
809         return true;
810
811     WebCore::Document* targetDocument = targetFrame->document();
812
813     // JS may be attempting to access the "window" object, which should be valid,
814     // even if the document hasn't been constructed yet.  If the document doesn't
815     // exist yet allow JS to access the window object.
816     if (!targetDocument)
817         return true;
818
819     WebCore::Document* originDocument = originFrame->document();
820
821     const SecurityOrigin& originSecurityOrigin = originDocument->securityOrigin();
822     const SecurityOrigin& targetSecurityOrigin = targetDocument->securityOrigin();
823
824     if (originSecurityOrigin.canAccess(targetSecurityOrigin))
825         return true;
826
827     if (!targetFrame->settings()->privateBrowsingEnabled()) {
828         // FIXME: this error message should contain more specifics of why the same origin check has failed.
829         String message = String::format("Unsafe JavaScript attempt to access frame with URL %s from frame with URL %s. Domains, protocols and ports must match.\n",
830                                         targetDocument->url().utf8().data(), originDocument->url().utf8().data());
831
832         if (Interpreter::shouldPrintExceptions())
833             printf("%s", message.utf8().data());
834
835         if (Page* page = targetFrame->page())
836             page->chrome()->addMessageToConsole(JSMessageSource, ErrorMessageLevel, message, 1, String()); // FIXME: provide a real line number and source URL.
837     }
838
839     return false;
840 }
841
842 ExecState* Window::globalExec()
843 {
844     // We need to make sure that any script execution happening in this
845     // frame does not destroy it
846     ASSERT(impl()->frame());
847     impl()->frame()->keepAlive();
848     return JSGlobalObject::globalExec();
849 }
850
851 bool Window::shouldInterruptScript() const
852 {
853     ASSERT(impl()->frame());
854     Page* page = impl()->frame()->page();
855
856     // See <rdar://problem/5479443>. We don't think that page can ever be NULL
857     // in this case, but if it is, we've gotten into a state where we may have
858     // hung the UI, with no way to ask the client whether to cancel execution.
859     // For now, our solution is just to cancel execution no matter what,
860     // ensuring that we never hang. We might want to consider other solutions
861     // if we discover problems with this one.
862     ASSERT(page);
863     if (!page)
864         return true;
865
866     return page->chrome()->shouldInterruptJavaScript();
867 }
868
869 void Window::setListener(ExecState* exec, const AtomicString& eventType, JSValue* func)
870 {
871     ASSERT(impl()->frame());
872     Document* doc = impl()->frame()->document();
873     if (!doc)
874         return;
875
876     doc->setHTMLWindowEventListener(eventType, findOrCreateJSEventListener(func, true));
877 }
878
879 JSValue* Window::getListener(ExecState* exec, const AtomicString& eventType) const
880 {
881     ASSERT(impl()->frame());
882     Document* doc = impl()->frame()->document();
883     if (!doc)
884         return jsUndefined();
885
886     WebCore::EventListener* listener = doc->getHTMLWindowEventListener(eventType);
887     if (listener && static_cast<JSEventListener*>(listener)->listenerObj())
888         return static_cast<JSEventListener*>(listener)->listenerObj();
889     return jsNull();
890 }
891
892 JSEventListener* Window::findJSEventListener(JSValue* val, bool html)
893 {
894     if (!val->isObject())
895         return 0;
896     JSObject* object = static_cast<JSObject*>(val);
897     ListenersMap& listeners = html ? d->jsHTMLEventListeners : d->jsEventListeners;
898     return listeners.get(object);
899 }
900
901 JSEventListener* Window::findOrCreateJSEventListener(JSValue* val, bool html)
902 {
903     JSEventListener* listener = findJSEventListener(val, html);
904     if (listener)
905         return listener;
906
907     if (!val->isObject())
908         return 0;
909     JSObject* object = static_cast<JSObject*>(val);
910
911     // Note that the JSEventListener constructor adds it to our jsEventListeners list
912     return new JSEventListener(object, this, html);
913 }
914
915 JSUnprotectedEventListener* Window::findJSUnprotectedEventListener(JSValue* val, bool html)
916 {
917     if (!val->isObject())
918         return 0;
919     JSObject* object = static_cast<JSObject*>(val);
920     UnprotectedListenersMap& listeners = html ? d->jsUnprotectedHTMLEventListeners : d->jsUnprotectedEventListeners;
921     return listeners.get(object);
922 }
923
924 JSUnprotectedEventListener* Window::findOrCreateJSUnprotectedEventListener(JSValue* val, bool html)
925 {
926     JSUnprotectedEventListener* listener = findJSUnprotectedEventListener(val, html);
927     if (listener)
928         return listener;
929     if (!val->isObject())
930         return 0;
931     JSObject* object = static_cast<JSObject*>(val);
932
933     // The JSUnprotectedEventListener constructor adds it to our jsUnprotectedEventListeners map.
934     return new JSUnprotectedEventListener(object, this, html);
935 }
936
937 void Window::clearHelperObjectProperties()
938 {
939     d->loc = 0;
940     d->m_evt = 0;
941 }
942
943 void Window::clear()
944 {
945   JSLock lock;
946
947   if (d->m_returnValueSlot && !*d->m_returnValueSlot)
948     *d->m_returnValueSlot = getDirect("returnValue");
949
950   clearAllTimeouts();
951   clearProperties();
952   clearHelperObjectProperties();
953
954   // Now recreate a working global object for the next URL that will use us; but only if we haven't been
955   // disconnected yet
956   if (Frame* frame = impl()->frame())
957     frame->scriptProxy()->globalObject()->reset(JSDOMWindowPrototype::self());
958
959   // there's likely to be lots of garbage now
960   gcController().garbageCollectSoon();
961 }
962
963 void Window::setCurrentEvent(Event* evt)
964 {
965     d->m_evt = evt;
966 }
967
968 Event* Window::currentEvent()
969 {
970     return d->m_evt;
971 }
972
973 JSValue* WindowProtoFuncAToB::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
974 {
975     if (!thisObj->inherits(&Window::info))
976         return throwError(exec, TypeError);
977
978     if (args.size() < 1)
979         return throwError(exec, SyntaxError, "Not enough arguments");
980
981     JSValue* v = args[0];
982     if (v->isNull())
983         return jsString();
984
985     UString s = v->toString(exec);
986     if (!s.is8Bit()) {
987         setDOMException(exec, INVALID_CHARACTER_ERR);
988         return jsUndefined();
989     }
990
991     Vector<char> in(s.size());
992     for (int i = 0; i < s.size(); ++i)
993         in[i] = static_cast<char>(s.data()[i].unicode());
994     Vector<char> out;
995
996     if (!base64Decode(in, out))
997         return throwError(exec, GeneralError, "Cannot decode base64");
998
999     return jsString(String(out.data(), out.size()));
1000 }
1001
1002 JSValue* WindowProtoFuncBToA::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
1003 {
1004     if (!thisObj->inherits(&Window::info))
1005         return throwError(exec, TypeError);
1006
1007     if (args.size() < 1)
1008         return throwError(exec, SyntaxError, "Not enough arguments");
1009
1010     JSValue* v = args[0];
1011     if (v->isNull())
1012         return jsString();
1013
1014     UString s = v->toString(exec);
1015     if (!s.is8Bit()) {
1016         setDOMException(exec, INVALID_CHARACTER_ERR);
1017         return jsUndefined();
1018     }
1019
1020     Vector<char> in(s.size());
1021     for (int i = 0; i < s.size(); ++i)
1022         in[i] = static_cast<char>(s.data()[i].unicode());
1023     Vector<char> out;
1024
1025     base64Encode(in, out);
1026
1027     return jsString(String(out.data(), out.size()));
1028 }
1029
1030 JSValue* WindowProtoFuncOpen::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
1031 {
1032     if (!thisObj->inherits(&Window::info))
1033         return throwError(exec, TypeError);
1034     Window* window = static_cast<Window*>(thisObj);
1035     Frame* frame = window->impl()->frame();
1036     if (!frame)
1037         return jsUndefined();
1038     Frame* activeFrame = Window::retrieveActive(exec)->impl()->frame();
1039     if (!activeFrame)
1040         return  jsUndefined();
1041
1042     Page* page = frame->page();
1043
1044     String urlString = valueToStringWithUndefinedOrNullCheck(exec, args[0]);
1045     AtomicString frameName = args[1]->isUndefinedOrNull() ? "_blank" : AtomicString(args[1]->toString(exec));
1046
1047     // Because FrameTree::find() returns true for empty strings, we must check for empty framenames.
1048     // Otherwise, illegitimate window.open() calls with no name will pass right through the popup blocker.
1049     if (!allowPopUp(frame) && (frameName.isEmpty() || !frame->tree()->find(frameName)))
1050         return jsUndefined();
1051
1052     // Get the target frame for the special cases of _top and _parent.  In those
1053     // cases, we can schedule a location change right now and return early.
1054     bool topOrParent = false;
1055     if (frameName == "_top") {
1056         frame = frame->tree()->top();
1057         topOrParent = true;
1058     } else if (frameName == "_parent") {
1059         if (Frame* parent = frame->tree()->parent())
1060             frame = parent;
1061         if (!activeFrame->loader()->shouldAllowNavigation(frame))
1062             return jsUndefined();
1063         topOrParent = true;
1064     }
1065     if (topOrParent) {
1066         String completedURL;
1067         if (!urlString.isEmpty())
1068             completedURL = activeFrame->document()->completeURL(urlString);
1069
1070         const Window* targetedWindow = Window::retrieveWindow(frame);
1071         if (!completedURL.isEmpty() && (!completedURL.startsWith("javascript:", false) || (targetedWindow && targetedWindow->allowsAccessFrom(exec)))) {
1072             bool userGesture = activeFrame->scriptProxy()->processingUserGesture();
1073             frame->loader()->scheduleLocationChange(completedURL, activeFrame->loader()->outgoingReferrer(), false, userGesture);
1074         }
1075         return Window::retrieve(frame);
1076     }
1077
1078     // In the case of a named frame or a new window, we'll use the createWindow() helper
1079     WindowFeatures windowFeatures(valueToStringWithUndefinedOrNullCheck(exec, args[2]));
1080     FloatRect windowRect(windowFeatures.x, windowFeatures.y, windowFeatures.width, windowFeatures.height);
1081     WebCore::DOMWindow::adjustWindowRect(screenAvailableRect(page->mainFrame()->view()), windowRect, windowRect);
1082
1083     windowFeatures.x = windowRect.x();
1084     windowFeatures.y = windowRect.y();
1085     windowFeatures.height = windowRect.height();
1086     windowFeatures.width = windowRect.width();
1087
1088     frame = createWindow(exec, frame, urlString, frameName, windowFeatures, 0);
1089
1090     if (!frame)
1091         return jsUndefined();
1092
1093     return Window::retrieve(frame); // global object
1094 }
1095
1096 JSValue* WindowProtoFuncSetTimeout::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
1097 {
1098     if (!thisObj->inherits(&Window::info))
1099         return throwError(exec, TypeError);
1100     Window* window = static_cast<Window*>(thisObj);
1101
1102     JSValue* v = args[0];
1103     if (v->isString())
1104         return jsNumber(window->installTimeout(v->toString(exec), args[1]->toInt32(exec), true /*single shot*/));
1105     if (v->isObject() && static_cast<JSObject*>(v)->implementsCall()) {
1106         List argsTail;
1107         args.getSlice(2, argsTail);
1108         return jsNumber(window->installTimeout(v, argsTail, args[1]->toInt32(exec), true /*single shot*/));
1109     }
1110
1111     return jsUndefined();
1112 }
1113
1114 JSValue* WindowProtoFuncClearTimeout::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
1115 {
1116     // Also the implementation for window.clearInterval()
1117
1118     if (!thisObj->inherits(&Window::info))
1119         return throwError(exec, TypeError);
1120     Window* window = static_cast<Window*>(thisObj);
1121
1122     window->clearTimeout(args[0]->toInt32(exec));
1123     return jsUndefined();
1124 }
1125
1126 JSValue* WindowProtoFuncSetInterval::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
1127 {
1128     if (!thisObj->inherits(&Window::info))
1129         return throwError(exec, TypeError);
1130     Window* window = static_cast<Window*>(thisObj);
1131
1132     if (args.size() >= 2) {
1133         JSValue* v = args[0];
1134         int delay = args[1]->toInt32(exec);
1135         if (v->isString())
1136             return jsNumber(window->installTimeout(v->toString(exec), delay, false));
1137         if (v->isObject() && static_cast<JSObject*>(v)->implementsCall()) {
1138             List argsTail;
1139             args.getSlice(2, argsTail);
1140             return jsNumber(window->installTimeout(v, argsTail, delay, false));
1141         }
1142     }
1143
1144     return jsUndefined();
1145
1146 }
1147
1148 JSValue* WindowProtoFuncAddEventListener::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
1149 {
1150     if (!thisObj->inherits(&Window::info))
1151         return throwError(exec, TypeError);
1152     Window* window = static_cast<Window*>(thisObj);
1153     Frame* frame = window->impl()->frame();
1154     if (!frame)
1155         return jsUndefined();
1156
1157     if (JSEventListener* listener = window->findOrCreateJSEventListener(args[1])) {
1158         if (Document* doc = frame->document())
1159             doc->addWindowEventListener(AtomicString(args[0]->toString(exec)), listener, args[2]->toBoolean(exec));
1160     }
1161
1162     return jsUndefined();
1163 }
1164
1165 JSValue* WindowProtoFuncRemoveEventListener::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
1166 {
1167     if (!thisObj->inherits(&Window::info))
1168         return throwError(exec, TypeError);
1169     Window* window = static_cast<Window*>(thisObj);
1170     Frame* frame = window->impl()->frame();
1171     if (!frame)
1172         return jsUndefined();
1173
1174     if (JSEventListener* listener = window->findJSEventListener(args[1])) {
1175         if (Document* doc = frame->document())
1176             doc->removeWindowEventListener(AtomicString(args[0]->toString(exec)), listener, args[2]->toBoolean(exec));
1177     }
1178
1179     return jsUndefined();
1180 }
1181
1182 JSValue* WindowProtoFuncShowModalDialog::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
1183 {
1184     if (!thisObj->inherits(&Window::info))
1185         return throwError(exec, TypeError);
1186     Window* window = static_cast<Window*>(thisObj);
1187     Frame* frame = window->impl()->frame();
1188     if (!frame)
1189         return jsUndefined();
1190
1191     return showModalDialog(exec, frame, valueToStringWithUndefinedOrNullCheck(exec, args[0]), args[1], valueToStringWithUndefinedOrNullCheck(exec, args[2]));
1192 }
1193
1194 JSValue* WindowProtoFuncNotImplemented::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
1195 {
1196     if (!thisObj->inherits(&Window::info))
1197         return throwError(exec, TypeError);
1198
1199     return jsUndefined();
1200 }
1201
1202 void Window::setReturnValueSlot(JSValue** slot)
1203 {
1204     d->m_returnValueSlot = slot;
1205 }
1206
1207 ////////////////////// timeouts ////////////////////////
1208
1209 void Window::clearAllTimeouts()
1210 {
1211     deleteAllValues(d->m_timeouts);
1212     d->m_timeouts.clear();
1213 }
1214
1215 int Window::installTimeout(WebCore::ScheduledAction* a, int t, bool singleShot)
1216 {
1217     int timeoutId = ++lastUsedTimeoutId;
1218
1219     // avoid wraparound going negative on us
1220     if (timeoutId <= 0)
1221         timeoutId = 1;
1222
1223     int nestLevel = timerNestingLevel + 1;
1224     DOMWindowTimer* timer = new DOMWindowTimer(timeoutId, nestLevel, this, a);
1225     ASSERT(!d->m_timeouts.get(timeoutId));
1226     d->m_timeouts.set(timeoutId, timer);
1227     // Use a minimum interval of 10 ms to match other browsers, but only once we've
1228     // nested enough to notice that we're repeating.
1229     // Faster timers might be "better", but they're incompatible.
1230     double interval = max(0.001, t * 0.001);
1231     if (interval < cMinimumTimerInterval && nestLevel >= cMaxTimerNestingLevel)
1232         interval = cMinimumTimerInterval;
1233     if (singleShot)
1234         timer->startOneShot(interval);
1235     else
1236         timer->startRepeating(interval);
1237     return timeoutId;
1238 }
1239
1240 int Window::installTimeout(const UString& handler, int t, bool singleShot)
1241 {
1242     return installTimeout(new WebCore::ScheduledAction(handler), t, singleShot);
1243 }
1244
1245 int Window::installTimeout(JSValue* func, const List& args, int t, bool singleShot)
1246 {
1247     return installTimeout(new WebCore::ScheduledAction(func, args), t, singleShot);
1248 }
1249
1250 WebCore::PausedTimeouts* Window::pauseTimeouts()
1251 {
1252     size_t count = d->m_timeouts.size();
1253     if (count == 0)
1254         return 0;
1255
1256     PausedTimeout* t = new PausedTimeout [count];
1257     PausedTimeouts* result = new PausedTimeouts(t, count);
1258
1259     WindowPrivate::TimeoutsMap::iterator it = d->m_timeouts.begin();
1260     for (size_t i = 0; i != count; ++i, ++it) {
1261         int timeoutId = it->first;
1262         DOMWindowTimer* timer = it->second;
1263         t[i].timeoutId = timeoutId;
1264         t[i].nestingLevel = timer->nestingLevel();
1265         t[i].nextFireInterval = timer->nextFireInterval();
1266         t[i].repeatInterval = timer->repeatInterval();
1267         t[i].action = timer->takeAction();
1268     }
1269     ASSERT(it == d->m_timeouts.end());
1270
1271     deleteAllValues(d->m_timeouts);
1272     d->m_timeouts.clear();
1273
1274     return result;
1275 }
1276
1277 void Window::resumeTimeouts(PausedTimeouts* timeouts)
1278 {
1279     if (!timeouts)
1280         return;
1281     size_t count = timeouts->numTimeouts();
1282     PausedTimeout* array = timeouts->takeTimeouts();
1283     for (size_t i = 0; i != count; ++i) {
1284         int timeoutId = array[i].timeoutId;
1285         DOMWindowTimer* timer = new DOMWindowTimer(timeoutId, array[i].nestingLevel, this, array[i].action);
1286         d->m_timeouts.set(timeoutId, timer);
1287         timer->start(array[i].nextFireInterval, array[i].repeatInterval);
1288     }
1289     delete [] array;
1290 }
1291
1292 void Window::clearTimeout(int timeoutId, bool delAction)
1293 {
1294     // timeout IDs have to be positive, and 0 and -1 are unsafe to
1295     // even look up since they are the empty and deleted value
1296     // respectively
1297     if (timeoutId <= 0)
1298         return;
1299
1300     delete d->m_timeouts.take(timeoutId);
1301 }
1302
1303 void Window::timerFired(DOMWindowTimer* timer)
1304 {
1305     // Simple case for non-one-shot timers.
1306     if (timer->isActive()) {
1307         int timeoutId = timer->timeoutId();
1308
1309         timer->action()->execute(this);
1310         if (d->m_timeouts.contains(timeoutId) && timer->repeatInterval() && timer->repeatInterval() < cMinimumTimerInterval) {
1311             timer->setNestingLevel(timer->nestingLevel() + 1);
1312             if (timer->nestingLevel() >= cMaxTimerNestingLevel)
1313                 timer->augmentRepeatInterval(cMinimumTimerInterval - timer->repeatInterval());
1314         }
1315         return;
1316     }
1317
1318     // Delete timer before executing the action for one-shot timers.
1319     WebCore::ScheduledAction* action = timer->takeAction();
1320     d->m_timeouts.remove(timer->timeoutId());
1321     delete timer;
1322     action->execute(this);
1323
1324     JSLock lock;
1325     delete action;
1326 }
1327
1328 void Window::disconnectFrame()
1329 {
1330     clearAllTimeouts();
1331     if (d->loc)
1332         d->loc->m_frame = 0;
1333 }
1334
1335 Window::ListenersMap& Window::jsEventListeners()
1336 {
1337     return d->jsEventListeners;
1338 }
1339
1340 Window::ListenersMap& Window::jsHTMLEventListeners()
1341 {
1342     return d->jsHTMLEventListeners;
1343 }
1344
1345 Window::UnprotectedListenersMap& Window::jsUnprotectedEventListeners()
1346 {
1347     return d->jsUnprotectedEventListeners;
1348 }
1349
1350 Window::UnprotectedListenersMap& Window::jsUnprotectedHTMLEventListeners()
1351 {
1352     return d->jsUnprotectedHTMLEventListeners;
1353 }
1354
1355 /////////////////////////////////////////////////////////////////////////////
1356
1357 void DOMWindowTimer::fired()
1358 {
1359     timerNestingLevel = m_nestingLevel;
1360     m_object->timerFired(this);
1361     timerNestingLevel = 0;
1362 }
1363
1364 } // namespace KJS
1365
1366 using namespace KJS;
1367
1368 namespace WebCore {
1369
1370 JSValue* toJS(ExecState*, DOMWindow* domWindow)
1371 {
1372     if (!domWindow)
1373         return jsNull();
1374     Frame* frame = domWindow->frame();
1375     if (!frame)
1376         return jsNull();
1377     return Window::retrieve(frame);
1378 }
1379
1380 } // namespace WebCore