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