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