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