Move static "policy" state from SecurityOrigin.cpp to SecurityPolicy.cpp
[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 bool WebFrameImpl::find(int identifier,
1496                         const WebString& searchText,
1497                         const WebFindOptions& options,
1498                         bool wrapWithinFrame,
1499                         WebRect* selectionRect)
1500 {
1501     WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl();
1502
1503     if (!options.findNext)
1504         frame()->page()->unmarkAllTextMatches();
1505     else
1506         setMarkerActive(m_activeMatch.get(), false); // Active match is changing.
1507
1508     // Starts the search from the current selection.
1509     bool startInSelection = true;
1510
1511     // If the user has selected something since the last Find operation we want
1512     // to start from there. Otherwise, we start searching from where the last Find
1513     // operation left off (either a Find or a FindNext operation).
1514     VisibleSelection selection(frame()->selection()->selection());
1515     bool activeSelection = !selection.isNone();
1516     if (!activeSelection && m_activeMatch) {
1517         selection = VisibleSelection(m_activeMatch.get());
1518         frame()->selection()->setSelection(selection);
1519     }
1520
1521     ASSERT(frame() && frame()->view());
1522     bool found = frame()->editor()->findString(
1523         searchText, options.forward, options.matchCase, wrapWithinFrame,
1524         startInSelection);
1525     if (found) {
1526         // Store which frame was active. This will come in handy later when we
1527         // change the active match ordinal below.
1528         WebFrameImpl* oldActiveFrame = mainFrameImpl->m_activeMatchFrame;
1529         // Set this frame as the active frame (the one with the active highlight).
1530         mainFrameImpl->m_activeMatchFrame = this;
1531
1532         // We found something, so we can now query the selection for its position.
1533         VisibleSelection newSelection(frame()->selection()->selection());
1534         IntRect currSelectionRect;
1535
1536         // If we thought we found something, but it couldn't be selected (perhaps
1537         // because it was marked -webkit-user-select: none), we can't set it to
1538         // be active but we still continue searching. This matches Safari's
1539         // behavior, including some oddities when selectable and un-selectable text
1540         // are mixed on a page: see https://bugs.webkit.org/show_bug.cgi?id=19127.
1541         if (newSelection.isNone() || (newSelection.start() == newSelection.end()))
1542             m_activeMatch = 0;
1543         else {
1544             m_activeMatch = newSelection.toNormalizedRange();
1545             currSelectionRect = m_activeMatch->boundingBox();
1546             setMarkerActive(m_activeMatch.get(), true); // Active.
1547             // WebKit draws the highlighting for all matches.
1548             executeCommand(WebString::fromUTF8("Unselect"));
1549         }
1550
1551         // Make sure no node is focused. See http://crbug.com/38700.
1552         frame()->document()->setFocusedNode(0);
1553
1554         if (!options.findNext || activeSelection) {
1555             // This is either a Find operation or a Find-next from a new start point
1556             // due to a selection, so we set the flag to ask the scoping effort
1557             // to find the active rect for us so we can update the ordinal (n of m).
1558             m_locatingActiveRect = true;
1559         } else {
1560             if (oldActiveFrame != this) {
1561                 // If the active frame has changed it means that we have a multi-frame
1562                 // page and we just switch to searching in a new frame. Then we just
1563                 // want to reset the index.
1564                 if (options.forward)
1565                     m_activeMatchIndex = 0;
1566                 else
1567                     m_activeMatchIndex = m_lastMatchCount - 1;
1568             } else {
1569                 // We are still the active frame, so increment (or decrement) the
1570                 // |m_activeMatchIndex|, wrapping if needed (on single frame pages).
1571                 options.forward ? ++m_activeMatchIndex : --m_activeMatchIndex;
1572                 if (m_activeMatchIndex + 1 > m_lastMatchCount)
1573                     m_activeMatchIndex = 0;
1574                 if (m_activeMatchIndex == -1)
1575                     m_activeMatchIndex = m_lastMatchCount - 1;
1576             }
1577             if (selectionRect) {
1578                 *selectionRect = frameView()->contentsToWindow(currSelectionRect);
1579                 reportFindInPageSelection(*selectionRect, m_activeMatchIndex + 1, identifier);
1580             }
1581         }
1582     } else {
1583         // Nothing was found in this frame.
1584         m_activeMatch = 0;
1585
1586         // Erase all previous tickmarks and highlighting.
1587         invalidateArea(InvalidateAll);
1588     }
1589
1590     return found;
1591 }
1592
1593 void WebFrameImpl::stopFinding(bool clearSelection)
1594 {
1595     if (!clearSelection)
1596         setFindEndstateFocusAndSelection();
1597     cancelPendingScopingEffort();
1598
1599     // Remove all markers for matches found and turn off the highlighting.
1600     frame()->document()->markers()->removeMarkers(DocumentMarker::TextMatch);
1601     frame()->editor()->setMarkedTextMatchesAreHighlighted(false);
1602
1603     // Let the frame know that we don't want tickmarks or highlighting anymore.
1604     invalidateArea(InvalidateAll);
1605 }
1606
1607 void WebFrameImpl::scopeStringMatches(int identifier,
1608                                       const WebString& searchText,
1609                                       const WebFindOptions& options,
1610                                       bool reset)
1611 {
1612     if (!shouldScopeMatches(searchText))
1613         return;
1614
1615     WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl();
1616
1617     if (reset) {
1618         // This is a brand new search, so we need to reset everything.
1619         // Scoping is just about to begin.
1620         m_scopingComplete = false;
1621         // Clear highlighting for this frame.
1622         if (frame()->editor()->markedTextMatchesAreHighlighted())
1623             frame()->page()->unmarkAllTextMatches();
1624         // Clear the counters from last operation.
1625         m_lastMatchCount = 0;
1626         m_nextInvalidateAfter = 0;
1627
1628         m_resumeScopingFromRange = 0;
1629
1630         mainFrameImpl->m_framesScopingCount++;
1631
1632         // Now, defer scoping until later to allow find operation to finish quickly.
1633         scopeStringMatchesSoon(
1634             identifier,
1635             searchText,
1636             options,
1637             false); // false=we just reset, so don't do it again.
1638         return;
1639     }
1640
1641     RefPtr<Range> searchRange(rangeOfContents(frame()->document()));
1642
1643     Node* originalEndContainer = searchRange->endContainer();
1644     int originalEndOffset = searchRange->endOffset();
1645
1646     ExceptionCode ec = 0, ec2 = 0;
1647     if (m_resumeScopingFromRange) {
1648         // This is a continuation of a scoping operation that timed out and didn't
1649         // complete last time around, so we should start from where we left off.
1650         searchRange->setStart(m_resumeScopingFromRange->startContainer(),
1651                               m_resumeScopingFromRange->startOffset(ec2) + 1,
1652                               ec);
1653         if (ec || ec2) {
1654             if (ec2) // A non-zero |ec| happens when navigating during search.
1655                 ASSERT_NOT_REACHED();
1656             return;
1657         }
1658     }
1659
1660     // This timeout controls how long we scope before releasing control.  This
1661     // value does not prevent us from running for longer than this, but it is
1662     // periodically checked to see if we have exceeded our allocated time.
1663     const double maxScopingDuration = 0.1; // seconds
1664
1665     int matchCount = 0;
1666     bool timedOut = false;
1667     double startTime = currentTime();
1668     do {
1669         // Find next occurrence of the search string.
1670         // FIXME: (http://b/1088245) This WebKit operation may run for longer
1671         // than the timeout value, and is not interruptible as it is currently
1672         // written. We may need to rewrite it with interruptibility in mind, or
1673         // find an alternative.
1674         RefPtr<Range> resultRange(findPlainText(searchRange.get(),
1675                                                 searchText,
1676                                                 options.matchCase ? 0 : CaseInsensitive));
1677         if (resultRange->collapsed(ec)) {
1678             if (!resultRange->startContainer()->isInShadowTree())
1679                 break;
1680
1681             searchRange->setStartAfter(
1682                 resultRange->startContainer()->shadowAncestorNode(), ec);
1683             searchRange->setEnd(originalEndContainer, originalEndOffset, ec);
1684             continue;
1685         }
1686
1687         // Only treat the result as a match if it is visible
1688         if (frame()->editor()->insideVisibleArea(resultRange.get())) {
1689             ++matchCount;
1690
1691             // Catch a special case where Find found something but doesn't know what
1692             // the bounding box for it is. In this case we set the first match we find
1693             // as the active rect.
1694             IntRect resultBounds = resultRange->boundingBox();
1695             IntRect activeSelectionRect;
1696             if (m_locatingActiveRect) {
1697                 activeSelectionRect = m_activeMatch.get() ?
1698                     m_activeMatch->boundingBox() : resultBounds;
1699             }
1700
1701             // If the Find function found a match it will have stored where the
1702             // match was found in m_activeSelectionRect on the current frame. If we
1703             // find this rect during scoping it means we have found the active
1704             // tickmark.
1705             bool foundActiveMatch = false;
1706             if (m_locatingActiveRect && (activeSelectionRect == resultBounds)) {
1707                 // We have found the active tickmark frame.
1708                 mainFrameImpl->m_activeMatchFrame = this;
1709                 foundActiveMatch = true;
1710                 // We also know which tickmark is active now.
1711                 m_activeMatchIndex = matchCount - 1;
1712                 // To stop looking for the active tickmark, we set this flag.
1713                 m_locatingActiveRect = false;
1714
1715                 // Notify browser of new location for the selected rectangle.
1716                 reportFindInPageSelection(
1717                     frameView()->contentsToWindow(resultBounds),
1718                     m_activeMatchIndex + 1,
1719                     identifier);
1720             }
1721
1722             addMarker(resultRange.get(), foundActiveMatch);
1723         }
1724
1725         // Set the new start for the search range to be the end of the previous
1726         // result range. There is no need to use a VisiblePosition here,
1727         // since findPlainText will use a TextIterator to go over the visible
1728         // text nodes.
1729         searchRange->setStart(resultRange->endContainer(ec), resultRange->endOffset(ec), ec);
1730
1731         Node* shadowTreeRoot = searchRange->shadowTreeRootNode();
1732         if (searchRange->collapsed(ec) && shadowTreeRoot)
1733             searchRange->setEnd(shadowTreeRoot, shadowTreeRoot->childNodeCount(), ec);
1734
1735         m_resumeScopingFromRange = resultRange;
1736         timedOut = (currentTime() - startTime) >= maxScopingDuration;
1737     } while (!timedOut);
1738
1739     // Remember what we search for last time, so we can skip searching if more
1740     // letters are added to the search string (and last outcome was 0).
1741     m_lastSearchString = searchText;
1742
1743     if (matchCount > 0) {
1744         frame()->editor()->setMarkedTextMatchesAreHighlighted(true);
1745
1746         m_lastMatchCount += matchCount;
1747
1748         // Let the mainframe know how much we found during this pass.
1749         mainFrameImpl->increaseMatchCount(matchCount, identifier);
1750     }
1751
1752     if (timedOut) {
1753         // If we found anything during this pass, we should redraw. However, we
1754         // don't want to spam too much if the page is extremely long, so if we
1755         // reach a certain point we start throttling the redraw requests.
1756         if (matchCount > 0)
1757             invalidateIfNecessary();
1758
1759         // Scoping effort ran out of time, lets ask for another time-slice.
1760         scopeStringMatchesSoon(
1761             identifier,
1762             searchText,
1763             options,
1764             false); // don't reset.
1765         return; // Done for now, resume work later.
1766     }
1767
1768     // This frame has no further scoping left, so it is done. Other frames might,
1769     // of course, continue to scope matches.
1770     m_scopingComplete = true;
1771     mainFrameImpl->m_framesScopingCount--;
1772
1773     // If this is the last frame to finish scoping we need to trigger the final
1774     // update to be sent.
1775     if (!mainFrameImpl->m_framesScopingCount)
1776         mainFrameImpl->increaseMatchCount(0, identifier);
1777
1778     // This frame is done, so show any scrollbar tickmarks we haven't drawn yet.
1779     invalidateArea(InvalidateScrollbar);
1780 }
1781
1782 void WebFrameImpl::cancelPendingScopingEffort()
1783 {
1784     deleteAllValues(m_deferredScopingWork);
1785     m_deferredScopingWork.clear();
1786
1787     m_activeMatchIndex = -1;
1788 }
1789
1790 void WebFrameImpl::increaseMatchCount(int count, int identifier)
1791 {
1792     // This function should only be called on the mainframe.
1793     ASSERT(!parent());
1794
1795     m_totalMatchCount += count;
1796
1797     // Update the UI with the latest findings.
1798     if (client())
1799         client()->reportFindInPageMatchCount(identifier, m_totalMatchCount, !m_framesScopingCount);
1800 }
1801
1802 void WebFrameImpl::reportFindInPageSelection(const WebRect& selectionRect,
1803                                              int activeMatchOrdinal,
1804                                              int identifier)
1805 {
1806     // Update the UI with the latest selection rect.
1807     if (client())
1808         client()->reportFindInPageSelection(identifier, ordinalOfFirstMatchForFrame(this) + activeMatchOrdinal, selectionRect);
1809 }
1810
1811 void WebFrameImpl::resetMatchCount()
1812 {
1813     m_totalMatchCount = 0;
1814     m_framesScopingCount = 0;
1815 }
1816
1817 WebString WebFrameImpl::contentAsText(size_t maxChars) const
1818 {
1819     if (!m_frame)
1820         return WebString();
1821
1822     Vector<UChar> text;
1823     frameContentAsPlainText(maxChars, m_frame, &text);
1824     return String::adopt(text);
1825 }
1826
1827 WebString WebFrameImpl::contentAsMarkup() const
1828 {
1829     return createFullMarkup(m_frame->document());
1830 }
1831
1832 WebString WebFrameImpl::renderTreeAsText(RenderAsTextControls toShow) const
1833 {
1834     RenderAsTextBehavior behavior = RenderAsTextBehaviorNormal;
1835
1836     if (toShow & RenderAsTextDebug) {
1837         behavior |= RenderAsTextShowCompositedLayers
1838             | RenderAsTextShowAddresses
1839             | RenderAsTextShowIDAndClass
1840             | RenderAsTextShowLayerNesting;
1841     }
1842
1843     if (toShow & RenderAsTextPrinting)
1844         behavior |= RenderAsTextPrintingMode;
1845
1846     return externalRepresentation(m_frame, behavior);
1847 }
1848
1849 WebString WebFrameImpl::counterValueForElementById(const WebString& id) const
1850 {
1851     if (!m_frame)
1852         return WebString();
1853
1854     Element* element = m_frame->document()->getElementById(id);
1855     if (!element)
1856         return WebString();
1857
1858     return counterValueForElement(element);
1859 }
1860
1861 WebString WebFrameImpl::markerTextForListItem(const WebElement& webElement) const
1862 {
1863     return WebCore::markerTextForListItem(const_cast<Element*>(webElement.constUnwrap<Element>()));
1864 }
1865
1866 int WebFrameImpl::pageNumberForElementById(const WebString& id,
1867                                            float pageWidthInPixels,
1868                                            float pageHeightInPixels) const
1869 {
1870     if (!m_frame)
1871         return -1;
1872
1873     Element* element = m_frame->document()->getElementById(id);
1874     if (!element)
1875         return -1;
1876
1877     FloatSize pageSize(pageWidthInPixels, pageHeightInPixels);
1878     return PrintContext::pageNumberForElement(element, pageSize);
1879 }
1880
1881 void WebFrameImpl::printPagesWithBoundaries(WebCanvas* canvas, const WebSize& pageSizeInPixels)
1882 {
1883     ASSERT(m_printContext.get());
1884
1885     GraphicsContextBuilder builder(canvas);
1886     GraphicsContext& graphicsContext = builder.context();
1887 #if WEBKIT_USING_SKIA
1888     graphicsContext.platformContext()->setPrinting(true);
1889 #endif
1890
1891     m_printContext->spoolAllPagesWithBoundaries(graphicsContext,
1892         FloatSize(pageSizeInPixels.width, pageSizeInPixels.height));
1893 }
1894
1895 WebRect WebFrameImpl::selectionBoundsRect() const
1896 {
1897     if (hasSelection())
1898         return IntRect(frame()->selection()->bounds(false));
1899
1900     return WebRect();
1901 }
1902
1903 bool WebFrameImpl::selectionStartHasSpellingMarkerFor(int from, int length) const
1904 {
1905     if (!m_frame)
1906         return false;
1907     return m_frame->editor()->selectionStartHasMarkerFor(DocumentMarker::Spelling, from, length);
1908 }
1909
1910 bool WebFrameImpl::pauseSVGAnimation(const WebString& animationId, double time, const WebString& elementId)
1911 {
1912 #if !ENABLE(SVG)
1913     return false;
1914 #else
1915     if (!m_frame)
1916         return false;
1917
1918     Document* document = m_frame->document();
1919     if (!document || !document->svgExtensions())
1920         return false;
1921
1922     Node* coreNode = document->getElementById(animationId);
1923     if (!coreNode || !SVGSMILElement::isSMILElement(coreNode))
1924         return false;
1925
1926     return document->accessSVGExtensions()->sampleAnimationAtTime(elementId, static_cast<SVGSMILElement*>(coreNode), time);
1927 #endif
1928 }
1929
1930 WebString WebFrameImpl::layerTreeAsText(bool showDebugInfo) const
1931 {
1932     if (!m_frame)
1933         return WebString();
1934     return WebString(m_frame->layerTreeAsText(showDebugInfo));
1935 }
1936
1937 // WebFrameImpl public ---------------------------------------------------------
1938
1939 PassRefPtr<WebFrameImpl> WebFrameImpl::create(WebFrameClient* client)
1940 {
1941     return adoptRef(new WebFrameImpl(client));
1942 }
1943
1944 WebFrameImpl::WebFrameImpl(WebFrameClient* client)
1945     : m_frameLoaderClient(this)
1946     , m_client(client)
1947     , m_activeMatchFrame(0)
1948     , m_activeMatchIndex(-1)
1949     , m_locatingActiveRect(false)
1950     , m_resumeScopingFromRange(0)
1951     , m_lastMatchCount(-1)
1952     , m_totalMatchCount(-1)
1953     , m_framesScopingCount(-1)
1954     , m_scopingComplete(false)
1955     , m_nextInvalidateAfter(0)
1956     , m_animationController(this)
1957     , m_identifier(generateFrameIdentifier())
1958     , m_inSameDocumentHistoryLoad(false)
1959 {
1960     PlatformSupport::incrementStatsCounter(webFrameActiveCount);
1961     frameCount++;
1962 }
1963
1964 WebFrameImpl::~WebFrameImpl()
1965 {
1966     PlatformSupport::decrementStatsCounter(webFrameActiveCount);
1967     frameCount--;
1968
1969     cancelPendingScopingEffort();
1970 }
1971
1972 void WebFrameImpl::initializeAsMainFrame(WebViewImpl* webViewImpl)
1973 {
1974     RefPtr<Frame> frame = Frame::create(webViewImpl->page(), 0, &m_frameLoaderClient);
1975     m_frame = frame.get();
1976
1977     // Add reference on behalf of FrameLoader.  See comments in
1978     // WebFrameLoaderClient::frameLoaderDestroyed for more info.
1979     ref();
1980
1981     // We must call init() after m_frame is assigned because it is referenced
1982     // during init().
1983     m_frame->init();
1984 }
1985
1986 PassRefPtr<Frame> WebFrameImpl::createChildFrame(
1987     const FrameLoadRequest& request, HTMLFrameOwnerElement* ownerElement)
1988 {
1989     RefPtr<WebFrameImpl> webframe(adoptRef(new WebFrameImpl(m_client)));
1990
1991     // Add an extra ref on behalf of the Frame/FrameLoader, which references the
1992     // WebFrame via the FrameLoaderClient interface. See the comment at the top
1993     // of this file for more info.
1994     webframe->ref();
1995
1996     RefPtr<Frame> childFrame = Frame::create(
1997         m_frame->page(), ownerElement, &webframe->m_frameLoaderClient);
1998     webframe->m_frame = childFrame.get();
1999
2000     childFrame->tree()->setName(request.frameName());
2001
2002     m_frame->tree()->appendChild(childFrame);
2003
2004     // Frame::init() can trigger onload event in the parent frame,
2005     // which may detach this frame and trigger a null-pointer access
2006     // in FrameTree::removeChild. Move init() after appendChild call
2007     // so that webframe->mFrame is in the tree before triggering
2008     // onload event handler.
2009     // Because the event handler may set webframe->mFrame to null,
2010     // it is necessary to check the value after calling init() and
2011     // return without loading URL.
2012     // (b:791612)
2013     childFrame->init(); // create an empty document
2014     if (!childFrame->tree()->parent())
2015         return 0;
2016
2017     m_frame->loader()->loadURLIntoChildFrame(
2018         request.resourceRequest().url(),
2019         request.resourceRequest().httpReferrer(),
2020         childFrame.get());
2021
2022     // A synchronous navigation (about:blank) would have already processed
2023     // onload, so it is possible for the frame to have already been destroyed by
2024     // script in the page.
2025     if (!childFrame->tree()->parent())
2026         return 0;
2027
2028     return childFrame.release();
2029 }
2030
2031 void WebFrameImpl::layout()
2032 {
2033     // layout this frame
2034     FrameView* view = m_frame->view();
2035     if (view)
2036         view->updateLayoutAndStyleIfNeededRecursive();
2037 }
2038
2039 void WebFrameImpl::paintWithContext(GraphicsContext& gc, const WebRect& rect)
2040 {
2041     IntRect dirtyRect(rect);
2042     gc.save();
2043     if (m_frame->document() && frameView()) {
2044         gc.clip(dirtyRect);
2045         frameView()->paint(&gc, dirtyRect);
2046         if (viewImpl()->pageOverlay())
2047             viewImpl()->pageOverlay()->paintWebFrame(gc);
2048     } else
2049         gc.fillRect(dirtyRect, Color::white, ColorSpaceDeviceRGB);
2050     gc.restore();
2051 }
2052
2053 void WebFrameImpl::paint(WebCanvas* canvas, const WebRect& rect)
2054 {
2055     if (rect.isEmpty())
2056         return;
2057     paintWithContext(GraphicsContextBuilder(canvas).context(), rect);
2058 }
2059
2060 void WebFrameImpl::createFrameView()
2061 {
2062     ASSERT(m_frame); // If m_frame doesn't exist, we probably didn't init properly.
2063
2064     WebViewImpl* webView = viewImpl();
2065     m_frame->createView(webView->size(), Color::white, webView->isTransparent(),  webView->fixedLayoutSize(), webView->isFixedLayoutModeEnabled());
2066
2067 #if ENABLE(GESTURE_RECOGNIZER)
2068     webView->resetGestureRecognizer();
2069 #endif
2070 }
2071
2072 WebFrameImpl* WebFrameImpl::fromFrame(Frame* frame)
2073 {
2074     if (!frame)
2075         return 0;
2076
2077     return static_cast<FrameLoaderClientImpl*>(frame->loader()->client())->webFrame();
2078 }
2079
2080 WebFrameImpl* WebFrameImpl::fromFrameOwnerElement(Element* element)
2081 {
2082     if (!element
2083         || !element->isFrameOwnerElement()
2084         || (!element->hasTagName(HTMLNames::iframeTag)
2085             && !element->hasTagName(HTMLNames::frameTag)))
2086         return 0;
2087
2088     HTMLFrameOwnerElement* frameElement =
2089         static_cast<HTMLFrameOwnerElement*>(element);
2090     return fromFrame(frameElement->contentFrame());
2091 }
2092
2093 WebViewImpl* WebFrameImpl::viewImpl() const
2094 {
2095     if (!m_frame)
2096         return 0;
2097
2098     return WebViewImpl::fromPage(m_frame->page());
2099 }
2100
2101 WebDataSourceImpl* WebFrameImpl::dataSourceImpl() const
2102 {
2103     return static_cast<WebDataSourceImpl*>(dataSource());
2104 }
2105
2106 WebDataSourceImpl* WebFrameImpl::provisionalDataSourceImpl() const
2107 {
2108     return static_cast<WebDataSourceImpl*>(provisionalDataSource());
2109 }
2110
2111 void WebFrameImpl::setFindEndstateFocusAndSelection()
2112 {
2113     WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl();
2114
2115     if (this == mainFrameImpl->activeMatchFrame() && m_activeMatch.get()) {
2116         // If the user has set the selection since the match was found, we
2117         // don't focus anything.
2118         VisibleSelection selection(frame()->selection()->selection());
2119         if (!selection.isNone())
2120             return;
2121
2122         // Try to find the first focusable node up the chain, which will, for
2123         // example, focus links if we have found text within the link.
2124         Node* node = m_activeMatch->firstNode();
2125         while (node && !node->isFocusable() && node != frame()->document())
2126             node = node->parentNode();
2127
2128         if (node && node != frame()->document()) {
2129             // Found a focusable parent node. Set focus to it.
2130             frame()->document()->setFocusedNode(node);
2131             return;
2132         }
2133
2134         // Iterate over all the nodes in the range until we find a focusable node.
2135         // This, for example, sets focus to the first link if you search for
2136         // text and text that is within one or more links.
2137         node = m_activeMatch->firstNode();
2138         while (node && node != m_activeMatch->pastLastNode()) {
2139             if (node->isFocusable()) {
2140                 frame()->document()->setFocusedNode(node);
2141                 return;
2142             }
2143             node = node->traverseNextNode();
2144         }
2145
2146         // No node related to the active match was focusable, so set the
2147         // active match as the selection (so that when you end the Find session,
2148         // you'll have the last thing you found highlighted) and make sure that
2149         // we have nothing focused (otherwise you might have text selected but
2150         // a link focused, which is weird).
2151         frame()->selection()->setSelection(m_activeMatch.get());
2152         frame()->document()->setFocusedNode(0);
2153     }
2154 }
2155
2156 void WebFrameImpl::didFail(const ResourceError& error, bool wasProvisional)
2157 {
2158     if (!client())
2159         return;
2160     WebURLError webError = error;
2161     if (wasProvisional)
2162         client()->didFailProvisionalLoad(this, webError);
2163     else
2164         client()->didFailLoad(this, webError);
2165 }
2166
2167 void WebFrameImpl::setCanHaveScrollbars(bool canHaveScrollbars)
2168 {
2169     m_frame->view()->setCanHaveScrollbars(canHaveScrollbars);
2170 }
2171
2172 // WebFrameImpl private --------------------------------------------------------
2173
2174 void WebFrameImpl::closing()
2175 {
2176     m_frame = 0;
2177 }
2178
2179 void WebFrameImpl::invalidateArea(AreaToInvalidate area)
2180 {
2181     ASSERT(frame() && frame()->view());
2182     FrameView* view = frame()->view();
2183
2184     if ((area & InvalidateAll) == InvalidateAll)
2185         view->invalidateRect(view->frameRect());
2186     else {
2187         if ((area & InvalidateContentArea) == InvalidateContentArea) {
2188             IntRect contentArea(
2189                 view->x(), view->y(), view->visibleWidth(), view->visibleHeight());
2190             IntRect frameRect = view->frameRect();
2191             contentArea.move(-frameRect.x(), -frameRect.y());
2192             view->invalidateRect(contentArea);
2193         }
2194
2195         if ((area & InvalidateScrollbar) == InvalidateScrollbar) {
2196             // Invalidate the vertical scroll bar region for the view.
2197             Scrollbar* scrollbar = view->verticalScrollbar();
2198             if (scrollbar)
2199                 scrollbar->invalidate();
2200         }
2201     }
2202 }
2203
2204 void WebFrameImpl::addMarker(Range* range, bool activeMatch)
2205 {
2206     frame()->document()->markers()->addTextMatchMarker(range, activeMatch);
2207 }
2208
2209 void WebFrameImpl::setMarkerActive(Range* range, bool active)
2210 {
2211     WebCore::ExceptionCode ec;
2212     if (!range || range->collapsed(ec))
2213         return;
2214
2215     frame()->document()->markers()->setMarkersActive(range, active);
2216 }
2217
2218 int WebFrameImpl::ordinalOfFirstMatchForFrame(WebFrameImpl* frame) const
2219 {
2220     int ordinal = 0;
2221     WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl();
2222     // Iterate from the main frame up to (but not including) |frame| and
2223     // add up the number of matches found so far.
2224     for (WebFrameImpl* it = mainFrameImpl;
2225          it != frame;
2226          it = static_cast<WebFrameImpl*>(it->traverseNext(true))) {
2227         if (it->m_lastMatchCount > 0)
2228             ordinal += it->m_lastMatchCount;
2229     }
2230     return ordinal;
2231 }
2232
2233 bool WebFrameImpl::shouldScopeMatches(const String& searchText)
2234 {
2235     // Don't scope if we can't find a frame or a view or if the frame is not visible.
2236     // The user may have closed the tab/application, so abort.
2237     if (!frame() || !frame()->view() || !hasVisibleContent())
2238         return false;
2239
2240     ASSERT(frame()->document() && frame()->view());
2241
2242     // If the frame completed the scoping operation and found 0 matches the last
2243     // time it was searched, then we don't have to search it again if the user is
2244     // just adding to the search string or sending the same search string again.
2245     if (m_scopingComplete && !m_lastSearchString.isEmpty() && !m_lastMatchCount) {
2246         // Check to see if the search string prefixes match.
2247         String previousSearchPrefix =
2248             searchText.substring(0, m_lastSearchString.length());
2249
2250         if (previousSearchPrefix == m_lastSearchString)
2251             return false; // Don't search this frame, it will be fruitless.
2252     }
2253
2254     return true;
2255 }
2256
2257 void WebFrameImpl::scopeStringMatchesSoon(int identifier, const WebString& searchText,
2258                                           const WebFindOptions& options, bool reset)
2259 {
2260     m_deferredScopingWork.append(new DeferredScopeStringMatches(
2261         this, identifier, searchText, options, reset));
2262 }
2263
2264 void WebFrameImpl::callScopeStringMatches(DeferredScopeStringMatches* caller,
2265                                           int identifier, const WebString& searchText,
2266                                           const WebFindOptions& options, bool reset)
2267 {
2268     m_deferredScopingWork.remove(m_deferredScopingWork.find(caller));
2269
2270     scopeStringMatches(identifier, searchText, options, reset);
2271
2272     // This needs to happen last since searchText is passed by reference.
2273     delete caller;
2274 }
2275
2276 void WebFrameImpl::invalidateIfNecessary()
2277 {
2278     if (m_lastMatchCount > m_nextInvalidateAfter) {
2279         // FIXME: (http://b/1088165) Optimize the drawing of the tickmarks and
2280         // remove this. This calculation sets a milestone for when next to
2281         // invalidate the scrollbar and the content area. We do this so that we
2282         // don't spend too much time drawing the scrollbar over and over again.
2283         // Basically, up until the first 500 matches there is no throttle.
2284         // After the first 500 matches, we set set the milestone further and
2285         // further out (750, 1125, 1688, 2K, 3K).
2286         static const int startSlowingDownAfter = 500;
2287         static const int slowdown = 750;
2288         int i = (m_lastMatchCount / startSlowingDownAfter);
2289         m_nextInvalidateAfter += i * slowdown;
2290
2291         invalidateArea(InvalidateScrollbar);
2292     }
2293 }
2294
2295 void WebFrameImpl::loadJavaScriptURL(const KURL& url)
2296 {
2297     // This is copied from ScriptController::executeIfJavaScriptURL.
2298     // Unfortunately, we cannot just use that method since it is private, and
2299     // it also doesn't quite behave as we require it to for bookmarklets.  The
2300     // key difference is that we need to suppress loading the string result
2301     // from evaluating the JS URL if executing the JS URL resulted in a
2302     // location change.  We also allow a JS URL to be loaded even if scripts on
2303     // the page are otherwise disabled.
2304
2305     if (!m_frame->document() || !m_frame->page())
2306         return;
2307
2308     RefPtr<Document> ownerDocument(m_frame->document());
2309
2310     // Protect privileged pages against bookmarklets and other javascript manipulations.
2311     if (SchemeRegistry::shouldTreatURLSchemeAsNotAllowingJavascriptURLs(m_frame->document()->url().protocol()))
2312         return;
2313
2314     String script = decodeURLEscapeSequences(url.string().substring(strlen("javascript:")));
2315     ScriptValue result = m_frame->script()->executeScript(script, true);
2316
2317     String scriptResult;
2318     if (!result.getString(scriptResult))
2319         return;
2320
2321     if (!m_frame->navigationScheduler()->locationChangePending())
2322         m_frame->document()->loader()->writer()->replaceDocument(scriptResult, ownerDocument.get());
2323 }
2324
2325 } // namespace WebKit