WebCore:
[WebKit-https.git] / WebCore / page / DOMWindow.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "DOMWindow.h"
28
29 #include "BarInfo.h"
30 #include "CSSComputedStyleDeclaration.h"
31 #include "CSSRuleList.h"
32 #include "CSSStyleSelector.h"
33 #include "CString.h"
34 #include "Chrome.h"
35 #include "Console.h"
36 #include "DOMSelection.h"
37 #include "Document.h"
38 #include "Element.h"
39 #include "ExceptionCode.h"
40 #include "FloatRect.h"
41 #include "Frame.h"
42 #include "FrameLoader.h"
43 #include "FrameTree.h"
44 #include "FrameView.h"
45 #include "HTMLFrameOwnerElement.h"
46 #include "History.h"
47 #include "Location.h"
48 #include "MessageEvent.h"
49 #include "Navigator.h"
50 #include "Page.h"
51 #include "PageGroup.h"
52 #include "PlatformScreen.h"
53 #include "PlatformString.h"
54 #include "Screen.h"
55 #include "SecurityOrigin.h"
56 #include <algorithm>
57 #include <wtf/MathExtras.h>
58
59 #if ENABLE(DATABASE)
60 #include "Database.h"
61 #endif
62
63 #if ENABLE(DOM_STORAGE)
64 #include "LocalStorage.h"
65 #include "SessionStorage.h"
66 #include "Storage.h"
67 #include "StorageArea.h"
68 #endif
69
70 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
71 #include "DOMApplicationCache.h"
72 #endif
73
74 using std::min;
75 using std::max;
76
77 namespace WebCore {
78
79 class PostMessageTimer : public TimerBase {
80 public:
81     PostMessageTimer(DOMWindow* window, PassRefPtr<MessageEvent> event, SecurityOrigin* targetOrigin)
82         : m_window(window)
83         , m_event(event)
84         , m_targetOrigin(targetOrigin)
85     {
86     }
87
88     MessageEvent* event() const { return m_event.get(); }
89     SecurityOrigin* targetOrigin() const { return m_targetOrigin.get(); }
90
91 private:
92     virtual void fired()
93     {
94         m_window->postMessageTimerFired(this);
95     }
96
97     RefPtr<DOMWindow> m_window;
98     RefPtr<MessageEvent> m_event;
99     RefPtr<SecurityOrigin> m_targetOrigin;
100 };
101
102 // This function:
103 // 1) Validates the pending changes are not changing to NaN
104 // 2) Constrains the window rect to no smaller than 100 in each dimension and no
105 //    bigger than the the float rect's dimensions.
106 // 3) Constrain window rect to within the top and left boundaries of the screen rect
107 // 4) Constraint the window rect to within the bottom and right boundaries of the
108 //    screen rect.
109 // 5) Translate the window rect coordinates to be within the coordinate space of
110 //    the screen rect.
111 void DOMWindow::adjustWindowRect(const FloatRect& screen, FloatRect& window, const FloatRect& pendingChanges)
112 {
113     // Make sure we're in a valid state before adjusting dimensions.
114     ASSERT(isfinite(screen.x()));
115     ASSERT(isfinite(screen.y()));
116     ASSERT(isfinite(screen.width()));
117     ASSERT(isfinite(screen.height()));
118     ASSERT(isfinite(window.x()));
119     ASSERT(isfinite(window.y()));
120     ASSERT(isfinite(window.width()));
121     ASSERT(isfinite(window.height()));
122     
123     // Update window values if new requested values are not NaN.
124     if (!isnan(pendingChanges.x()))
125         window.setX(pendingChanges.x());
126     if (!isnan(pendingChanges.y()))
127         window.setY(pendingChanges.y());
128     if (!isnan(pendingChanges.width()))
129         window.setWidth(pendingChanges.width());
130     if (!isnan(pendingChanges.height()))
131         window.setHeight(pendingChanges.height());
132     
133     // Resize the window to between 100 and the screen width and height.
134     window.setWidth(min(max(100.0f, window.width()), screen.width()));
135     window.setHeight(min(max(100.0f, window.height()), screen.height()));
136     
137     // Constrain the window position to the screen.
138     window.setX(max(screen.x(), min(window.x(), screen.right() - window.width())));
139     window.setY(max(screen.y(), min(window.y(), screen.bottom() - window.height())));
140 }
141
142 DOMWindow::DOMWindow(Frame* frame)
143     : m_frame(frame)
144 {
145 }
146
147 DOMWindow::~DOMWindow()
148 {
149     if (m_frame)
150         m_frame->clearFormerDOMWindow(this);
151 }
152
153 void DOMWindow::disconnectFrame()
154 {
155     m_frame = 0;
156     clear();
157 }
158
159 void DOMWindow::clear()
160 {
161     if (m_screen)
162         m_screen->disconnectFrame();
163     m_screen = 0;
164
165     if (m_selection)
166         m_selection->disconnectFrame();
167     m_selection = 0;
168
169     if (m_history)
170         m_history->disconnectFrame();
171     m_history = 0;
172
173     if (m_locationbar)
174         m_locationbar->disconnectFrame();
175     m_locationbar = 0;
176
177     if (m_menubar)
178         m_menubar->disconnectFrame();
179     m_menubar = 0;
180
181     if (m_personalbar)
182         m_personalbar->disconnectFrame();
183     m_personalbar = 0;
184
185     if (m_scrollbars)
186         m_scrollbars->disconnectFrame();
187     m_scrollbars = 0;
188
189     if (m_statusbar)
190         m_statusbar->disconnectFrame();
191     m_statusbar = 0;
192
193     if (m_toolbar)
194         m_toolbar->disconnectFrame();
195     m_toolbar = 0;
196
197     if (m_console)
198         m_console->disconnectFrame();
199     m_console = 0;
200
201     if (m_navigator)
202         m_navigator->disconnectFrame();
203     m_navigator = 0;
204
205     if (m_location)
206         m_location->disconnectFrame();
207     m_location = 0;
208     
209 #if ENABLE(DOM_STORAGE)
210     if (m_sessionStorage)
211         m_sessionStorage->disconnectFrame();
212     m_sessionStorage = 0;
213
214     if (m_localStorage)
215         m_localStorage->disconnectFrame();
216     m_localStorage = 0;
217 #endif
218
219 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
220     if (m_applicationCache)
221         m_applicationCache->disconnectFrame();
222     m_applicationCache = 0;
223 #endif
224 }
225
226 Screen* DOMWindow::screen() const
227 {
228     if (!m_screen)
229         m_screen = Screen::create(m_frame);
230     return m_screen.get();
231 }
232
233 History* DOMWindow::history() const
234 {
235     if (!m_history)
236         m_history = History::create(m_frame);
237     return m_history.get();
238 }
239
240 BarInfo* DOMWindow::locationbar() const
241 {
242     if (!m_locationbar)
243         m_locationbar = BarInfo::create(m_frame, BarInfo::Locationbar);
244     return m_locationbar.get();
245 }
246
247 BarInfo* DOMWindow::menubar() const
248 {
249     if (!m_menubar)
250         m_menubar = BarInfo::create(m_frame, BarInfo::Menubar);
251     return m_menubar.get();
252 }
253
254 BarInfo* DOMWindow::personalbar() const
255 {
256     if (!m_personalbar)
257         m_personalbar = BarInfo::create(m_frame, BarInfo::Personalbar);
258     return m_personalbar.get();
259 }
260
261 BarInfo* DOMWindow::scrollbars() const
262 {
263     if (!m_scrollbars)
264         m_scrollbars = BarInfo::create(m_frame, BarInfo::Scrollbars);
265     return m_scrollbars.get();
266 }
267
268 BarInfo* DOMWindow::statusbar() const
269 {
270     if (!m_statusbar)
271         m_statusbar = BarInfo::create(m_frame, BarInfo::Statusbar);
272     return m_statusbar.get();
273 }
274
275 BarInfo* DOMWindow::toolbar() const
276 {
277     if (!m_toolbar)
278         m_toolbar = BarInfo::create(m_frame, BarInfo::Toolbar);
279     return m_toolbar.get();
280 }
281
282 Console* DOMWindow::console() const
283 {
284     if (!m_console)
285         m_console = Console::create(m_frame);
286     return m_console.get();
287 }
288
289 #if ENABLE(OFFLINE_WEB_APPLICATIONS)
290 DOMApplicationCache* DOMWindow::applicationCache() const
291 {
292     if (!m_applicationCache)
293         m_applicationCache = DOMApplicationCache::create(m_frame);
294     return m_applicationCache.get();
295 }
296 #endif
297
298 Navigator* DOMWindow::navigator() const
299 {
300     if (!m_navigator)
301         m_navigator = Navigator::create(m_frame);
302     return m_navigator.get();
303 }
304
305 Location* DOMWindow::location() const
306 {
307     if (!m_location)
308         m_location = Location::create(m_frame);
309     return m_location.get();
310 }
311
312 #if ENABLE(DOM_STORAGE)
313 Storage* DOMWindow::sessionStorage() const
314 {
315     if (m_sessionStorage)
316         return m_sessionStorage.get();
317         
318     Page* page = m_frame->page();
319     if (!page)
320         return 0;
321
322     Document* document = m_frame->document();
323     if (!document)
324         return 0;
325
326     RefPtr<StorageArea> storageArea = page->sessionStorage()->storageArea(document->securityOrigin());
327     m_sessionStorage = Storage::create(m_frame, storageArea.release());
328     return m_sessionStorage.get();
329 }
330
331 Storage* DOMWindow::localStorage() const
332 {
333     Document* document = this->document();
334     if (!document)
335         return 0;
336         
337     Page* page = document->page();
338     if (!page)
339         return 0;
340     
341     LocalStorage* localStorage = page->group().localStorage();
342     RefPtr<StorageArea> storageArea = localStorage ? localStorage->storageArea(m_frame, document->securityOrigin()) : 0; 
343     if (storageArea)
344         m_localStorage = Storage::create(m_frame, storageArea.release());
345
346     return m_localStorage.get();
347 }
348 #endif
349
350 void DOMWindow::postMessage(const String& message, const String& targetOrigin, DOMWindow* source, ExceptionCode& ec)
351 {
352     if (!m_frame)
353         return;
354
355     // Compute the target origin.  We need to do this synchronously in order
356     // to generate the SYNTAX_ERR exception correctly.
357     RefPtr<SecurityOrigin> target;
358     if (targetOrigin != "*") {
359         target = SecurityOrigin::create(KURL(targetOrigin));
360         if (target->isEmpty()) {
361             ec = SYNTAX_ERR;
362             return;
363         }
364     }
365
366     // Capture the source of the message.  We need to do this synchronously
367     // in order to capture the source of the message correctly.
368     Document* sourceDocument = source->document();
369     if (!sourceDocument)
370         return;
371     String sourceOrigin = sourceDocument->securityOrigin()->toString();
372
373     // Schedule the message.
374     PostMessageTimer* timer = new PostMessageTimer(this, MessageEvent::create(message, sourceOrigin, "", source), target.get());
375     timer->startOneShot(0);
376 }
377
378 void DOMWindow::postMessageTimerFired(PostMessageTimer* t)
379 {
380     OwnPtr<PostMessageTimer> timer(t);
381
382     if (!document())
383         return;
384
385     if (timer->targetOrigin()) {
386         // Check target origin now since the target document may have changed since the simer was scheduled.
387         if (!timer->targetOrigin()->isSameSchemeHostPort(document()->securityOrigin())) {
388             String message = String::format("Unable to post message to %s. Recipient has origin %s.\n", 
389                 timer->targetOrigin()->toString().utf8().data(), document()->securityOrigin()->toString().utf8().data());
390             console()->addMessage(JSMessageSource, ErrorMessageLevel, message, 0, String());
391             return;
392         }
393     }
394
395     document()->dispatchWindowEvent(timer->event());
396 }
397
398 DOMSelection* DOMWindow::getSelection()
399 {
400     if (!m_selection)
401         m_selection = DOMSelection::create(m_frame);
402     return m_selection.get();
403 }
404
405 Element* DOMWindow::frameElement() const
406 {
407     if (!m_frame)
408         return 0;
409
410     return m_frame->ownerElement();
411 }
412
413 void DOMWindow::focus()
414 {
415     if (!m_frame)
416         return;
417
418     m_frame->focusWindow();
419 }
420
421 void DOMWindow::blur()
422 {
423     if (!m_frame)
424         return;
425
426     m_frame->unfocusWindow();
427 }
428
429 void DOMWindow::close()
430 {
431     if (!m_frame)
432         return;
433
434     if (m_frame->loader()->openedByDOM() || m_frame->loader()->getHistoryLength() <= 1)
435         m_frame->scheduleClose();
436 }
437
438 void DOMWindow::print()
439 {
440     if (!m_frame)
441         return;
442
443     Page* page = m_frame->page();
444     if (!page)
445         return;
446
447     page->chrome()->print(m_frame);
448 }
449
450 void DOMWindow::stop()
451 {
452     if (!m_frame)
453         return;
454
455     // We must check whether the load is complete asynchronously, because we might still be parsing
456     // the document until the callstack unwinds.
457     m_frame->loader()->stopForUserCancel(true);
458 }
459
460 void DOMWindow::alert(const String& message)
461 {
462     if (!m_frame)
463         return;
464
465     Document* doc = m_frame->document();
466     ASSERT(doc);
467     if (doc)
468         doc->updateRendering();
469
470     Page* page = m_frame->page();
471     if (!page)
472         return;
473
474     page->chrome()->runJavaScriptAlert(m_frame, message);
475 }
476
477 bool DOMWindow::confirm(const String& message)
478 {
479     if (!m_frame)
480         return false;
481
482     Document* doc = m_frame->document();
483     ASSERT(doc);
484     if (doc)
485         doc->updateRendering();
486
487     Page* page = m_frame->page();
488     if (!page)
489         return false;
490
491     return page->chrome()->runJavaScriptConfirm(m_frame, message);
492 }
493
494 String DOMWindow::prompt(const String& message, const String& defaultValue)
495 {
496     if (!m_frame)
497         return String();
498
499     Document* doc = m_frame->document();
500     ASSERT(doc);
501     if (doc)
502         doc->updateRendering();
503
504     Page* page = m_frame->page();
505     if (!page)
506         return String();
507
508     String returnValue;
509     if (page->chrome()->runJavaScriptPrompt(m_frame, message, defaultValue, returnValue))
510         return returnValue;
511
512     return String();
513 }
514
515 bool DOMWindow::find(const String& string, bool caseSensitive, bool backwards, bool wrap, bool wholeWord, bool searchInFrames, bool showDialog) const
516 {
517     if (!m_frame)
518         return false;
519
520     // FIXME (13016): Support wholeWord, searchInFrames and showDialog
521     return m_frame->findString(string, !backwards, caseSensitive, wrap, false);
522 }
523
524 bool DOMWindow::offscreenBuffering() const
525 {
526     return true;
527 }
528
529 int DOMWindow::outerHeight() const
530 {
531     if (!m_frame)
532         return 0;
533
534     Page* page = m_frame->page();
535     if (!page)
536         return 0;
537
538     return static_cast<int>(page->chrome()->windowRect().height());
539 }
540
541 int DOMWindow::outerWidth() const
542 {
543     if (!m_frame)
544         return 0;
545
546     Page* page = m_frame->page();
547     if (!page)
548         return 0;
549
550     return static_cast<int>(page->chrome()->windowRect().width());
551 }
552
553 int DOMWindow::innerHeight() const
554 {
555     if (!m_frame)
556         return 0;
557
558     FrameView* view = m_frame->view();
559     if (!view)
560         return 0;
561     
562     return view->height() / m_frame->pageZoomFactor();
563 }
564
565 int DOMWindow::innerWidth() const
566 {
567     if (!m_frame)
568         return 0;
569
570     FrameView* view = m_frame->view();
571     if (!view)
572         return 0;
573
574     return view->width() / m_frame->pageZoomFactor();
575 }
576
577 int DOMWindow::screenX() const
578 {
579     if (!m_frame)
580         return 0;
581
582     Page* page = m_frame->page();
583     if (!page)
584         return 0;
585
586     return static_cast<int>(page->chrome()->windowRect().x());
587 }
588
589 int DOMWindow::screenY() const
590 {
591     if (!m_frame)
592         return 0;
593
594     Page* page = m_frame->page();
595     if (!page)
596         return 0;
597
598     return static_cast<int>(page->chrome()->windowRect().y());
599 }
600
601 int DOMWindow::scrollX() const
602 {
603     if (!m_frame)
604         return 0;
605
606     FrameView* view = m_frame->view();
607     if (!view)
608         return 0;
609
610     Document* doc = m_frame->document();
611     ASSERT(doc);
612     if (doc)
613         doc->updateLayoutIgnorePendingStylesheets();
614
615     return view->contentsX() / m_frame->pageZoomFactor();
616 }
617
618 int DOMWindow::scrollY() const
619 {
620     if (!m_frame)
621         return 0;
622
623     FrameView* view = m_frame->view();
624     if (!view)
625         return 0;
626
627     Document* doc = m_frame->document();
628     ASSERT(doc);
629     if (doc)
630         doc->updateLayoutIgnorePendingStylesheets();
631
632     return view->contentsY() / m_frame->pageZoomFactor();
633 }
634
635 bool DOMWindow::closed() const
636 {
637     return !m_frame;
638 }
639
640 unsigned DOMWindow::length() const
641 {
642     if (!m_frame)
643         return 0;
644
645     return m_frame->tree()->childCount();
646 }
647
648 String DOMWindow::name() const
649 {
650     if (!m_frame)
651         return String();
652
653     return m_frame->tree()->name();
654 }
655
656 void DOMWindow::setName(const String& string)
657 {
658     if (!m_frame)
659         return;
660
661     m_frame->tree()->setName(string);
662 }
663
664 String DOMWindow::status() const
665 {
666     if (!m_frame)
667         return String();
668
669     return m_frame->jsStatusBarText();
670 }
671
672 void DOMWindow::setStatus(const String& string) 
673
674     if (!m_frame) 
675         return; 
676
677     m_frame->setJSStatusBarText(string); 
678
679     
680 String DOMWindow::defaultStatus() const
681 {
682     if (!m_frame)
683         return String();
684
685     return m_frame->jsDefaultStatusBarText();
686
687
688 void DOMWindow::setDefaultStatus(const String& string) 
689
690     if (!m_frame) 
691         return; 
692
693     m_frame->setJSDefaultStatusBarText(string);
694 }
695
696 DOMWindow* DOMWindow::self() const
697 {
698     if (!m_frame)
699         return 0;
700
701     return m_frame->domWindow();
702 }
703
704 DOMWindow* DOMWindow::opener() const
705 {
706     if (!m_frame)
707         return 0;
708
709     Frame* opener = m_frame->loader()->opener();
710     if (!opener)
711         return 0;
712
713     return opener->domWindow();
714 }
715
716 DOMWindow* DOMWindow::parent() const
717 {
718     if (!m_frame)
719         return 0;
720
721     Frame* parent = m_frame->tree()->parent(true);
722     if (parent)
723         return parent->domWindow();
724
725     return m_frame->domWindow();
726 }
727
728 DOMWindow* DOMWindow::top() const
729 {
730     if (!m_frame)
731         return 0;
732
733     Page* page = m_frame->page();
734     if (!page)
735         return 0;
736
737     return m_frame->tree()->top(true)->domWindow();
738 }
739
740 Document* DOMWindow::document() const
741 {
742     if (!m_frame)
743         return 0;
744
745     ASSERT(m_frame->document());
746     return m_frame->document();
747 }
748
749 PassRefPtr<CSSStyleDeclaration> DOMWindow::getComputedStyle(Element* elt, const String&) const
750 {
751     if (!elt)
752         return 0;
753
754     // FIXME: This needs take pseudo elements into account.
755     return computedStyle(elt);
756 }
757
758 PassRefPtr<CSSRuleList> DOMWindow::getMatchedCSSRules(Element* elt, const String& pseudoElt, bool authorOnly) const
759 {
760     if (!m_frame)
761         return 0;
762
763     Document* doc = m_frame->document();
764     ASSERT(doc);
765     if (!doc)
766         return 0;
767
768     if (!pseudoElt.isEmpty())
769         return doc->styleSelector()->pseudoStyleRulesForElement(elt, pseudoElt, authorOnly);
770     return doc->styleSelector()->styleRulesForElement(elt, authorOnly);
771 }
772
773 double DOMWindow::devicePixelRatio() const
774 {
775     if (!m_frame)
776         return 0.0;
777
778     Page* page = m_frame->page();
779     if (!page)
780         return 0.0;
781
782     return page->chrome()->scaleFactor();
783 }
784
785 #if ENABLE(DATABASE)
786 PassRefPtr<Database> DOMWindow::openDatabase(const String& name, const String& version, const String& displayName, unsigned long estimatedSize, ExceptionCode& ec)
787 {
788     if (!m_frame)
789         return 0;
790
791     Document* doc = m_frame->document();
792     ASSERT(doc);
793     if (!doc)
794         return 0;
795
796     return Database::openDatabase(doc, name, version, displayName, estimatedSize, ec);
797 }
798 #endif
799
800 void DOMWindow::scrollBy(int x, int y) const
801 {
802     if (!m_frame)
803         return;
804
805     Document* doc = m_frame->document();
806     ASSERT(doc);
807     if (doc)
808         doc->updateLayoutIgnorePendingStylesheets();
809
810     FrameView* view = m_frame->view();
811     if (!view)
812         return;
813
814     view->scrollBy(x, y);
815 }
816
817 void DOMWindow::scrollTo(int x, int y) const
818 {
819     if (!m_frame)
820         return;
821
822     Document* doc = m_frame->document();
823     ASSERT(doc);
824     if (doc)
825         doc->updateLayoutIgnorePendingStylesheets();
826
827     FrameView* view = m_frame->view();
828     if (!view)
829         return;
830
831     view->setContentsPos(x * m_frame->pageZoomFactor(), y * m_frame->pageZoomFactor());
832 }
833
834 void DOMWindow::moveBy(float x, float y) const
835 {
836     if (!m_frame)
837         return;
838
839     Page* page = m_frame->page();
840     if (!page)
841         return;
842
843     FloatRect fr = page->chrome()->windowRect();
844     FloatRect update = fr;
845     update.move(x, y);
846     // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
847     adjustWindowRect(screenAvailableRect(page->mainFrame()->view()), fr, update);
848     page->chrome()->setWindowRect(fr);
849 }
850
851 void DOMWindow::moveTo(float x, float y) const
852 {
853     if (!m_frame)
854         return;
855
856     Page* page = m_frame->page();
857     if (!page)
858         return;
859
860     FloatRect fr = page->chrome()->windowRect();
861     FloatRect sr = screenAvailableRect(page->mainFrame()->view());
862     fr.setLocation(sr.location());
863     FloatRect update = fr;
864     update.move(x, y);     
865     // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
866     adjustWindowRect(sr, fr, update);
867     page->chrome()->setWindowRect(fr);
868 }
869
870 void DOMWindow::resizeBy(float x, float y) const
871 {
872     if (!m_frame)
873         return;
874
875     Page* page = m_frame->page();
876     if (!page)
877         return;
878
879     FloatRect fr = page->chrome()->windowRect();
880     FloatSize dest = fr.size() + FloatSize(x, y);
881     FloatRect update(fr.location(), dest);
882     adjustWindowRect(screenAvailableRect(page->mainFrame()->view()), fr, update);
883     page->chrome()->setWindowRect(fr);
884 }
885
886 void DOMWindow::resizeTo(float width, float height) const
887 {
888     if (!m_frame)
889         return;
890
891     Page* page = m_frame->page();
892     if (!page)
893         return;
894
895     FloatRect fr = page->chrome()->windowRect();
896     FloatSize dest = FloatSize(width, height);
897     FloatRect update(fr.location(), dest);
898     adjustWindowRect(screenAvailableRect(page->mainFrame()->view()), fr, update);
899     page->chrome()->setWindowRect(fr);
900 }
901
902 } // namespace WebCore