[Chromium] DRT does not have LayoutTestController.pageSizeAndMarginsInPixels
[WebKit-https.git] / Source / WebKit / chromium / src / WebFrameImpl.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 // How ownership works
32 // -------------------
33 //
34 // Big oh represents a refcounted relationship: owner O--- ownee
35 //
36 // WebView (for the toplevel frame only)
37 //    O
38 //    |
39 //   Page O------- Frame (m_mainFrame) O-------O FrameView
40 //                   ||
41 //                   ||
42 //               FrameLoader O-------- WebFrame (via FrameLoaderClient)
43 //
44 // FrameLoader and Frame are formerly one object that was split apart because
45 // it got too big. They basically have the same lifetime, hence the double line.
46 //
47 // WebFrame is refcounted and has one ref on behalf of the FrameLoader/Frame.
48 // This is not a normal reference counted pointer because that would require
49 // changing WebKit code that we don't control. Instead, it is created with this
50 // ref initially and it is removed when the FrameLoader is getting destroyed.
51 //
52 // WebFrames are created in two places, first in WebViewImpl when the root
53 // frame is created, and second in WebFrame::CreateChildFrame when sub-frames
54 // are created. WebKit will hook up this object to the FrameLoader/Frame
55 // and the refcount will be correct.
56 //
57 // How frames are destroyed
58 // ------------------------
59 //
60 // The main frame is never destroyed and is re-used. The FrameLoader is re-used
61 // and a reference to the main frame is kept by the Page.
62 //
63 // When frame content is replaced, all subframes are destroyed. This happens
64 // in FrameLoader::detachFromParent for each subframe.
65 //
66 // Frame going away causes the FrameLoader to get deleted. In FrameLoader's
67 // destructor, it notifies its client with frameLoaderDestroyed. This calls
68 // WebFrame::Closing and then derefs the WebFrame and will cause it to be
69 // deleted (unless an external someone is also holding a reference).
70
71 #include "config.h"
72 #include "WebFrameImpl.h"
73
74 #include "AssociatedURLLoader.h"
75 #include "BackForwardController.h"
76 #include "Chrome.h"
77 #include "ClipboardUtilitiesChromium.h"
78 #include "Console.h"
79 #include "DOMUtilitiesPrivate.h"
80 #include "DOMWindow.h"
81 #include "Document.h"
82 #include "DocumentFragment.h" // Only needed for ReplaceSelectionCommand.h :(
83 #include "DocumentLoader.h"
84 #include "DocumentMarker.h"
85 #include "DocumentMarkerController.h"
86 #include "Editor.h"
87 #include "EventHandler.h"
88 #include "FocusController.h"
89 #include "FontCache.h"
90 #include "FormState.h"
91 #include "FrameLoadRequest.h"
92 #include "FrameLoader.h"
93 #include "FrameSelection.h"
94 #include "FrameTree.h"
95 #include "FrameView.h"
96 #include "HTMLCollection.h"
97 #include "HTMLFormElement.h"
98 #include "HTMLFrameOwnerElement.h"
99 #include "HTMLHeadElement.h"
100 #include "HTMLInputElement.h"
101 #include "HTMLLinkElement.h"
102 #include "HTMLNames.h"
103 #include "HistoryItem.h"
104 #include "HitTestResult.h"
105 #include "IconURL.h"
106 #include "InspectorController.h"
107 #include "KURL.h"
108 #include "Page.h"
109 #include "PageOverlay.h"
110 #include "painting/GraphicsContextBuilder.h"
111 #include "Performance.h"
112 #include "PlatformSupport.h"
113 #include "PluginDocument.h"
114 #include "PrintContext.h"
115 #include "RenderFrame.h"
116 #include "RenderLayer.h"
117 #include "RenderObject.h"
118 #include "RenderTreeAsText.h"
119 #include "RenderView.h"
120 #include "RenderWidget.h"
121 #include "ReplaceSelectionCommand.h"
122 #include "ResourceHandle.h"
123 #include "ResourceRequest.h"
124 #include "SVGDocumentExtensions.h"
125 #include "SVGSMILElement.h"
126 #include "SchemeRegistry.h"
127 #include "ScriptController.h"
128 #include "ScriptSourceCode.h"
129 #include "ScriptValue.h"
130 #include "ScrollTypes.h"
131 #include "ScrollbarTheme.h"
132 #include "SecurityPolicy.h"
133 #include "Settings.h"
134 #include "SkiaUtils.h"
135 #include "SubstituteData.h"
136 #include "TextAffinity.h"
137 #include "TextIterator.h"
138 #include "UserGestureIndicator.h"
139 #include "WebAnimationControllerImpl.h"
140 #include "WebConsoleMessage.h"
141 #include "WebDataSourceImpl.h"
142 #include "WebDocument.h"
143 #include "WebFindOptions.h"
144 #include "WebFormElement.h"
145 #include "WebFrameClient.h"
146 #include "WebHistoryItem.h"
147 #include "WebIconURL.h"
148 #include "WebInputElement.h"
149 #include "WebNode.h"
150 #include "WebPerformance.h"
151 #include "WebPlugin.h"
152 #include "WebPluginContainerImpl.h"
153 #include "WebPoint.h"
154 #include "WebRange.h"
155 #include "WebRect.h"
156 #include "WebScriptSource.h"
157 #include "WebSecurityOrigin.h"
158 #include "WebSize.h"
159 #include "WebURLError.h"
160 #include "WebVector.h"
161 #include "WebViewImpl.h"
162 #include "XPathResult.h"
163 #include "markup.h"
164
165 #include <algorithm>
166 #include <wtf/CurrentTime.h>
167
168 #if USE(V8)
169 #include "AsyncFileSystem.h"
170 #include "AsyncFileSystemChromium.h"
171 #include "DirectoryEntry.h"
172 #include "DOMFileSystem.h"
173 #include "FileEntry.h"
174 #include "V8DirectoryEntry.h"
175 #include "V8DOMFileSystem.h"
176 #include "V8FileEntry.h"
177 #include "WebFileSystem.h"
178 #endif
179
180 using namespace WebCore;
181
182 namespace WebKit {
183
184 static int frameCount = 0;
185
186 // Key for a StatsCounter tracking how many WebFrames are active.
187 static const char* const webFrameActiveCount = "WebFrameActiveCount";
188
189 // Backend for contentAsPlainText, this is a recursive function that gets
190 // the text for the current frame and all of its subframes. It will append
191 // the text of each frame in turn to the |output| up to |maxChars| length.
192 //
193 // The |frame| must be non-null.
194 static void frameContentAsPlainText(size_t maxChars, Frame* frame,
195                                     Vector<UChar>* output)
196 {
197     Document* doc = frame->document();
198     if (!doc)
199         return;
200
201     if (!frame->view())
202         return;
203
204     // TextIterator iterates over the visual representation of the DOM. As such,
205     // it requires you to do a layout before using it (otherwise it'll crash).
206     if (frame->view()->needsLayout())
207         frame->view()->layout();
208
209     // Select the document body.
210     RefPtr<Range> range(doc->createRange());
211     ExceptionCode exception = 0;
212     range->selectNodeContents(doc->body(), exception);
213
214     if (!exception) {
215         // The text iterator will walk nodes giving us text. This is similar to
216         // the plainText() function in TextIterator.h, but we implement the maximum
217         // size and also copy the results directly into a wstring, avoiding the
218         // string conversion.
219         for (TextIterator it(range.get()); !it.atEnd(); it.advance()) {
220             const UChar* chars = it.characters();
221             if (!chars) {
222                 if (it.length()) {
223                     // It appears from crash reports that an iterator can get into a state
224                     // where the character count is nonempty but the character pointer is
225                     // null. advance()ing it will then just add that many to the null
226                     // pointer which won't be caught in a null check but will crash.
227                     //
228                     // A null pointer and 0 length is common for some nodes.
229                     //
230                     // IF YOU CATCH THIS IN A DEBUGGER please let brettw know. We don't
231                     // currently understand the conditions for this to occur. Ideally, the
232                     // iterators would never get into the condition so we should fix them
233                     // if we can.
234                     ASSERT_NOT_REACHED();
235                     break;
236                 }
237
238                 // Just got a null node, we can forge ahead!
239                 continue;
240             }
241             size_t toAppend =
242                 std::min(static_cast<size_t>(it.length()), maxChars - output->size());
243             output->append(chars, toAppend);
244             if (output->size() >= maxChars)
245                 return; // Filled up the buffer.
246         }
247     }
248
249     // The separator between frames when the frames are converted to plain text.
250     const UChar frameSeparator[] = { '\n', '\n' };
251     const size_t frameSeparatorLen = 2;
252
253     // Recursively walk the children.
254     FrameTree* frameTree = frame->tree();
255     for (Frame* curChild = frameTree->firstChild(); curChild; curChild = curChild->tree()->nextSibling()) {
256         // Ignore the text of non-visible frames.
257         RenderView* contentRenderer = curChild->contentRenderer();
258         RenderPart* ownerRenderer = curChild->ownerRenderer();
259         if (!contentRenderer || !contentRenderer->width() || !contentRenderer->height()
260             || (contentRenderer->x() + contentRenderer->width() <= 0) || (contentRenderer->y() + contentRenderer->height() <= 0)
261             || (ownerRenderer && ownerRenderer->style() && ownerRenderer->style()->visibility() != VISIBLE)) {
262             continue;
263         }
264
265         // Make sure the frame separator won't fill up the buffer, and give up if
266         // it will. The danger is if the separator will make the buffer longer than
267         // maxChars. This will cause the computation above:
268         //   maxChars - output->size()
269         // to be a negative number which will crash when the subframe is added.
270         if (output->size() >= maxChars - frameSeparatorLen)
271             return;
272
273         output->append(frameSeparator, frameSeparatorLen);
274         frameContentAsPlainText(maxChars, curChild, output);
275         if (output->size() >= maxChars)
276             return; // Filled up the buffer.
277     }
278 }
279
280 static long long generateFrameIdentifier()
281 {
282     static long long next = 0;
283     return ++next;
284 }
285
286 static WebPluginContainerImpl* pluginContainerFromNode(const WebNode& node)
287 {
288     if (node.isNull())
289         return 0;
290
291     const Node* coreNode = node.constUnwrap<Node>();
292     if (coreNode->hasTagName(HTMLNames::objectTag) || coreNode->hasTagName(HTMLNames::embedTag)) {
293         RenderObject* object = coreNode->renderer();
294         if (object && object->isWidget()) {
295             Widget* widget = toRenderWidget(object)->widget();
296             if (widget && widget->isPluginContainer())
297                 return static_cast<WebPluginContainerImpl*>(widget);
298         }
299     }
300     return 0;
301 }
302
303 WebPluginContainerImpl* WebFrameImpl::pluginContainerFromFrame(Frame* frame)
304 {
305     if (!frame)
306         return 0;
307     if (!frame->document() || !frame->document()->isPluginDocument())
308         return 0;
309     PluginDocument* pluginDocument = static_cast<PluginDocument*>(frame->document());
310     return static_cast<WebPluginContainerImpl *>(pluginDocument->pluginWidget());
311 }
312
313 // Simple class to override some of PrintContext behavior. Some of the methods
314 // made virtual so that they can be overridden by ChromePluginPrintContext.
315 class ChromePrintContext : public PrintContext {
316     WTF_MAKE_NONCOPYABLE(ChromePrintContext);
317 public:
318     ChromePrintContext(Frame* frame)
319         : PrintContext(frame)
320         , m_printedPageWidth(0)
321     {
322     }
323
324     virtual ~ChromePrintContext() { }
325
326     virtual void begin(float width, float height)
327     {
328         ASSERT(!m_printedPageWidth);
329         m_printedPageWidth = width;
330         PrintContext::begin(m_printedPageWidth, height);
331     }
332
333     virtual void end()
334     {
335         PrintContext::end();
336     }
337
338     virtual float getPageShrink(int pageNumber) const
339     {
340         IntRect pageRect = m_pageRects[pageNumber];
341         return m_printedPageWidth / pageRect.width();
342     }
343
344     // Spools the printed page, a subrect of m_frame. Skip the scale step.
345     // NativeTheme doesn't play well with scaling. Scaling is done browser side
346     // instead. Returns the scale to be applied.
347     // On Linux, we don't have the problem with NativeTheme, hence we let WebKit
348     // do the scaling and ignore the return value.
349     virtual float spoolPage(GraphicsContext& ctx, int pageNumber)
350     {
351         IntRect pageRect = m_pageRects[pageNumber];
352         float scale = m_printedPageWidth / pageRect.width();
353
354         ctx.save();
355 #if OS(UNIX) && !OS(DARWIN)
356         ctx.scale(WebCore::FloatSize(scale, scale));
357 #endif
358         ctx.translate(static_cast<float>(-pageRect.x()),
359                       static_cast<float>(-pageRect.y()));
360         ctx.clip(pageRect);
361         m_frame->view()->paintContents(&ctx, pageRect);
362         ctx.restore();
363         return scale;
364     }
365
366     void spoolAllPagesWithBoundaries(GraphicsContext& graphicsContext, const FloatSize& pageSizeInPixels)
367     {
368         if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderer())
369             return;
370
371         m_frame->document()->updateLayout();
372
373         float pageHeight;
374         computePageRects(FloatRect(FloatPoint(0, 0), pageSizeInPixels), 0, 0, 1, pageHeight);
375
376         const float pageWidth = pageSizeInPixels.width();
377         size_t numPages = pageRects().size();
378         int totalHeight = numPages * (pageSizeInPixels.height() + 1) - 1;
379
380         // Fill the whole background by white.
381         graphicsContext.setFillColor(Color(255, 255, 255), ColorSpaceDeviceRGB);
382         graphicsContext.fillRect(FloatRect(0, 0, pageWidth, totalHeight));
383
384         graphicsContext.save();
385
386         int currentHeight = 0;
387         for (size_t pageIndex = 0; pageIndex < numPages; pageIndex++) {
388             // Draw a line for a page boundary if this isn't the first page.
389             if (pageIndex > 0) {
390                 graphicsContext.save();
391                 graphicsContext.setStrokeColor(Color(0, 0, 255), ColorSpaceDeviceRGB);
392                 graphicsContext.setFillColor(Color(0, 0, 255), ColorSpaceDeviceRGB);
393                 graphicsContext.drawLine(IntPoint(0, currentHeight),
394                                          IntPoint(pageWidth, currentHeight));
395                 graphicsContext.restore();
396             }
397
398             graphicsContext.save();
399
400             graphicsContext.translate(0, currentHeight);
401 #if !OS(UNIX) || OS(DARWIN)
402             // Account for the disabling of scaling in spoolPage. In the context
403             // of spoolAllPagesWithBoundaries the scale HAS NOT been pre-applied.
404             float scale = getPageShrink(pageIndex);
405             graphicsContext.scale(WebCore::FloatSize(scale, scale));
406 #endif
407             spoolPage(graphicsContext, pageIndex);
408             graphicsContext.restore();
409
410             currentHeight += pageSizeInPixels.height() + 1;
411         }
412
413         graphicsContext.restore();
414     }
415
416     virtual void computePageRects(const FloatRect& printRect, float headerHeight, float footerHeight, float userScaleFactor, float& outPageHeight)
417     {
418         return PrintContext::computePageRects(printRect, headerHeight, footerHeight, userScaleFactor, outPageHeight);
419     }
420
421     virtual int pageCount() const
422     {
423         return PrintContext::pageCount();
424     }
425
426     virtual bool shouldUseBrowserOverlays() const
427     {
428         return true;
429     }
430
431 private:
432     // Set when printing.
433     float m_printedPageWidth;
434 };
435
436 // Simple class to override some of PrintContext behavior. This is used when
437 // the frame hosts a plugin that supports custom printing. In this case, we
438 // want to delegate all printing related calls to the plugin.
439 class ChromePluginPrintContext : public ChromePrintContext {
440 public:
441     ChromePluginPrintContext(Frame* frame, WebPluginContainerImpl* plugin, int printerDPI)
442         : ChromePrintContext(frame), m_plugin(plugin), m_pageCount(0), m_printerDPI(printerDPI)
443     {
444     }
445
446     virtual ~ChromePluginPrintContext() { }
447
448     virtual void begin(float width, float height)
449     {
450     }
451
452     virtual void end()
453     {
454         m_plugin->printEnd();
455     }
456
457     virtual float getPageShrink(int pageNumber) const
458     {
459         // We don't shrink the page (maybe we should ask the widget ??)
460         return 1.0;
461     }
462
463     virtual void computePageRects(const FloatRect& printRect, float headerHeight, float footerHeight, float userScaleFactor, float& outPageHeight)
464     {
465         m_pageCount = m_plugin->printBegin(IntRect(printRect), m_printerDPI);
466     }
467
468     virtual int pageCount() const
469     {
470         return m_pageCount;
471     }
472
473     // Spools the printed page, a subrect of m_frame.  Skip the scale step.
474     // NativeTheme doesn't play well with scaling. Scaling is done browser side
475     // instead.  Returns the scale to be applied.
476     virtual float spoolPage(GraphicsContext& ctx, int pageNumber)
477     {
478         m_plugin->printPage(pageNumber, &ctx);
479         return 1.0;
480     }
481
482     virtual bool shouldUseBrowserOverlays() const
483     {
484         return false;
485     }
486
487 private:
488     // Set when printing.
489     WebPluginContainerImpl* m_plugin;
490     int m_pageCount;
491     int m_printerDPI;
492 };
493
494 static WebDataSource* DataSourceForDocLoader(DocumentLoader* loader)
495 {
496     return loader ? WebDataSourceImpl::fromDocumentLoader(loader) : 0;
497 }
498
499
500 // WebFrame -------------------------------------------------------------------
501
502 class WebFrameImpl::DeferredScopeStringMatches {
503 public:
504     DeferredScopeStringMatches(WebFrameImpl* webFrame,
505                                int identifier,
506                                const WebString& searchText,
507                                const WebFindOptions& options,
508                                bool reset)
509         : m_timer(this, &DeferredScopeStringMatches::doTimeout)
510         , m_webFrame(webFrame)
511         , m_identifier(identifier)
512         , m_searchText(searchText)
513         , m_options(options)
514         , m_reset(reset)
515     {
516         m_timer.startOneShot(0.0);
517     }
518
519 private:
520     void doTimeout(Timer<DeferredScopeStringMatches>*)
521     {
522         m_webFrame->callScopeStringMatches(
523             this, m_identifier, m_searchText, m_options, m_reset);
524     }
525
526     Timer<DeferredScopeStringMatches> m_timer;
527     RefPtr<WebFrameImpl> m_webFrame;
528     int m_identifier;
529     WebString m_searchText;
530     WebFindOptions m_options;
531     bool m_reset;
532 };
533
534
535 // WebFrame -------------------------------------------------------------------
536
537 int WebFrame::instanceCount()
538 {
539     return frameCount;
540 }
541
542 WebFrame* WebFrame::frameForEnteredContext()
543 {
544     Frame* frame =
545         ScriptController::retrieveFrameForEnteredContext();
546     return WebFrameImpl::fromFrame(frame);
547 }
548
549 WebFrame* WebFrame::frameForCurrentContext()
550 {
551     Frame* frame =
552         ScriptController::retrieveFrameForCurrentContext();
553     return WebFrameImpl::fromFrame(frame);
554 }
555
556 #if WEBKIT_USING_V8
557 WebFrame* WebFrame::frameForContext(v8::Handle<v8::Context> context)
558 {
559     return WebFrameImpl::fromFrame(V8Proxy::retrieveFrame(context));
560 }
561 #endif
562
563 WebFrame* WebFrame::fromFrameOwnerElement(const WebElement& element)
564 {
565     return WebFrameImpl::fromFrameOwnerElement(
566         PassRefPtr<Element>(element).get());
567 }
568
569 WebString WebFrameImpl::name() const
570 {
571     return m_frame->tree()->uniqueName();
572 }
573
574 void WebFrameImpl::setName(const WebString& name)
575 {
576     m_frame->tree()->setName(name);
577 }
578
579 long long WebFrameImpl::identifier() const
580 {
581     return m_identifier;
582 }
583
584 WebVector<WebIconURL> WebFrameImpl::iconURLs(int iconTypes) const
585 {
586     FrameLoader* frameLoader = m_frame->loader();
587     // The URL to the icon may be in the header. As such, only
588     // ask the loader for the icon if it's finished loading.
589     if (frameLoader->state() == FrameStateComplete)
590         return frameLoader->icon()->urlsForTypes(iconTypes);
591     return WebVector<WebIconURL>();
592 }
593
594 WebSize WebFrameImpl::scrollOffset() const
595 {
596     FrameView* view = frameView();
597     if (view)
598         return view->scrollOffset();
599
600     return WebSize();
601 }
602
603 WebSize WebFrameImpl::minimumScrollOffset() const
604 {
605     FrameView* view = frameView();
606     if (view)
607         return view->minimumScrollPosition() - IntPoint();
608
609     return WebSize();
610 }
611
612 WebSize WebFrameImpl::maximumScrollOffset() const
613 {
614     FrameView* view = frameView();
615     if (view)
616         return view->maximumScrollPosition() - IntPoint();
617
618     return WebSize();
619 }
620
621 void WebFrameImpl::setScrollOffset(const WebSize& offset)
622 {
623     if (FrameView* view = frameView())
624         view->setScrollOffset(IntPoint(offset.width, offset.height));
625 }
626
627 WebSize WebFrameImpl::contentsSize() const
628 {
629     return frame()->view()->contentsSize();
630 }
631
632 int WebFrameImpl::contentsPreferredWidth() const
633 {
634     if (m_frame->document() && m_frame->document()->renderView()) {
635         FontCachePurgePreventer fontCachePurgePreventer;
636
637         return m_frame->document()->renderView()->minPreferredLogicalWidth();
638     }
639     return 0;
640 }
641
642 int WebFrameImpl::documentElementScrollHeight() const
643 {
644     if (m_frame->document() && m_frame->document()->documentElement())
645         return m_frame->document()->documentElement()->scrollHeight();
646     return 0;
647 }
648
649 bool WebFrameImpl::hasVisibleContent() const
650 {
651     return frame()->view()->visibleWidth() > 0 && frame()->view()->visibleHeight() > 0;
652 }
653
654 bool WebFrameImpl::hasHorizontalScrollbar() const
655 {
656     return m_frame && m_frame->view() && m_frame->view()->horizontalScrollbar();
657 }
658
659 bool WebFrameImpl::hasVerticalScrollbar() const
660 {
661     return m_frame && m_frame->view() && m_frame->view()->verticalScrollbar();
662 }
663
664 WebView* WebFrameImpl::view() const
665 {
666     return viewImpl();
667 }
668
669 void WebFrameImpl::clearOpener()
670 {
671     m_frame->loader()->setOpener(0);
672 }
673
674 WebFrame* WebFrameImpl::opener() const
675 {
676     Frame* opener = 0;
677     if (m_frame)
678         opener = m_frame->loader()->opener();
679     return fromFrame(opener);
680 }
681
682 WebFrame* WebFrameImpl::parent() const
683 {
684     Frame* parent = 0;
685     if (m_frame)
686         parent = m_frame->tree()->parent();
687     return fromFrame(parent);
688 }
689
690 WebFrame* WebFrameImpl::top() const
691 {
692     if (m_frame)
693         return fromFrame(m_frame->tree()->top());
694
695     return 0;
696 }
697
698 WebFrame* WebFrameImpl::firstChild() const
699 {
700     return fromFrame(frame()->tree()->firstChild());
701 }
702
703 WebFrame* WebFrameImpl::lastChild() const
704 {
705     return fromFrame(frame()->tree()->lastChild());
706 }
707
708 WebFrame* WebFrameImpl::nextSibling() const
709 {
710     return fromFrame(frame()->tree()->nextSibling());
711 }
712
713 WebFrame* WebFrameImpl::previousSibling() const
714 {
715     return fromFrame(frame()->tree()->previousSibling());
716 }
717
718 WebFrame* WebFrameImpl::traverseNext(bool wrap) const
719 {
720     return fromFrame(frame()->tree()->traverseNextWithWrap(wrap));
721 }
722
723 WebFrame* WebFrameImpl::traversePrevious(bool wrap) const
724 {
725     return fromFrame(frame()->tree()->traversePreviousWithWrap(wrap));
726 }
727
728 WebFrame* WebFrameImpl::findChildByName(const WebString& name) const
729 {
730     return fromFrame(frame()->tree()->child(name));
731 }
732
733 WebFrame* WebFrameImpl::findChildByExpression(const WebString& xpath) const
734 {
735     if (xpath.isEmpty())
736         return 0;
737
738     Document* document = m_frame->document();
739
740     ExceptionCode ec = 0;
741     PassRefPtr<XPathResult> xpathResult =
742         document->evaluate(xpath,
743         document,
744         0, // namespace
745         XPathResult::ORDERED_NODE_ITERATOR_TYPE,
746         0, // XPathResult object
747         ec);
748     if (!xpathResult)
749         return 0;
750
751     Node* node = xpathResult->iterateNext(ec);
752
753     if (!node || !node->isFrameOwnerElement())
754         return 0;
755     HTMLFrameOwnerElement* frameElement =
756         static_cast<HTMLFrameOwnerElement*>(node);
757     return fromFrame(frameElement->contentFrame());
758 }
759
760 WebDocument WebFrameImpl::document() const
761 {
762     if (!m_frame || !m_frame->document())
763         return WebDocument();
764     return WebDocument(m_frame->document());
765 }
766
767 WebAnimationController* WebFrameImpl::animationController()
768 {
769     return &m_animationController;
770 }
771
772 WebPerformance WebFrameImpl::performance() const
773 {
774     if (!m_frame || !m_frame->domWindow())
775         return WebPerformance();
776
777     return WebPerformance(m_frame->domWindow()->performance());
778 }
779
780 NPObject* WebFrameImpl::windowObject() const
781 {
782     if (!m_frame)
783         return 0;
784
785     return m_frame->script()->windowScriptNPObject();
786 }
787
788 void WebFrameImpl::bindToWindowObject(const WebString& name, NPObject* object)
789 {
790     ASSERT(m_frame);
791     if (!m_frame || !m_frame->script()->canExecuteScripts(NotAboutToExecuteScript))
792         return;
793
794     String key = name;
795 #if USE(V8)
796     m_frame->script()->bindToWindowObject(m_frame, key, object);
797 #else
798     notImplemented();
799 #endif
800 }
801
802 void WebFrameImpl::executeScript(const WebScriptSource& source)
803 {
804     TextPosition position(OrdinalNumber::fromOneBasedInt(source.startLine), OrdinalNumber::first());
805     m_frame->script()->executeScript(
806         ScriptSourceCode(source.code, source.url, position));
807 }
808
809 void WebFrameImpl::executeScriptInIsolatedWorld(
810     int worldID, const WebScriptSource* sourcesIn, unsigned numSources,
811     int extensionGroup)
812 {
813     Vector<ScriptSourceCode> sources;
814
815     for (unsigned i = 0; i < numSources; ++i) {
816         TextPosition position(OrdinalNumber::fromOneBasedInt(sourcesIn[i].startLine), OrdinalNumber::first());
817         sources.append(ScriptSourceCode(
818             sourcesIn[i].code, sourcesIn[i].url, position));
819     }
820
821     m_frame->script()->evaluateInIsolatedWorld(worldID, sources, extensionGroup);
822 }
823
824 void WebFrameImpl::setIsolatedWorldSecurityOrigin(int worldID, const WebSecurityOrigin& securityOrigin)
825 {
826     m_frame->script()->setIsolatedWorldSecurityOrigin(worldID, securityOrigin.get());
827 }
828
829 void WebFrameImpl::addMessageToConsole(const WebConsoleMessage& message)
830 {
831     ASSERT(frame());
832
833     MessageLevel webCoreMessageLevel;
834     switch (message.level) {
835     case WebConsoleMessage::LevelTip:
836         webCoreMessageLevel = TipMessageLevel;
837         break;
838     case WebConsoleMessage::LevelLog:
839         webCoreMessageLevel = LogMessageLevel;
840         break;
841     case WebConsoleMessage::LevelWarning:
842         webCoreMessageLevel = WarningMessageLevel;
843         break;
844     case WebConsoleMessage::LevelError:
845         webCoreMessageLevel = ErrorMessageLevel;
846         break;
847     default:
848         ASSERT_NOT_REACHED();
849         return;
850     }
851
852     frame()->domWindow()->console()->addMessage(
853         OtherMessageSource, LogMessageType, webCoreMessageLevel, message.text,
854         1, String());
855 }
856
857 void WebFrameImpl::collectGarbage()
858 {
859     if (!m_frame)
860         return;
861     if (!m_frame->settings()->isScriptEnabled())
862         return;
863     // FIXME: Move this to the ScriptController and make it JS neutral.
864 #if USE(V8)
865     m_frame->script()->collectGarbage();
866 #else
867     notImplemented();
868 #endif
869 }
870
871 bool WebFrameImpl::checkIfRunInsecureContent(const WebURL& url) const
872 {
873     FrameLoader* frameLoader = m_frame->loader();
874     return frameLoader->checkIfRunInsecureContent(m_frame->document()->securityOrigin(), url);
875 }
876
877 #if USE(V8)
878 v8::Handle<v8::Value> WebFrameImpl::executeScriptAndReturnValue(const WebScriptSource& source)
879 {
880     // FIXME: This fake user gesture is required to make a bunch of pyauto
881     // tests pass. If this isn't needed in non-test situations, we should
882     // consider removing this code and changing the tests.
883     // http://code.google.com/p/chromium/issues/detail?id=86397
884     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
885
886     TextPosition position(OrdinalNumber::fromOneBasedInt(source.startLine), OrdinalNumber::first());
887     return m_frame->script()->executeScript(ScriptSourceCode(source.code, source.url, position)).v8Value();
888 }
889
890 // Returns the V8 context for this frame, or an empty handle if there is none.
891 v8::Local<v8::Context> WebFrameImpl::mainWorldScriptContext() const
892 {
893     if (!m_frame)
894         return v8::Local<v8::Context>();
895
896     return V8Proxy::mainWorldContext(m_frame);
897 }
898
899 v8::Handle<v8::Value> WebFrameImpl::createFileSystem(WebFileSystem::Type type,
900                                                      const WebString& name,
901                                                      const WebString& path)
902 {
903     return toV8(DOMFileSystem::create(frame()->document(), name, AsyncFileSystemChromium::create(static_cast<AsyncFileSystem::Type>(type), KURL(ParsedURLString, path.utf8().data()))));
904 }
905
906 v8::Handle<v8::Value> WebFrameImpl::createFileEntry(WebFileSystem::Type type,
907                                                     const WebString& fileSystemName,
908                                                     const WebString& fileSystemPath,
909                                                     const WebString& filePath,
910                                                     bool isDirectory)
911 {
912     RefPtr<DOMFileSystemBase> fileSystem = DOMFileSystem::create(frame()->document(), fileSystemName, AsyncFileSystemChromium::create(static_cast<AsyncFileSystem::Type>(type), KURL(ParsedURLString, fileSystemPath.utf8().data())));
913     if (isDirectory)
914         return toV8(DirectoryEntry::create(fileSystem, filePath));
915     return toV8(FileEntry::create(fileSystem, filePath));
916 }
917 #endif
918
919 void WebFrameImpl::reload(bool ignoreCache)
920 {
921     m_frame->loader()->history()->saveDocumentAndScrollState();
922     m_frame->loader()->reload(ignoreCache);
923 }
924
925 void WebFrameImpl::loadRequest(const WebURLRequest& request)
926 {
927     ASSERT(!request.isNull());
928     const ResourceRequest& resourceRequest = request.toResourceRequest();
929
930     if (resourceRequest.url().protocolIs("javascript")) {
931         loadJavaScriptURL(resourceRequest.url());
932         return;
933     }
934
935     m_frame->loader()->load(resourceRequest, false);
936 }
937
938 void WebFrameImpl::loadHistoryItem(const WebHistoryItem& item)
939 {
940     RefPtr<HistoryItem> historyItem = PassRefPtr<HistoryItem>(item);
941     ASSERT(historyItem);
942
943     m_frame->loader()->prepareForHistoryNavigation();
944     RefPtr<HistoryItem> currentItem = m_frame->loader()->history()->currentItem();
945     m_inSameDocumentHistoryLoad = currentItem->shouldDoSameDocumentNavigationTo(historyItem.get());
946     m_frame->page()->goToItem(historyItem.get(),
947                               FrameLoadTypeIndexedBackForward);
948     m_inSameDocumentHistoryLoad = false;
949 }
950
951 void WebFrameImpl::loadData(const WebData& data,
952                             const WebString& mimeType,
953                             const WebString& textEncoding,
954                             const WebURL& baseURL,
955                             const WebURL& unreachableURL,
956                             bool replace)
957 {
958     SubstituteData substData(data, mimeType, textEncoding, unreachableURL);
959     ASSERT(substData.isValid());
960
961     // If we are loading substitute data to replace an existing load, then
962     // inherit all of the properties of that original request.  This way,
963     // reload will re-attempt the original request.  It is essential that
964     // we only do this when there is an unreachableURL since a non-empty
965     // unreachableURL informs FrameLoader::reload to load unreachableURL
966     // instead of the currently loaded URL.
967     ResourceRequest request;
968     if (replace && !unreachableURL.isEmpty())
969         request = m_frame->loader()->originalRequest();
970     request.setURL(baseURL);
971
972     m_frame->loader()->load(request, substData, false);
973     if (replace) {
974         // Do this to force WebKit to treat the load as replacing the currently
975         // loaded page.
976         m_frame->loader()->setReplacing();
977     }
978 }
979
980 void WebFrameImpl::loadHTMLString(const WebData& data,
981                                   const WebURL& baseURL,
982                                   const WebURL& unreachableURL,
983                                   bool replace)
984 {
985     loadData(data,
986              WebString::fromUTF8("text/html"),
987              WebString::fromUTF8("UTF-8"),
988              baseURL,
989              unreachableURL,
990              replace);
991 }
992
993 bool WebFrameImpl::isLoading() const
994 {
995     if (!m_frame)
996         return false;
997     return m_frame->loader()->isLoading();
998 }
999
1000 void WebFrameImpl::stopLoading()
1001 {
1002     if (!m_frame)
1003       return;
1004
1005     // FIXME: Figure out what we should really do here.  It seems like a bug
1006     // that FrameLoader::stopLoading doesn't call stopAllLoaders.
1007     m_frame->loader()->stopAllLoaders();
1008     m_frame->loader()->stopLoading(UnloadEventPolicyNone);
1009 }
1010
1011 WebDataSource* WebFrameImpl::provisionalDataSource() const
1012 {
1013     FrameLoader* frameLoader = m_frame->loader();
1014
1015     // We regard the policy document loader as still provisional.
1016     DocumentLoader* docLoader = frameLoader->provisionalDocumentLoader();
1017     if (!docLoader)
1018         docLoader = frameLoader->policyDocumentLoader();
1019
1020     return DataSourceForDocLoader(docLoader);
1021 }
1022
1023 WebDataSource* WebFrameImpl::dataSource() const
1024 {
1025     return DataSourceForDocLoader(m_frame->loader()->documentLoader());
1026 }
1027
1028 WebHistoryItem WebFrameImpl::previousHistoryItem() const
1029 {
1030     // We use the previous item here because documentState (filled-out forms)
1031     // only get saved to history when it becomes the previous item.  The caller
1032     // is expected to query the history item after a navigation occurs, after
1033     // the desired history item has become the previous entry.
1034     return WebHistoryItem(m_frame->loader()->history()->previousItem());
1035 }
1036
1037 WebHistoryItem WebFrameImpl::currentHistoryItem() const
1038 {
1039     // We're shutting down.
1040     if (!m_frame->loader()->activeDocumentLoader())
1041         return WebHistoryItem();
1042
1043     // If we are still loading, then we don't want to clobber the current
1044     // history item as this could cause us to lose the scroll position and
1045     // document state.  However, it is OK for new navigations.
1046     // FIXME: Can we make this a plain old getter, instead of worrying about
1047     // clobbering here?
1048     if (!m_inSameDocumentHistoryLoad && (m_frame->loader()->loadType() == FrameLoadTypeStandard
1049         || !m_frame->loader()->activeDocumentLoader()->isLoadingInAPISense()))
1050         m_frame->loader()->history()->saveDocumentAndScrollState();
1051
1052     return WebHistoryItem(m_frame->page()->backForward()->currentItem());
1053 }
1054
1055 void WebFrameImpl::enableViewSourceMode(bool enable)
1056 {
1057     if (m_frame)
1058         m_frame->setInViewSourceMode(enable);
1059 }
1060
1061 bool WebFrameImpl::isViewSourceModeEnabled() const
1062 {
1063     if (m_frame)
1064         return m_frame->inViewSourceMode();
1065
1066     return false;
1067 }
1068
1069 void WebFrameImpl::setReferrerForRequest(WebURLRequest& request, const WebURL& referrerURL)
1070 {
1071     String referrer;
1072     if (referrerURL.isEmpty())
1073         referrer = m_frame->loader()->outgoingReferrer();
1074     else
1075         referrer = referrerURL.spec().utf16();
1076     if (SecurityPolicy::shouldHideReferrer(request.url(), referrer))
1077         return;
1078     request.setHTTPHeaderField(WebString::fromUTF8("Referer"), referrer);
1079 }
1080
1081 void WebFrameImpl::dispatchWillSendRequest(WebURLRequest& request)
1082 {
1083     ResourceResponse response;
1084     m_frame->loader()->client()->dispatchWillSendRequest(
1085         0, 0, request.toMutableResourceRequest(), response);
1086 }
1087
1088 WebURLLoader* WebFrameImpl::createAssociatedURLLoader(const WebURLLoaderOptions& options)
1089 {
1090     return new AssociatedURLLoader(this, options);
1091 }
1092
1093 void WebFrameImpl::commitDocumentData(const char* data, size_t length)
1094 {
1095     m_frame->loader()->documentLoader()->commitData(data, length);
1096 }
1097
1098 unsigned WebFrameImpl::unloadListenerCount() const
1099 {
1100     return frame()->domWindow()->pendingUnloadEventListeners();
1101 }
1102
1103 bool WebFrameImpl::isProcessingUserGesture() const
1104 {
1105     return ScriptController::processingUserGesture();
1106 }
1107
1108 bool WebFrameImpl::willSuppressOpenerInNewFrame() const
1109 {
1110     return frame()->loader()->suppressOpenerInNewFrame();
1111 }
1112
1113 void WebFrameImpl::replaceSelection(const WebString& text)
1114 {
1115     RefPtr<DocumentFragment> fragment = createFragmentFromText(
1116         frame()->selection()->toNormalizedRange().get(), text);
1117     applyCommand(ReplaceSelectionCommand::create(
1118         frame()->document(), fragment.get(), ReplaceSelectionCommand::SmartReplace | ReplaceSelectionCommand::MatchStyle | ReplaceSelectionCommand::PreventNesting));
1119 }
1120
1121 void WebFrameImpl::insertText(const WebString& text)
1122 {
1123     Editor* editor = frame()->editor();
1124
1125     if (editor->hasComposition())
1126         editor->confirmComposition(text);
1127     else
1128         editor->insertText(text, 0);
1129 }
1130
1131 void WebFrameImpl::setMarkedText(
1132     const WebString& text, unsigned location, unsigned length)
1133 {
1134     Editor* editor = frame()->editor();
1135
1136     Vector<CompositionUnderline> decorations;
1137     editor->setComposition(text, decorations, location, length);
1138 }
1139
1140 void WebFrameImpl::unmarkText()
1141 {
1142     frame()->editor()->cancelComposition();
1143 }
1144
1145 bool WebFrameImpl::hasMarkedText() const
1146 {
1147     return frame()->editor()->hasComposition();
1148 }
1149
1150 WebRange WebFrameImpl::markedRange() const
1151 {
1152     return frame()->editor()->compositionRange();
1153 }
1154
1155 void WebFrameImpl::setSelectionToRange(const WebRange& range)
1156 {
1157     if (frame()->selection()->isContentEditable()) {
1158         RefPtr<Range> replacementRange = PassRefPtr<Range>(range);
1159         frame()->selection()->setSelection(VisibleSelection(replacementRange.get(), SEL_DEFAULT_AFFINITY));
1160     }
1161 }
1162
1163 bool WebFrameImpl::firstRectForCharacterRange(unsigned location, unsigned length, WebRect& rect) const
1164 {
1165     if ((location + length < location) && (location + length))
1166         length = 0;
1167
1168     RefPtr<Range> range = TextIterator::rangeFromLocationAndLength(frame()->selection()->rootEditableElementOrDocumentElement(), location, length);
1169     if (!range)
1170         return false;
1171     IntRect intRect = frame()->editor()->firstRectForRange(range.get());
1172     rect = WebRect(intRect);
1173     rect = frame()->view()->contentsToWindow(rect);
1174
1175     return true;
1176 }
1177
1178 size_t WebFrameImpl::characterIndexForPoint(const WebPoint& webPoint) const
1179 {
1180     if (!frame())
1181         return notFound;
1182
1183     IntPoint point = frame()->view()->windowToContents(webPoint);
1184     HitTestResult result = frame()->eventHandler()->hitTestResultAtPoint(point, false);
1185     RefPtr<Range> range = frame()->rangeForPoint(result.point());
1186     if (!range)
1187         return notFound;
1188
1189     size_t location, length;
1190     TextIterator::getLocationAndLengthFromRange(frame()->selection()->rootEditableElementOrDocumentElement(), range.get(), location, length);
1191     return location;
1192 }
1193
1194 bool WebFrameImpl::executeCommand(const WebString& name, const WebNode& node)
1195 {
1196     ASSERT(frame());
1197
1198     if (name.length() <= 2)
1199         return false;
1200
1201     // Since we don't have NSControl, we will convert the format of command
1202     // string and call the function on Editor directly.
1203     String command = name;
1204
1205     // Make sure the first letter is upper case.
1206     command.replace(0, 1, command.substring(0, 1).upper());
1207
1208     // Remove the trailing ':' if existing.
1209     if (command[command.length() - 1] == UChar(':'))
1210         command = command.substring(0, command.length() - 1);
1211
1212     if (command == "Copy") {
1213         WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
1214         if (!pluginContainer)
1215             pluginContainer = pluginContainerFromNode(node);
1216         if (pluginContainer) {
1217             pluginContainer->copy();
1218             return true;
1219         }
1220     }
1221
1222     bool rv = true;
1223
1224     // Specially handling commands that Editor::execCommand does not directly
1225     // support.
1226     if (command == "DeleteToEndOfParagraph") {
1227         Editor* editor = frame()->editor();
1228         if (!editor->deleteWithDirection(DirectionForward,
1229                                          ParagraphBoundary,
1230                                          true,
1231                                          false)) {
1232             editor->deleteWithDirection(DirectionForward,
1233                                         CharacterGranularity,
1234                                         true,
1235                                         false);
1236         }
1237     } else if (command == "Indent")
1238         frame()->editor()->indent();
1239     else if (command == "Outdent")
1240         frame()->editor()->outdent();
1241     else if (command == "DeleteBackward")
1242         rv = frame()->editor()->command(AtomicString("BackwardDelete")).execute();
1243     else if (command == "DeleteForward")
1244         rv = frame()->editor()->command(AtomicString("ForwardDelete")).execute();
1245     else if (command == "AdvanceToNextMisspelling") {
1246         // False must be passed here, or the currently selected word will never be
1247         // skipped.
1248         frame()->editor()->advanceToNextMisspelling(false);
1249     } else if (command == "ToggleSpellPanel")
1250         frame()->editor()->showSpellingGuessPanel();
1251     else
1252         rv = frame()->editor()->command(command).execute();
1253     return rv;
1254 }
1255
1256 bool WebFrameImpl::executeCommand(const WebString& name, const WebString& value)
1257 {
1258     ASSERT(frame());
1259     String webName = name;
1260
1261     // moveToBeginningOfDocument and moveToEndfDocument are only handled by WebKit
1262     // for editable nodes.
1263     if (!frame()->editor()->canEdit() && webName == "moveToBeginningOfDocument")
1264         return viewImpl()->propagateScroll(ScrollUp, ScrollByDocument);
1265
1266     if (!frame()->editor()->canEdit() && webName == "moveToEndOfDocument")
1267         return viewImpl()->propagateScroll(ScrollDown, ScrollByDocument);
1268
1269     return frame()->editor()->command(webName).execute(value);
1270 }
1271
1272 bool WebFrameImpl::isCommandEnabled(const WebString& name) const
1273 {
1274     ASSERT(frame());
1275     return frame()->editor()->command(name).isEnabled();
1276 }
1277
1278 void WebFrameImpl::enableContinuousSpellChecking(bool enable)
1279 {
1280     if (enable == isContinuousSpellCheckingEnabled())
1281         return;
1282     frame()->editor()->toggleContinuousSpellChecking();
1283 }
1284
1285 bool WebFrameImpl::isContinuousSpellCheckingEnabled() const
1286 {
1287     return frame()->editor()->isContinuousSpellCheckingEnabled();
1288 }
1289
1290 bool WebFrameImpl::hasSelection() const
1291 {
1292     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
1293     if (pluginContainer)
1294         return pluginContainer->plugin()->hasSelection();
1295
1296     // frame()->selection()->isNone() never returns true.
1297     return (frame()->selection()->start() != frame()->selection()->end());
1298 }
1299
1300 WebRange WebFrameImpl::selectionRange() const
1301 {
1302     return frame()->selection()->toNormalizedRange();
1303 }
1304
1305 WebString WebFrameImpl::selectionAsText() const
1306 {
1307     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
1308     if (pluginContainer)
1309         return pluginContainer->plugin()->selectionAsText();
1310
1311     RefPtr<Range> range = frame()->selection()->toNormalizedRange();
1312     if (!range)
1313         return WebString();
1314
1315     String text = range->text();
1316 #if OS(WINDOWS)
1317     replaceNewlinesWithWindowsStyleNewlines(text);
1318 #endif
1319     replaceNBSPWithSpace(text);
1320     return text;
1321 }
1322
1323 WebString WebFrameImpl::selectionAsMarkup() const
1324 {
1325     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
1326     if (pluginContainer)
1327         return pluginContainer->plugin()->selectionAsMarkup();
1328
1329     RefPtr<Range> range = frame()->selection()->toNormalizedRange();
1330     if (!range)
1331         return WebString();
1332
1333     return createMarkup(range.get(), 0);
1334 }
1335
1336 void WebFrameImpl::selectWordAroundPosition(Frame* frame, VisiblePosition pos)
1337 {
1338     VisibleSelection selection(pos);
1339     selection.expandUsingGranularity(WordGranularity);
1340
1341     if (frame->selection()->shouldChangeSelection(selection)) {
1342         TextGranularity granularity = selection.isRange() ? WordGranularity : CharacterGranularity;
1343         frame->selection()->setSelection(selection, granularity);
1344     }
1345 }
1346
1347 bool WebFrameImpl::selectWordAroundCaret()
1348 {
1349     FrameSelection* selection = frame()->selection();
1350     ASSERT(!selection->isNone());
1351     if (selection->isNone() || selection->isRange())
1352         return false;
1353     selectWordAroundPosition(frame(), selection->selection().visibleStart());
1354     return true;
1355 }
1356
1357 void WebFrameImpl::selectRange(const WebPoint& start, const WebPoint& end)
1358 {
1359     VisibleSelection selection(visiblePositionForWindowPoint(start),
1360                                visiblePositionForWindowPoint(end));
1361
1362     if (frame()->selection()->shouldChangeSelection(selection))
1363         frame()->selection()->setSelection(selection, CharacterGranularity);
1364 }
1365
1366 VisiblePosition WebFrameImpl::visiblePositionForWindowPoint(const WebPoint& point)
1367 {
1368     HitTestRequest::HitTestRequestType hitType = HitTestRequest::MouseMove;
1369     hitType |= HitTestRequest::ReadOnly;
1370     hitType |= HitTestRequest::Active;
1371     HitTestRequest request(hitType);
1372     FrameView* view = frame()->view();
1373     HitTestResult result(view->windowToContents(
1374         view->convertFromContainingWindow(IntPoint(point.x, point.y))));
1375
1376     frame()->document()->renderView()->layer()->hitTest(request, result);
1377
1378     // Matching the logic in MouseEventWithHitTestResults::targetNode()
1379     Node* node = result.innerNode();
1380     if (!node)
1381         return VisiblePosition();
1382     Element* element = node->parentElement();
1383     if (!node->inDocument() && element && element->inDocument())
1384         node = element;
1385
1386     return node->renderer()->positionForPoint(result.localPoint());
1387 }
1388
1389 int WebFrameImpl::printBegin(const WebSize& pageSize,
1390                              const WebNode& constrainToNode,
1391                              int printerDPI,
1392                              bool* useBrowserOverlays)
1393 {
1394     ASSERT(!frame()->document()->isFrameSet());
1395     WebPluginContainerImpl* pluginContainer = 0;
1396     if (constrainToNode.isNull()) {
1397         // If this is a plugin document, check if the plugin supports its own
1398         // printing. If it does, we will delegate all printing to that.
1399         pluginContainer = pluginContainerFromFrame(frame());
1400     } else {
1401         // We only support printing plugin nodes for now.
1402         pluginContainer = pluginContainerFromNode(constrainToNode);
1403     }
1404
1405     if (pluginContainer && pluginContainer->supportsPaginatedPrint())
1406         m_printContext = adoptPtr(new ChromePluginPrintContext(frame(), pluginContainer, printerDPI));
1407     else
1408         m_printContext = adoptPtr(new ChromePrintContext(frame()));
1409
1410     FloatRect rect(0, 0, static_cast<float>(pageSize.width),
1411                          static_cast<float>(pageSize.height));
1412     m_printContext->begin(rect.width(), rect.height());
1413     float pageHeight;
1414     // We ignore the overlays calculation for now since they are generated in the
1415     // browser. pageHeight is actually an output parameter.
1416     m_printContext->computePageRects(rect, 0, 0, 1.0, pageHeight);
1417     if (useBrowserOverlays)
1418         *useBrowserOverlays = m_printContext->shouldUseBrowserOverlays();
1419
1420     return m_printContext->pageCount();
1421 }
1422
1423 float WebFrameImpl::getPrintPageShrink(int page)
1424 {
1425     // Ensure correct state.
1426     if (!m_printContext || page < 0) {
1427         ASSERT_NOT_REACHED();
1428         return 0;
1429     }
1430
1431     return m_printContext->getPageShrink(page);
1432 }
1433
1434 float WebFrameImpl::printPage(int page, WebCanvas* canvas)
1435 {
1436     // Ensure correct state.
1437     if (!m_printContext || page < 0 || !frame() || !frame()->document()) {
1438         ASSERT_NOT_REACHED();
1439         return 0;
1440     }
1441
1442     GraphicsContextBuilder builder(canvas);
1443     GraphicsContext& gc = builder.context();
1444 #if WEBKIT_USING_SKIA
1445     gc.platformContext()->setPrinting(true);
1446 #endif
1447
1448     return m_printContext->spoolPage(gc, page);
1449 }
1450
1451 void WebFrameImpl::printEnd()
1452 {
1453     ASSERT(m_printContext);
1454     if (m_printContext)
1455         m_printContext->end();
1456     m_printContext.clear();
1457 }
1458
1459 bool WebFrameImpl::isPrintScalingDisabledForPlugin(const WebNode& node)
1460 {
1461     WebPluginContainerImpl* pluginContainer = 0;
1462     if (node.isNull())
1463         pluginContainer = pluginContainerFromFrame(frame());
1464     else
1465         pluginContainer = pluginContainerFromNode(node);
1466
1467     if (!pluginContainer || !pluginContainer->supportsPaginatedPrint())
1468         return false;
1469
1470     return pluginContainer->isPrintScalingDisabled();
1471 }
1472
1473 bool WebFrameImpl::isPageBoxVisible(int pageIndex)
1474 {
1475     return frame()->document()->isPageBoxVisible(pageIndex);
1476 }
1477
1478 void WebFrameImpl::pageSizeAndMarginsInPixels(int pageIndex,
1479                                               WebSize& pageSize,
1480                                               int& marginTop,
1481                                               int& marginRight,
1482                                               int& marginBottom,
1483                                               int& marginLeft)
1484 {
1485     IntSize size(pageSize.width, pageSize.height);
1486     frame()->document()->pageSizeAndMarginsInPixels(pageIndex,
1487                                                     size,
1488                                                     marginTop,
1489                                                     marginRight,
1490                                                     marginBottom,
1491                                                     marginLeft);
1492     pageSize = size;
1493 }
1494
1495 WebString WebFrameImpl::pageProperty(const WebString& propertyName, int pageIndex)
1496 {
1497     ASSERT(m_printContext);
1498     return m_printContext->pageProperty(m_frame, propertyName.utf8().data(), pageIndex);
1499 }
1500
1501 bool WebFrameImpl::find(int identifier,
1502                         const WebString& searchText,
1503                         const WebFindOptions& options,
1504                         bool wrapWithinFrame,
1505                         WebRect* selectionRect)
1506 {
1507     WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl();
1508
1509     if (!options.findNext)
1510         frame()->page()->unmarkAllTextMatches();
1511     else
1512         setMarkerActive(m_activeMatch.get(), false); // Active match is changing.
1513
1514     // Starts the search from the current selection.
1515     bool startInSelection = true;
1516
1517     // If the user has selected something since the last Find operation we want
1518     // to start from there. Otherwise, we start searching from where the last Find
1519     // operation left off (either a Find or a FindNext operation).
1520     VisibleSelection selection(frame()->selection()->selection());
1521     bool activeSelection = !selection.isNone();
1522     if (!activeSelection && m_activeMatch) {
1523         selection = VisibleSelection(m_activeMatch.get());
1524         frame()->selection()->setSelection(selection);
1525     }
1526
1527     ASSERT(frame() && frame()->view());
1528     bool found = frame()->editor()->findString(
1529         searchText, options.forward, options.matchCase, wrapWithinFrame,
1530         startInSelection);
1531     if (found) {
1532         // Store which frame was active. This will come in handy later when we
1533         // change the active match ordinal below.
1534         WebFrameImpl* oldActiveFrame = mainFrameImpl->m_activeMatchFrame;
1535         // Set this frame as the active frame (the one with the active highlight).
1536         mainFrameImpl->m_activeMatchFrame = this;
1537
1538         // We found something, so we can now query the selection for its position.
1539         VisibleSelection newSelection(frame()->selection()->selection());
1540         IntRect currSelectionRect;
1541
1542         // If we thought we found something, but it couldn't be selected (perhaps
1543         // because it was marked -webkit-user-select: none), we can't set it to
1544         // be active but we still continue searching. This matches Safari's
1545         // behavior, including some oddities when selectable and un-selectable text
1546         // are mixed on a page: see https://bugs.webkit.org/show_bug.cgi?id=19127.
1547         if (newSelection.isNone() || (newSelection.start() == newSelection.end()))
1548             m_activeMatch = 0;
1549         else {
1550             m_activeMatch = newSelection.toNormalizedRange();
1551             currSelectionRect = m_activeMatch->boundingBox();
1552             setMarkerActive(m_activeMatch.get(), true); // Active.
1553             // WebKit draws the highlighting for all matches.
1554             executeCommand(WebString::fromUTF8("Unselect"));
1555         }
1556
1557         // Make sure no node is focused. See http://crbug.com/38700.
1558         frame()->document()->setFocusedNode(0);
1559
1560         if (!options.findNext || activeSelection) {
1561             // This is either a Find operation or a Find-next from a new start point
1562             // due to a selection, so we set the flag to ask the scoping effort
1563             // to find the active rect for us so we can update the ordinal (n of m).
1564             m_locatingActiveRect = true;
1565         } else {
1566             if (oldActiveFrame != this) {
1567                 // If the active frame has changed it means that we have a multi-frame
1568                 // page and we just switch to searching in a new frame. Then we just
1569                 // want to reset the index.
1570                 if (options.forward)
1571                     m_activeMatchIndex = 0;
1572                 else
1573                     m_activeMatchIndex = m_lastMatchCount - 1;
1574             } else {
1575                 // We are still the active frame, so increment (or decrement) the
1576                 // |m_activeMatchIndex|, wrapping if needed (on single frame pages).
1577                 options.forward ? ++m_activeMatchIndex : --m_activeMatchIndex;
1578                 if (m_activeMatchIndex + 1 > m_lastMatchCount)
1579                     m_activeMatchIndex = 0;
1580                 if (m_activeMatchIndex == -1)
1581                     m_activeMatchIndex = m_lastMatchCount - 1;
1582             }
1583             if (selectionRect) {
1584                 *selectionRect = frameView()->contentsToWindow(currSelectionRect);
1585                 reportFindInPageSelection(*selectionRect, m_activeMatchIndex + 1, identifier);
1586             }
1587         }
1588     } else {
1589         // Nothing was found in this frame.
1590         m_activeMatch = 0;
1591
1592         // Erase all previous tickmarks and highlighting.
1593         invalidateArea(InvalidateAll);
1594     }
1595
1596     return found;
1597 }
1598
1599 void WebFrameImpl::stopFinding(bool clearSelection)
1600 {
1601     if (!clearSelection)
1602         setFindEndstateFocusAndSelection();
1603     cancelPendingScopingEffort();
1604
1605     // Remove all markers for matches found and turn off the highlighting.
1606     frame()->document()->markers()->removeMarkers(DocumentMarker::TextMatch);
1607     frame()->editor()->setMarkedTextMatchesAreHighlighted(false);
1608
1609     // Let the frame know that we don't want tickmarks or highlighting anymore.
1610     invalidateArea(InvalidateAll);
1611 }
1612
1613 void WebFrameImpl::scopeStringMatches(int identifier,
1614                                       const WebString& searchText,
1615                                       const WebFindOptions& options,
1616                                       bool reset)
1617 {
1618     if (!shouldScopeMatches(searchText))
1619         return;
1620
1621     WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl();
1622
1623     if (reset) {
1624         // This is a brand new search, so we need to reset everything.
1625         // Scoping is just about to begin.
1626         m_scopingComplete = false;
1627         // Clear highlighting for this frame.
1628         if (frame()->editor()->markedTextMatchesAreHighlighted())
1629             frame()->page()->unmarkAllTextMatches();
1630         // Clear the counters from last operation.
1631         m_lastMatchCount = 0;
1632         m_nextInvalidateAfter = 0;
1633
1634         m_resumeScopingFromRange = 0;
1635
1636         mainFrameImpl->m_framesScopingCount++;
1637
1638         // Now, defer scoping until later to allow find operation to finish quickly.
1639         scopeStringMatchesSoon(
1640             identifier,
1641             searchText,
1642             options,
1643             false); // false=we just reset, so don't do it again.
1644         return;
1645     }
1646
1647     RefPtr<Range> searchRange(rangeOfContents(frame()->document()));
1648
1649     Node* originalEndContainer = searchRange->endContainer();
1650     int originalEndOffset = searchRange->endOffset();
1651
1652     ExceptionCode ec = 0, ec2 = 0;
1653     if (m_resumeScopingFromRange) {
1654         // This is a continuation of a scoping operation that timed out and didn't
1655         // complete last time around, so we should start from where we left off.
1656         searchRange->setStart(m_resumeScopingFromRange->startContainer(),
1657                               m_resumeScopingFromRange->startOffset(ec2) + 1,
1658                               ec);
1659         if (ec || ec2) {
1660             if (ec2) // A non-zero |ec| happens when navigating during search.
1661                 ASSERT_NOT_REACHED();
1662             return;
1663         }
1664     }
1665
1666     // This timeout controls how long we scope before releasing control.  This
1667     // value does not prevent us from running for longer than this, but it is
1668     // periodically checked to see if we have exceeded our allocated time.
1669     const double maxScopingDuration = 0.1; // seconds
1670
1671     int matchCount = 0;
1672     bool timedOut = false;
1673     double startTime = currentTime();
1674     do {
1675         // Find next occurrence of the search string.
1676         // FIXME: (http://b/1088245) This WebKit operation may run for longer
1677         // than the timeout value, and is not interruptible as it is currently
1678         // written. We may need to rewrite it with interruptibility in mind, or
1679         // find an alternative.
1680         RefPtr<Range> resultRange(findPlainText(searchRange.get(),
1681                                                 searchText,
1682                                                 options.matchCase ? 0 : CaseInsensitive));
1683         if (resultRange->collapsed(ec)) {
1684             if (!resultRange->startContainer()->isInShadowTree())
1685                 break;
1686
1687             searchRange->setStartAfter(
1688                 resultRange->startContainer()->shadowAncestorNode(), ec);
1689             searchRange->setEnd(originalEndContainer, originalEndOffset, ec);
1690             continue;
1691         }
1692
1693         // Only treat the result as a match if it is visible
1694         if (frame()->editor()->insideVisibleArea(resultRange.get())) {
1695             ++matchCount;
1696
1697             // Catch a special case where Find found something but doesn't know what
1698             // the bounding box for it is. In this case we set the first match we find
1699             // as the active rect.
1700             IntRect resultBounds = resultRange->boundingBox();
1701             IntRect activeSelectionRect;
1702             if (m_locatingActiveRect) {
1703                 activeSelectionRect = m_activeMatch.get() ?
1704                     m_activeMatch->boundingBox() : resultBounds;
1705             }
1706
1707             // If the Find function found a match it will have stored where the
1708             // match was found in m_activeSelectionRect on the current frame. If we
1709             // find this rect during scoping it means we have found the active
1710             // tickmark.
1711             bool foundActiveMatch = false;
1712             if (m_locatingActiveRect && (activeSelectionRect == resultBounds)) {
1713                 // We have found the active tickmark frame.
1714                 mainFrameImpl->m_activeMatchFrame = this;
1715                 foundActiveMatch = true;
1716                 // We also know which tickmark is active now.
1717                 m_activeMatchIndex = matchCount - 1;
1718                 // To stop looking for the active tickmark, we set this flag.
1719                 m_locatingActiveRect = false;
1720
1721                 // Notify browser of new location for the selected rectangle.
1722                 reportFindInPageSelection(
1723                     frameView()->contentsToWindow(resultBounds),
1724                     m_activeMatchIndex + 1,
1725                     identifier);
1726             }
1727
1728             addMarker(resultRange.get(), foundActiveMatch);
1729         }
1730
1731         // Set the new start for the search range to be the end of the previous
1732         // result range. There is no need to use a VisiblePosition here,
1733         // since findPlainText will use a TextIterator to go over the visible
1734         // text nodes.
1735         searchRange->setStart(resultRange->endContainer(ec), resultRange->endOffset(ec), ec);
1736
1737         Node* shadowTreeRoot = searchRange->shadowTreeRootNode();
1738         if (searchRange->collapsed(ec) && shadowTreeRoot)
1739             searchRange->setEnd(shadowTreeRoot, shadowTreeRoot->childNodeCount(), ec);
1740
1741         m_resumeScopingFromRange = resultRange;
1742         timedOut = (currentTime() - startTime) >= maxScopingDuration;
1743     } while (!timedOut);
1744
1745     // Remember what we search for last time, so we can skip searching if more
1746     // letters are added to the search string (and last outcome was 0).
1747     m_lastSearchString = searchText;
1748
1749     if (matchCount > 0) {
1750         frame()->editor()->setMarkedTextMatchesAreHighlighted(true);
1751
1752         m_lastMatchCount += matchCount;
1753
1754         // Let the mainframe know how much we found during this pass.
1755         mainFrameImpl->increaseMatchCount(matchCount, identifier);
1756     }
1757
1758     if (timedOut) {
1759         // If we found anything during this pass, we should redraw. However, we
1760         // don't want to spam too much if the page is extremely long, so if we
1761         // reach a certain point we start throttling the redraw requests.
1762         if (matchCount > 0)
1763             invalidateIfNecessary();
1764
1765         // Scoping effort ran out of time, lets ask for another time-slice.
1766         scopeStringMatchesSoon(
1767             identifier,
1768             searchText,
1769             options,
1770             false); // don't reset.
1771         return; // Done for now, resume work later.
1772     }
1773
1774     // This frame has no further scoping left, so it is done. Other frames might,
1775     // of course, continue to scope matches.
1776     m_scopingComplete = true;
1777     mainFrameImpl->m_framesScopingCount--;
1778
1779     // If this is the last frame to finish scoping we need to trigger the final
1780     // update to be sent.
1781     if (!mainFrameImpl->m_framesScopingCount)
1782         mainFrameImpl->increaseMatchCount(0, identifier);
1783
1784     // This frame is done, so show any scrollbar tickmarks we haven't drawn yet.
1785     invalidateArea(InvalidateScrollbar);
1786 }
1787
1788 void WebFrameImpl::cancelPendingScopingEffort()
1789 {
1790     deleteAllValues(m_deferredScopingWork);
1791     m_deferredScopingWork.clear();
1792
1793     m_activeMatchIndex = -1;
1794 }
1795
1796 void WebFrameImpl::increaseMatchCount(int count, int identifier)
1797 {
1798     // This function should only be called on the mainframe.
1799     ASSERT(!parent());
1800
1801     m_totalMatchCount += count;
1802
1803     // Update the UI with the latest findings.
1804     if (client())
1805         client()->reportFindInPageMatchCount(identifier, m_totalMatchCount, !m_framesScopingCount);
1806 }
1807
1808 void WebFrameImpl::reportFindInPageSelection(const WebRect& selectionRect,
1809                                              int activeMatchOrdinal,
1810                                              int identifier)
1811 {
1812     // Update the UI with the latest selection rect.
1813     if (client())
1814         client()->reportFindInPageSelection(identifier, ordinalOfFirstMatchForFrame(this) + activeMatchOrdinal, selectionRect);
1815 }
1816
1817 void WebFrameImpl::resetMatchCount()
1818 {
1819     m_totalMatchCount = 0;
1820     m_framesScopingCount = 0;
1821 }
1822
1823 WebString WebFrameImpl::contentAsText(size_t maxChars) const
1824 {
1825     if (!m_frame)
1826         return WebString();
1827
1828     Vector<UChar> text;
1829     frameContentAsPlainText(maxChars, m_frame, &text);
1830     return String::adopt(text);
1831 }
1832
1833 WebString WebFrameImpl::contentAsMarkup() const
1834 {
1835     return createFullMarkup(m_frame->document());
1836 }
1837
1838 WebString WebFrameImpl::renderTreeAsText(RenderAsTextControls toShow) const
1839 {
1840     RenderAsTextBehavior behavior = RenderAsTextBehaviorNormal;
1841
1842     if (toShow & RenderAsTextDebug) {
1843         behavior |= RenderAsTextShowCompositedLayers
1844             | RenderAsTextShowAddresses
1845             | RenderAsTextShowIDAndClass
1846             | RenderAsTextShowLayerNesting;
1847     }
1848
1849     if (toShow & RenderAsTextPrinting)
1850         behavior |= RenderAsTextPrintingMode;
1851
1852     return externalRepresentation(m_frame, behavior);
1853 }
1854
1855 WebString WebFrameImpl::counterValueForElementById(const WebString& id) const
1856 {
1857     if (!m_frame)
1858         return WebString();
1859
1860     Element* element = m_frame->document()->getElementById(id);
1861     if (!element)
1862         return WebString();
1863
1864     return counterValueForElement(element);
1865 }
1866
1867 WebString WebFrameImpl::markerTextForListItem(const WebElement& webElement) const
1868 {
1869     return WebCore::markerTextForListItem(const_cast<Element*>(webElement.constUnwrap<Element>()));
1870 }
1871
1872 int WebFrameImpl::pageNumberForElementById(const WebString& id,
1873                                            float pageWidthInPixels,
1874                                            float pageHeightInPixels) const
1875 {
1876     if (!m_frame)
1877         return -1;
1878
1879     Element* element = m_frame->document()->getElementById(id);
1880     if (!element)
1881         return -1;
1882
1883     FloatSize pageSize(pageWidthInPixels, pageHeightInPixels);
1884     return PrintContext::pageNumberForElement(element, pageSize);
1885 }
1886
1887 void WebFrameImpl::printPagesWithBoundaries(WebCanvas* canvas, const WebSize& pageSizeInPixels)
1888 {
1889     ASSERT(m_printContext.get());
1890
1891     GraphicsContextBuilder builder(canvas);
1892     GraphicsContext& graphicsContext = builder.context();
1893 #if WEBKIT_USING_SKIA
1894     graphicsContext.platformContext()->setPrinting(true);
1895 #endif
1896
1897     m_printContext->spoolAllPagesWithBoundaries(graphicsContext,
1898         FloatSize(pageSizeInPixels.width, pageSizeInPixels.height));
1899 }
1900
1901 WebRect WebFrameImpl::selectionBoundsRect() const
1902 {
1903     if (hasSelection())
1904         return IntRect(frame()->selection()->bounds(false));
1905
1906     return WebRect();
1907 }
1908
1909 bool WebFrameImpl::selectionStartHasSpellingMarkerFor(int from, int length) const
1910 {
1911     if (!m_frame)
1912         return false;
1913     return m_frame->editor()->selectionStartHasMarkerFor(DocumentMarker::Spelling, from, length);
1914 }
1915
1916 bool WebFrameImpl::pauseSVGAnimation(const WebString& animationId, double time, const WebString& elementId)
1917 {
1918 #if !ENABLE(SVG)
1919     return false;
1920 #else
1921     if (!m_frame)
1922         return false;
1923
1924     Document* document = m_frame->document();
1925     if (!document || !document->svgExtensions())
1926         return false;
1927
1928     Node* coreNode = document->getElementById(animationId);
1929     if (!coreNode || !SVGSMILElement::isSMILElement(coreNode))
1930         return false;
1931
1932     return document->accessSVGExtensions()->sampleAnimationAtTime(elementId, static_cast<SVGSMILElement*>(coreNode), time);
1933 #endif
1934 }
1935
1936 WebString WebFrameImpl::layerTreeAsText(bool showDebugInfo) const
1937 {
1938     if (!m_frame)
1939         return WebString();
1940     return WebString(m_frame->layerTreeAsText(showDebugInfo));
1941 }
1942
1943 // WebFrameImpl public ---------------------------------------------------------
1944
1945 PassRefPtr<WebFrameImpl> WebFrameImpl::create(WebFrameClient* client)
1946 {
1947     return adoptRef(new WebFrameImpl(client));
1948 }
1949
1950 WebFrameImpl::WebFrameImpl(WebFrameClient* client)
1951     : m_frameLoaderClient(this)
1952     , m_client(client)
1953     , m_activeMatchFrame(0)
1954     , m_activeMatchIndex(-1)
1955     , m_locatingActiveRect(false)
1956     , m_resumeScopingFromRange(0)
1957     , m_lastMatchCount(-1)
1958     , m_totalMatchCount(-1)
1959     , m_framesScopingCount(-1)
1960     , m_scopingComplete(false)
1961     , m_nextInvalidateAfter(0)
1962     , m_animationController(this)
1963     , m_identifier(generateFrameIdentifier())
1964     , m_inSameDocumentHistoryLoad(false)
1965 {
1966     PlatformSupport::incrementStatsCounter(webFrameActiveCount);
1967     frameCount++;
1968 }
1969
1970 WebFrameImpl::~WebFrameImpl()
1971 {
1972     PlatformSupport::decrementStatsCounter(webFrameActiveCount);
1973     frameCount--;
1974
1975     cancelPendingScopingEffort();
1976 }
1977
1978 void WebFrameImpl::initializeAsMainFrame(WebViewImpl* webViewImpl)
1979 {
1980     RefPtr<Frame> frame = Frame::create(webViewImpl->page(), 0, &m_frameLoaderClient);
1981     m_frame = frame.get();
1982
1983     // Add reference on behalf of FrameLoader.  See comments in
1984     // WebFrameLoaderClient::frameLoaderDestroyed for more info.
1985     ref();
1986
1987     // We must call init() after m_frame is assigned because it is referenced
1988     // during init().
1989     m_frame->init();
1990 }
1991
1992 PassRefPtr<Frame> WebFrameImpl::createChildFrame(
1993     const FrameLoadRequest& request, HTMLFrameOwnerElement* ownerElement)
1994 {
1995     RefPtr<WebFrameImpl> webframe(adoptRef(new WebFrameImpl(m_client)));
1996
1997     // Add an extra ref on behalf of the Frame/FrameLoader, which references the
1998     // WebFrame via the FrameLoaderClient interface. See the comment at the top
1999     // of this file for more info.
2000     webframe->ref();
2001
2002     RefPtr<Frame> childFrame = Frame::create(
2003         m_frame->page(), ownerElement, &webframe->m_frameLoaderClient);
2004     webframe->m_frame = childFrame.get();
2005
2006     childFrame->tree()->setName(request.frameName());
2007
2008     m_frame->tree()->appendChild(childFrame);
2009
2010     // Frame::init() can trigger onload event in the parent frame,
2011     // which may detach this frame and trigger a null-pointer access
2012     // in FrameTree::removeChild. Move init() after appendChild call
2013     // so that webframe->mFrame is in the tree before triggering
2014     // onload event handler.
2015     // Because the event handler may set webframe->mFrame to null,
2016     // it is necessary to check the value after calling init() and
2017     // return without loading URL.
2018     // (b:791612)
2019     childFrame->init(); // create an empty document
2020     if (!childFrame->tree()->parent())
2021         return 0;
2022
2023     m_frame->loader()->loadURLIntoChildFrame(
2024         request.resourceRequest().url(),
2025         request.resourceRequest().httpReferrer(),
2026         childFrame.get());
2027
2028     // A synchronous navigation (about:blank) would have already processed
2029     // onload, so it is possible for the frame to have already been destroyed by
2030     // script in the page.
2031     if (!childFrame->tree()->parent())
2032         return 0;
2033
2034     return childFrame.release();
2035 }
2036
2037 void WebFrameImpl::layout()
2038 {
2039     // layout this frame
2040     FrameView* view = m_frame->view();
2041     if (view)
2042         view->updateLayoutAndStyleIfNeededRecursive();
2043 }
2044
2045 void WebFrameImpl::paintWithContext(GraphicsContext& gc, const WebRect& rect)
2046 {
2047     IntRect dirtyRect(rect);
2048     gc.save();
2049     if (m_frame->document() && frameView()) {
2050         gc.clip(dirtyRect);
2051         frameView()->paint(&gc, dirtyRect);
2052         if (viewImpl()->pageOverlay())
2053             viewImpl()->pageOverlay()->paintWebFrame(gc);
2054     } else
2055         gc.fillRect(dirtyRect, Color::white, ColorSpaceDeviceRGB);
2056     gc.restore();
2057 }
2058
2059 void WebFrameImpl::paint(WebCanvas* canvas, const WebRect& rect)
2060 {
2061     if (rect.isEmpty())
2062         return;
2063     paintWithContext(GraphicsContextBuilder(canvas).context(), rect);
2064 }
2065
2066 void WebFrameImpl::createFrameView()
2067 {
2068     ASSERT(m_frame); // If m_frame doesn't exist, we probably didn't init properly.
2069
2070     WebViewImpl* webView = viewImpl();
2071     m_frame->createView(webView->size(), Color::white, webView->isTransparent(),  webView->fixedLayoutSize(), webView->isFixedLayoutModeEnabled());
2072
2073 #if ENABLE(GESTURE_RECOGNIZER)
2074     webView->resetGestureRecognizer();
2075 #endif
2076 }
2077
2078 WebFrameImpl* WebFrameImpl::fromFrame(Frame* frame)
2079 {
2080     if (!frame)
2081         return 0;
2082
2083     return static_cast<FrameLoaderClientImpl*>(frame->loader()->client())->webFrame();
2084 }
2085
2086 WebFrameImpl* WebFrameImpl::fromFrameOwnerElement(Element* element)
2087 {
2088     if (!element
2089         || !element->isFrameOwnerElement()
2090         || (!element->hasTagName(HTMLNames::iframeTag)
2091             && !element->hasTagName(HTMLNames::frameTag)))
2092         return 0;
2093
2094     HTMLFrameOwnerElement* frameElement =
2095         static_cast<HTMLFrameOwnerElement*>(element);
2096     return fromFrame(frameElement->contentFrame());
2097 }
2098
2099 WebViewImpl* WebFrameImpl::viewImpl() const
2100 {
2101     if (!m_frame)
2102         return 0;
2103
2104     return WebViewImpl::fromPage(m_frame->page());
2105 }
2106
2107 WebDataSourceImpl* WebFrameImpl::dataSourceImpl() const
2108 {
2109     return static_cast<WebDataSourceImpl*>(dataSource());
2110 }
2111
2112 WebDataSourceImpl* WebFrameImpl::provisionalDataSourceImpl() const
2113 {
2114     return static_cast<WebDataSourceImpl*>(provisionalDataSource());
2115 }
2116
2117 void WebFrameImpl::setFindEndstateFocusAndSelection()
2118 {
2119     WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl();
2120
2121     if (this == mainFrameImpl->activeMatchFrame() && m_activeMatch.get()) {
2122         // If the user has set the selection since the match was found, we
2123         // don't focus anything.
2124         VisibleSelection selection(frame()->selection()->selection());
2125         if (!selection.isNone())
2126             return;
2127
2128         // Try to find the first focusable node up the chain, which will, for
2129         // example, focus links if we have found text within the link.
2130         Node* node = m_activeMatch->firstNode();
2131         while (node && !node->isFocusable() && node != frame()->document())
2132             node = node->parentNode();
2133
2134         if (node && node != frame()->document()) {
2135             // Found a focusable parent node. Set focus to it.
2136             frame()->document()->setFocusedNode(node);
2137             return;
2138         }
2139
2140         // Iterate over all the nodes in the range until we find a focusable node.
2141         // This, for example, sets focus to the first link if you search for
2142         // text and text that is within one or more links.
2143         node = m_activeMatch->firstNode();
2144         while (node && node != m_activeMatch->pastLastNode()) {
2145             if (node->isFocusable()) {
2146                 frame()->document()->setFocusedNode(node);
2147                 return;
2148             }
2149             node = node->traverseNextNode();
2150         }
2151
2152         // No node related to the active match was focusable, so set the
2153         // active match as the selection (so that when you end the Find session,
2154         // you'll have the last thing you found highlighted) and make sure that
2155         // we have nothing focused (otherwise you might have text selected but
2156         // a link focused, which is weird).
2157         frame()->selection()->setSelection(m_activeMatch.get());
2158         frame()->document()->setFocusedNode(0);
2159     }
2160 }
2161
2162 void WebFrameImpl::didFail(const ResourceError& error, bool wasProvisional)
2163 {
2164     if (!client())
2165         return;
2166     WebURLError webError = error;
2167     if (wasProvisional)
2168         client()->didFailProvisionalLoad(this, webError);
2169     else
2170         client()->didFailLoad(this, webError);
2171 }
2172
2173 void WebFrameImpl::setCanHaveScrollbars(bool canHaveScrollbars)
2174 {
2175     m_frame->view()->setCanHaveScrollbars(canHaveScrollbars);
2176 }
2177
2178 // WebFrameImpl private --------------------------------------------------------
2179
2180 void WebFrameImpl::closing()
2181 {
2182     m_frame = 0;
2183 }
2184
2185 void WebFrameImpl::invalidateArea(AreaToInvalidate area)
2186 {
2187     ASSERT(frame() && frame()->view());
2188     FrameView* view = frame()->view();
2189
2190     if ((area & InvalidateAll) == InvalidateAll)
2191         view->invalidateRect(view->frameRect());
2192     else {
2193         if ((area & InvalidateContentArea) == InvalidateContentArea) {
2194             IntRect contentArea(
2195                 view->x(), view->y(), view->visibleWidth(), view->visibleHeight());
2196             IntRect frameRect = view->frameRect();
2197             contentArea.move(-frameRect.x(), -frameRect.y());
2198             view->invalidateRect(contentArea);
2199         }
2200
2201         if ((area & InvalidateScrollbar) == InvalidateScrollbar) {
2202             // Invalidate the vertical scroll bar region for the view.
2203             Scrollbar* scrollbar = view->verticalScrollbar();
2204             if (scrollbar)
2205                 scrollbar->invalidate();
2206         }
2207     }
2208 }
2209
2210 void WebFrameImpl::addMarker(Range* range, bool activeMatch)
2211 {
2212     frame()->document()->markers()->addTextMatchMarker(range, activeMatch);
2213 }
2214
2215 void WebFrameImpl::setMarkerActive(Range* range, bool active)
2216 {
2217     WebCore::ExceptionCode ec;
2218     if (!range || range->collapsed(ec))
2219         return;
2220
2221     frame()->document()->markers()->setMarkersActive(range, active);
2222 }
2223
2224 int WebFrameImpl::ordinalOfFirstMatchForFrame(WebFrameImpl* frame) const
2225 {
2226     int ordinal = 0;
2227     WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl();
2228     // Iterate from the main frame up to (but not including) |frame| and
2229     // add up the number of matches found so far.
2230     for (WebFrameImpl* it = mainFrameImpl;
2231          it != frame;
2232          it = static_cast<WebFrameImpl*>(it->traverseNext(true))) {
2233         if (it->m_lastMatchCount > 0)
2234             ordinal += it->m_lastMatchCount;
2235     }
2236     return ordinal;
2237 }
2238
2239 bool WebFrameImpl::shouldScopeMatches(const String& searchText)
2240 {
2241     // Don't scope if we can't find a frame or a view or if the frame is not visible.
2242     // The user may have closed the tab/application, so abort.
2243     if (!frame() || !frame()->view() || !hasVisibleContent())
2244         return false;
2245
2246     ASSERT(frame()->document() && frame()->view());
2247
2248     // If the frame completed the scoping operation and found 0 matches the last
2249     // time it was searched, then we don't have to search it again if the user is
2250     // just adding to the search string or sending the same search string again.
2251     if (m_scopingComplete && !m_lastSearchString.isEmpty() && !m_lastMatchCount) {
2252         // Check to see if the search string prefixes match.
2253         String previousSearchPrefix =
2254             searchText.substring(0, m_lastSearchString.length());
2255
2256         if (previousSearchPrefix == m_lastSearchString)
2257             return false; // Don't search this frame, it will be fruitless.
2258     }
2259
2260     return true;
2261 }
2262
2263 void WebFrameImpl::scopeStringMatchesSoon(int identifier, const WebString& searchText,
2264                                           const WebFindOptions& options, bool reset)
2265 {
2266     m_deferredScopingWork.append(new DeferredScopeStringMatches(
2267         this, identifier, searchText, options, reset));
2268 }
2269
2270 void WebFrameImpl::callScopeStringMatches(DeferredScopeStringMatches* caller,
2271                                           int identifier, const WebString& searchText,
2272                                           const WebFindOptions& options, bool reset)
2273 {
2274     m_deferredScopingWork.remove(m_deferredScopingWork.find(caller));
2275
2276     scopeStringMatches(identifier, searchText, options, reset);
2277
2278     // This needs to happen last since searchText is passed by reference.
2279     delete caller;
2280 }
2281
2282 void WebFrameImpl::invalidateIfNecessary()
2283 {
2284     if (m_lastMatchCount > m_nextInvalidateAfter) {
2285         // FIXME: (http://b/1088165) Optimize the drawing of the tickmarks and
2286         // remove this. This calculation sets a milestone for when next to
2287         // invalidate the scrollbar and the content area. We do this so that we
2288         // don't spend too much time drawing the scrollbar over and over again.
2289         // Basically, up until the first 500 matches there is no throttle.
2290         // After the first 500 matches, we set set the milestone further and
2291         // further out (750, 1125, 1688, 2K, 3K).
2292         static const int startSlowingDownAfter = 500;
2293         static const int slowdown = 750;
2294         int i = (m_lastMatchCount / startSlowingDownAfter);
2295         m_nextInvalidateAfter += i * slowdown;
2296
2297         invalidateArea(InvalidateScrollbar);
2298     }
2299 }
2300
2301 void WebFrameImpl::loadJavaScriptURL(const KURL& url)
2302 {
2303     // This is copied from ScriptController::executeIfJavaScriptURL.
2304     // Unfortunately, we cannot just use that method since it is private, and
2305     // it also doesn't quite behave as we require it to for bookmarklets.  The
2306     // key difference is that we need to suppress loading the string result
2307     // from evaluating the JS URL if executing the JS URL resulted in a
2308     // location change.  We also allow a JS URL to be loaded even if scripts on
2309     // the page are otherwise disabled.
2310
2311     if (!m_frame->document() || !m_frame->page())
2312         return;
2313
2314     RefPtr<Document> ownerDocument(m_frame->document());
2315
2316     // Protect privileged pages against bookmarklets and other javascript manipulations.
2317     if (SchemeRegistry::shouldTreatURLSchemeAsNotAllowingJavascriptURLs(m_frame->document()->url().protocol()))
2318         return;
2319
2320     String script = decodeURLEscapeSequences(url.string().substring(strlen("javascript:")));
2321     ScriptValue result = m_frame->script()->executeScript(script, true);
2322
2323     String scriptResult;
2324     if (!result.getString(scriptResult))
2325         return;
2326
2327     if (!m_frame->navigationScheduler()->locationChangePending())
2328         m_frame->document()->loader()->writer()->replaceDocument(scriptResult, ownerDocument.get());
2329 }
2330
2331 } // namespace WebKit