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