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