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