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