9d6129be25bf7d9233e057c78c2cc1f51c876b3b
[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     // If there is no currentItem, which happens when we are navigating in
885     // session history after a crash, we need to manufacture one otherwise WebKit
886     // hoarks. This is probably the wrong thing to do, but it seems to work.
887     RefPtr<HistoryItem> currentItem = m_frame->loader()->history()->currentItem();
888     if (!currentItem) {
889         currentItem = HistoryItem::create();
890         currentItem->setLastVisitWasFailure(true);
891         m_frame->loader()->history()->setCurrentItem(currentItem.get());
892         m_frame->page()->backForward()->setCurrentItem(currentItem.get());
893     }
894
895     m_frame->loader()->history()->goToItem(
896         historyItem.get(), FrameLoadTypeIndexedBackForward);
897 }
898
899 void WebFrameImpl::loadData(const WebData& data,
900                             const WebString& mimeType,
901                             const WebString& textEncoding,
902                             const WebURL& baseURL,
903                             const WebURL& unreachableURL,
904                             bool replace)
905 {
906     SubstituteData substData(data, mimeType, textEncoding, unreachableURL);
907     ASSERT(substData.isValid());
908
909     // If we are loading substitute data to replace an existing load, then
910     // inherit all of the properties of that original request.  This way,
911     // reload will re-attempt the original request.  It is essential that
912     // we only do this when there is an unreachableURL since a non-empty
913     // unreachableURL informs FrameLoader::reload to load unreachableURL
914     // instead of the currently loaded URL.
915     ResourceRequest request;
916     if (replace && !unreachableURL.isEmpty())
917         request = m_frame->loader()->originalRequest();
918     request.setURL(baseURL);
919
920     m_frame->loader()->load(request, substData, false);
921     if (replace) {
922         // Do this to force WebKit to treat the load as replacing the currently
923         // loaded page.
924         m_frame->loader()->setReplacing();
925     }
926 }
927
928 void WebFrameImpl::loadHTMLString(const WebData& data,
929                                   const WebURL& baseURL,
930                                   const WebURL& unreachableURL,
931                                   bool replace)
932 {
933     loadData(data,
934              WebString::fromUTF8("text/html"),
935              WebString::fromUTF8("UTF-8"),
936              baseURL,
937              unreachableURL,
938              replace);
939 }
940
941 bool WebFrameImpl::isLoading() const
942 {
943     if (!m_frame)
944         return false;
945     return m_frame->loader()->isLoading();
946 }
947
948 void WebFrameImpl::stopLoading()
949 {
950     if (!m_frame)
951       return;
952
953     // FIXME: Figure out what we should really do here.  It seems like a bug
954     // that FrameLoader::stopLoading doesn't call stopAllLoaders.
955     m_frame->loader()->stopAllLoaders();
956     m_frame->loader()->stopLoading(UnloadEventPolicyNone);
957 }
958
959 WebDataSource* WebFrameImpl::provisionalDataSource() const
960 {
961     FrameLoader* frameLoader = m_frame->loader();
962
963     // We regard the policy document loader as still provisional.
964     DocumentLoader* docLoader = frameLoader->provisionalDocumentLoader();
965     if (!docLoader)
966         docLoader = frameLoader->policyDocumentLoader();
967
968     return DataSourceForDocLoader(docLoader);
969 }
970
971 WebDataSource* WebFrameImpl::dataSource() const
972 {
973     return DataSourceForDocLoader(m_frame->loader()->documentLoader());
974 }
975
976 WebHistoryItem WebFrameImpl::previousHistoryItem() const
977 {
978     // We use the previous item here because documentState (filled-out forms)
979     // only get saved to history when it becomes the previous item.  The caller
980     // is expected to query the history item after a navigation occurs, after
981     // the desired history item has become the previous entry.
982     return WebHistoryItem(m_frame->loader()->history()->previousItem());
983 }
984
985 WebHistoryItem WebFrameImpl::currentHistoryItem() const
986 {
987     // If we are still loading, then we don't want to clobber the current
988     // history item as this could cause us to lose the scroll position and
989     // document state.  However, it is OK for new navigations.
990     if (m_frame->loader()->loadType() == FrameLoadTypeStandard
991         || !m_frame->loader()->activeDocumentLoader()->isLoadingInAPISense())
992         m_frame->loader()->history()->saveDocumentAndScrollState();
993
994     return WebHistoryItem(m_frame->page()->backForward()->currentItem());
995 }
996
997 void WebFrameImpl::enableViewSourceMode(bool enable)
998 {
999     if (m_frame)
1000         m_frame->setInViewSourceMode(enable);
1001 }
1002
1003 bool WebFrameImpl::isViewSourceModeEnabled() const
1004 {
1005     if (m_frame)
1006         return m_frame->inViewSourceMode();
1007
1008     return false;
1009 }
1010
1011 void WebFrameImpl::setReferrerForRequest(
1012     WebURLRequest& request, const WebURL& referrerURL) {
1013     String referrer;
1014     if (referrerURL.isEmpty())
1015         referrer = m_frame->loader()->outgoingReferrer();
1016     else
1017         referrer = referrerURL.spec().utf16();
1018     if (SecurityOrigin::shouldHideReferrer(request.url(), referrer))
1019         return;
1020     request.setHTTPHeaderField(WebString::fromUTF8("Referer"), referrer);
1021 }
1022
1023 void WebFrameImpl::dispatchWillSendRequest(WebURLRequest& request)
1024 {
1025     ResourceResponse response;
1026     m_frame->loader()->client()->dispatchWillSendRequest(
1027         0, 0, request.toMutableResourceRequest(), response);
1028 }
1029
1030 WebURLLoader* WebFrameImpl::createAssociatedURLLoader()
1031 {
1032     return new AssociatedURLLoader(this);
1033 }
1034
1035 void WebFrameImpl::commitDocumentData(const char* data, size_t length)
1036 {
1037     m_frame->loader()->documentLoader()->commitData(data, length);
1038 }
1039
1040 unsigned WebFrameImpl::unloadListenerCount() const
1041 {
1042     return frame()->domWindow()->pendingUnloadEventListeners();
1043 }
1044
1045 bool WebFrameImpl::isProcessingUserGesture() const
1046 {
1047     return frame()->loader()->isProcessingUserGesture();
1048 }
1049
1050 bool WebFrameImpl::willSuppressOpenerInNewFrame() const
1051 {
1052     return frame()->loader()->suppressOpenerInNewFrame();
1053 }
1054
1055 void WebFrameImpl::replaceSelection(const WebString& text)
1056 {
1057     RefPtr<DocumentFragment> fragment = createFragmentFromText(
1058         frame()->selection()->toNormalizedRange().get(), text);
1059     applyCommand(ReplaceSelectionCommand::create(
1060         frame()->document(), fragment.get(), false, true, true));
1061 }
1062
1063 void WebFrameImpl::insertText(const WebString& text)
1064 {
1065     Editor* editor = frame()->editor();
1066
1067     if (editor->hasComposition())
1068         editor->confirmComposition(text);
1069     else
1070         editor->insertText(text, 0);
1071 }
1072
1073 void WebFrameImpl::setMarkedText(
1074     const WebString& text, unsigned location, unsigned length)
1075 {
1076     Editor* editor = frame()->editor();
1077
1078     Vector<CompositionUnderline> decorations;
1079     editor->setComposition(text, decorations, location, length);
1080 }
1081
1082 void WebFrameImpl::unmarkText()
1083 {
1084     frame()->editor()->confirmCompositionWithoutDisturbingSelection();
1085 }
1086
1087 bool WebFrameImpl::hasMarkedText() const
1088 {
1089     return frame()->editor()->hasComposition();
1090 }
1091
1092 WebRange WebFrameImpl::markedRange() const
1093 {
1094     return frame()->editor()->compositionRange();
1095 }
1096
1097 bool WebFrameImpl::firstRectForCharacterRange(unsigned location, unsigned length, WebRect& rect) const
1098 {
1099     if ((location + length < location) && (location + length))
1100         length = 0;
1101
1102     Element* selectionRoot = frame()->selection()->rootEditableElement();
1103     Element* scope = selectionRoot ? selectionRoot : frame()->document()->documentElement();
1104     RefPtr<Range> range = TextIterator::rangeFromLocationAndLength(scope, location, length);
1105     if (!range)
1106         return false;
1107     IntRect intRect = frame()->editor()->firstRectForRange(range.get());
1108     rect = WebRect(intRect.x(), intRect.y(), intRect.width(), intRect.height());
1109
1110     return true;
1111 }
1112
1113 bool WebFrameImpl::executeCommand(const WebString& name)
1114 {
1115     ASSERT(frame());
1116
1117     if (name.length() <= 2)
1118         return false;
1119
1120     // Since we don't have NSControl, we will convert the format of command
1121     // string and call the function on Editor directly.
1122     String command = name;
1123
1124     // Make sure the first letter is upper case.
1125     command.replace(0, 1, command.substring(0, 1).upper());
1126
1127     // Remove the trailing ':' if existing.
1128     if (command[command.length() - 1] == UChar(':'))
1129         command = command.substring(0, command.length() - 1);
1130
1131     if (command == "Copy") {
1132         WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
1133         if (pluginContainer) {
1134             pluginContainer->copy();
1135             return true;
1136         }
1137     }
1138
1139     bool rv = true;
1140
1141     // Specially handling commands that Editor::execCommand does not directly
1142     // support.
1143     if (command == "DeleteToEndOfParagraph") {
1144         Editor* editor = frame()->editor();
1145         if (!editor->deleteWithDirection(DirectionForward,
1146                                          ParagraphBoundary,
1147                                          true,
1148                                          false)) {
1149             editor->deleteWithDirection(DirectionForward,
1150                                         CharacterGranularity,
1151                                         true,
1152                                         false);
1153         }
1154     } else if (command == "Indent")
1155         frame()->editor()->indent();
1156     else if (command == "Outdent")
1157         frame()->editor()->outdent();
1158     else if (command == "DeleteBackward")
1159         rv = frame()->editor()->command(AtomicString("BackwardDelete")).execute();
1160     else if (command == "DeleteForward")
1161         rv = frame()->editor()->command(AtomicString("ForwardDelete")).execute();
1162     else if (command == "AdvanceToNextMisspelling") {
1163         // False must be passed here, or the currently selected word will never be
1164         // skipped.
1165         frame()->editor()->advanceToNextMisspelling(false);
1166     } else if (command == "ToggleSpellPanel")
1167         frame()->editor()->showSpellingGuessPanel();
1168     else
1169         rv = frame()->editor()->command(command).execute();
1170     return rv;
1171 }
1172
1173 bool WebFrameImpl::executeCommand(const WebString& name, const WebString& value)
1174 {
1175     ASSERT(frame());
1176     String webName = name;
1177
1178     // moveToBeginningOfDocument and moveToEndfDocument are only handled by WebKit
1179     // for editable nodes.
1180     if (!frame()->editor()->canEdit() && webName == "moveToBeginningOfDocument")
1181         return viewImpl()->propagateScroll(ScrollUp, ScrollByDocument);
1182
1183     if (!frame()->editor()->canEdit() && webName == "moveToEndOfDocument")
1184         return viewImpl()->propagateScroll(ScrollDown, ScrollByDocument);
1185
1186     return frame()->editor()->command(webName).execute(value);
1187 }
1188
1189 bool WebFrameImpl::isCommandEnabled(const WebString& name) const
1190 {
1191     ASSERT(frame());
1192     return frame()->editor()->command(name).isEnabled();
1193 }
1194
1195 void WebFrameImpl::enableContinuousSpellChecking(bool enable)
1196 {
1197     if (enable == isContinuousSpellCheckingEnabled())
1198         return;
1199     // Note, the editor will will notify the client that the continuous spell
1200     // checking state has changed by calling
1201     // WebFrameClient::didToggleContinuousSpellChecking().
1202     frame()->editor()->toggleContinuousSpellChecking();
1203 }
1204
1205 bool WebFrameImpl::isContinuousSpellCheckingEnabled() const
1206 {
1207     return frame()->editor()->isContinuousSpellCheckingEnabled();
1208 }
1209
1210 bool WebFrameImpl::hasSelection() const
1211 {
1212     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
1213     if (pluginContainer)
1214         return pluginContainer->plugin()->hasSelection();
1215
1216     // frame()->selection()->isNone() never returns true.
1217     return (frame()->selection()->start() != frame()->selection()->end());
1218 }
1219
1220 WebRange WebFrameImpl::selectionRange() const
1221 {
1222     return frame()->selection()->toNormalizedRange();
1223 }
1224
1225 WebString WebFrameImpl::selectionAsText() const
1226 {
1227     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
1228     if (pluginContainer)
1229         return pluginContainer->plugin()->selectionAsText();
1230
1231     RefPtr<Range> range = frame()->selection()->toNormalizedRange();
1232     if (!range.get())
1233         return WebString();
1234
1235     String text = range->text();
1236 #if OS(WINDOWS)
1237     replaceNewlinesWithWindowsStyleNewlines(text);
1238 #endif
1239     replaceNBSPWithSpace(text);
1240     return text;
1241 }
1242
1243 WebString WebFrameImpl::selectionAsMarkup() const
1244 {
1245     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
1246     if (pluginContainer)
1247         return pluginContainer->plugin()->selectionAsMarkup();
1248
1249     RefPtr<Range> range = frame()->selection()->toNormalizedRange();
1250     if (!range.get())
1251         return WebString();
1252
1253     return createMarkup(range.get(), 0);
1254 }
1255
1256 void WebFrameImpl::selectWordAroundPosition(Frame* frame, VisiblePosition pos)
1257 {
1258     VisibleSelection selection(pos);
1259     selection.expandUsingGranularity(WordGranularity);
1260
1261     if (frame->selection()->shouldChangeSelection(selection)) {
1262         TextGranularity granularity = selection.isRange() ? WordGranularity : CharacterGranularity;
1263         frame->selection()->setSelection(selection, granularity);
1264     }
1265 }
1266
1267 bool WebFrameImpl::selectWordAroundCaret()
1268 {
1269     SelectionController* controller = frame()->selection();
1270     ASSERT(!controller->isNone());
1271     if (controller->isNone() || controller->isRange())
1272         return false;
1273     selectWordAroundPosition(frame(), controller->selection().visibleStart());
1274     return true;
1275 }
1276
1277 int WebFrameImpl::printBegin(const WebSize& pageSize,
1278                              const WebNode& constrainToNode,
1279                              int printerDPI,
1280                              bool* useBrowserOverlays)
1281 {
1282     ASSERT(!frame()->document()->isFrameSet());
1283     WebPluginContainerImpl* pluginContainer = 0;
1284     if (constrainToNode.isNull()) {
1285         // If this is a plugin document, check if the plugin supports its own
1286         // printing. If it does, we will delegate all printing to that.
1287         pluginContainer = pluginContainerFromFrame(frame());
1288     } else {
1289         // We only support printing plugin nodes for now.
1290         const Node* coreNode = constrainToNode.constUnwrap<Node>();
1291         if (coreNode->hasTagName(HTMLNames::objectTag) || coreNode->hasTagName(HTMLNames::embedTag)) {
1292             RenderObject* object = coreNode->renderer();
1293             if (object && object->isWidget()) {
1294                 Widget* widget = toRenderWidget(object)->widget();
1295                 if (widget && widget->isPluginContainer())
1296                     pluginContainer =  static_cast<WebPluginContainerImpl*>(widget);
1297             }
1298         }
1299     }
1300
1301     if (pluginContainer && pluginContainer->supportsPaginatedPrint())
1302         m_printContext.set(new ChromePluginPrintContext(frame(), pluginContainer, printerDPI));
1303     else
1304         m_printContext.set(new ChromePrintContext(frame()));
1305
1306     FloatRect rect(0, 0, static_cast<float>(pageSize.width),
1307                          static_cast<float>(pageSize.height));
1308     m_printContext->begin(rect.width(), rect.height());
1309     float pageHeight;
1310     // We ignore the overlays calculation for now since they are generated in the
1311     // browser. pageHeight is actually an output parameter.
1312     m_printContext->computePageRects(rect, 0, 0, 1.0, pageHeight);
1313     if (useBrowserOverlays)
1314         *useBrowserOverlays = m_printContext->shouldUseBrowserOverlays();
1315
1316     return m_printContext->pageCount();
1317 }
1318
1319 float WebFrameImpl::getPrintPageShrink(int page)
1320 {
1321     // Ensure correct state.
1322     if (!m_printContext.get() || page < 0) {
1323         ASSERT_NOT_REACHED();
1324         return 0;
1325     }
1326
1327     return m_printContext->getPageShrink(page);
1328 }
1329
1330 float WebFrameImpl::printPage(int page, WebCanvas* canvas)
1331 {
1332     // Ensure correct state.
1333     if (!m_printContext.get() || page < 0 || !frame() || !frame()->document()) {
1334         ASSERT_NOT_REACHED();
1335         return 0;
1336     }
1337
1338     return m_printContext->spoolPage(GraphicsContextBuilder(canvas).context(), page);
1339 }
1340
1341 void WebFrameImpl::printEnd()
1342 {
1343     ASSERT(m_printContext.get());
1344     if (m_printContext.get())
1345         m_printContext->end();
1346     m_printContext.clear();
1347 }
1348
1349 bool WebFrameImpl::isPageBoxVisible(int pageIndex)
1350 {
1351     return frame()->document()->isPageBoxVisible(pageIndex);
1352 }
1353
1354 void WebFrameImpl::pageSizeAndMarginsInPixels(int pageIndex,
1355                                               WebSize& pageSize,
1356                                               int& marginTop,
1357                                               int& marginRight,
1358                                               int& marginBottom,
1359                                               int& marginLeft)
1360 {
1361     IntSize size(pageSize.width, pageSize.height);
1362     frame()->document()->pageSizeAndMarginsInPixels(pageIndex,
1363                                                     size,
1364                                                     marginTop,
1365                                                     marginRight,
1366                                                     marginBottom,
1367                                                     marginLeft);
1368     pageSize = size;
1369 }
1370
1371 bool WebFrameImpl::find(int identifier,
1372                         const WebString& searchText,
1373                         const WebFindOptions& options,
1374                         bool wrapWithinFrame,
1375                         WebRect* selectionRect)
1376 {
1377     WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl();
1378
1379     if (!options.findNext)
1380         frame()->page()->unmarkAllTextMatches();
1381     else
1382         setMarkerActive(m_activeMatch.get(), false); // Active match is changing.
1383
1384     // Starts the search from the current selection.
1385     bool startInSelection = true;
1386
1387     // If the user has selected something since the last Find operation we want
1388     // to start from there. Otherwise, we start searching from where the last Find
1389     // operation left off (either a Find or a FindNext operation).
1390     VisibleSelection selection(frame()->selection()->selection());
1391     bool activeSelection = !selection.isNone();
1392     if (!activeSelection && m_activeMatch) {
1393         selection = VisibleSelection(m_activeMatch.get());
1394         frame()->selection()->setSelection(selection);
1395     }
1396
1397     ASSERT(frame() && frame()->view());
1398     bool found = frame()->editor()->findString(
1399         searchText, options.forward, options.matchCase, wrapWithinFrame,
1400         startInSelection);
1401     if (found) {
1402         // Store which frame was active. This will come in handy later when we
1403         // change the active match ordinal below.
1404         WebFrameImpl* oldActiveFrame = mainFrameImpl->m_activeMatchFrame;
1405         // Set this frame as the active frame (the one with the active highlight).
1406         mainFrameImpl->m_activeMatchFrame = this;
1407
1408         // We found something, so we can now query the selection for its position.
1409         VisibleSelection newSelection(frame()->selection()->selection());
1410         IntRect currSelectionRect;
1411
1412         // If we thought we found something, but it couldn't be selected (perhaps
1413         // because it was marked -webkit-user-select: none), we can't set it to
1414         // be active but we still continue searching. This matches Safari's
1415         // behavior, including some oddities when selectable and un-selectable text
1416         // are mixed on a page: see https://bugs.webkit.org/show_bug.cgi?id=19127.
1417         if (newSelection.isNone() || (newSelection.start() == newSelection.end()))
1418             m_activeMatch = 0;
1419         else {
1420             m_activeMatch = newSelection.toNormalizedRange();
1421             currSelectionRect = m_activeMatch->boundingBox();
1422             setMarkerActive(m_activeMatch.get(), true); // Active.
1423             // WebKit draws the highlighting for all matches.
1424             executeCommand(WebString::fromUTF8("Unselect"));
1425         }
1426
1427         // Make sure no node is focused. See http://crbug.com/38700.
1428         frame()->document()->setFocusedNode(0);
1429
1430         if (!options.findNext || activeSelection) {
1431             // This is either a Find operation or a Find-next from a new start point
1432             // due to a selection, so we set the flag to ask the scoping effort
1433             // to find the active rect for us so we can update the ordinal (n of m).
1434             m_locatingActiveRect = true;
1435         } else {
1436             if (oldActiveFrame != this) {
1437                 // If the active frame has changed it means that we have a multi-frame
1438                 // page and we just switch to searching in a new frame. Then we just
1439                 // want to reset the index.
1440                 if (options.forward)
1441                     m_activeMatchIndex = 0;
1442                 else
1443                     m_activeMatchIndex = m_lastMatchCount - 1;
1444             } else {
1445                 // We are still the active frame, so increment (or decrement) the
1446                 // |m_activeMatchIndex|, wrapping if needed (on single frame pages).
1447                 options.forward ? ++m_activeMatchIndex : --m_activeMatchIndex;
1448                 if (m_activeMatchIndex + 1 > m_lastMatchCount)
1449                     m_activeMatchIndex = 0;
1450                 if (m_activeMatchIndex == -1)
1451                     m_activeMatchIndex = m_lastMatchCount - 1;
1452             }
1453             if (selectionRect) {
1454                 WebRect rect = frame()->view()->convertToContainingWindow(currSelectionRect);
1455                 rect.x -= frameView()->scrollOffset().width();
1456                 rect.y -= frameView()->scrollOffset().height();
1457                 *selectionRect = rect;
1458
1459                 reportFindInPageSelection(rect, m_activeMatchIndex + 1, identifier);
1460             }
1461         }
1462     } else {
1463         // Nothing was found in this frame.
1464         m_activeMatch = 0;
1465
1466         // Erase all previous tickmarks and highlighting.
1467         invalidateArea(InvalidateAll);
1468     }
1469
1470     return found;
1471 }
1472
1473 void WebFrameImpl::stopFinding(bool clearSelection)
1474 {
1475     if (!clearSelection)
1476         setFindEndstateFocusAndSelection();
1477     cancelPendingScopingEffort();
1478
1479     // Remove all markers for matches found and turn off the highlighting.
1480     frame()->document()->markers()->removeMarkers(DocumentMarker::TextMatch);
1481     frame()->editor()->setMarkedTextMatchesAreHighlighted(false);
1482
1483     // Let the frame know that we don't want tickmarks or highlighting anymore.
1484     invalidateArea(InvalidateAll);
1485 }
1486
1487 void WebFrameImpl::scopeStringMatches(int identifier,
1488                                       const WebString& searchText,
1489                                       const WebFindOptions& options,
1490                                       bool reset)
1491 {
1492     if (!shouldScopeMatches(searchText))
1493         return;
1494
1495     WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl();
1496
1497     if (reset) {
1498         // This is a brand new search, so we need to reset everything.
1499         // Scoping is just about to begin.
1500         m_scopingComplete = false;
1501         // Clear highlighting for this frame.
1502         if (frame()->editor()->markedTextMatchesAreHighlighted())
1503             frame()->page()->unmarkAllTextMatches();
1504         // Clear the counters from last operation.
1505         m_lastMatchCount = 0;
1506         m_nextInvalidateAfter = 0;
1507
1508         m_resumeScopingFromRange = 0;
1509
1510         mainFrameImpl->m_framesScopingCount++;
1511
1512         // Now, defer scoping until later to allow find operation to finish quickly.
1513         scopeStringMatchesSoon(
1514             identifier,
1515             searchText,
1516             options,
1517             false); // false=we just reset, so don't do it again.
1518         return;
1519     }
1520
1521     RefPtr<Range> searchRange(rangeOfContents(frame()->document()));
1522
1523     Node* originalEndContainer = searchRange->endContainer();
1524     int originalEndOffset = searchRange->endOffset();
1525
1526     ExceptionCode ec = 0, ec2 = 0;
1527     if (m_resumeScopingFromRange.get()) {
1528         // This is a continuation of a scoping operation that timed out and didn't
1529         // complete last time around, so we should start from where we left off.
1530         searchRange->setStart(m_resumeScopingFromRange->startContainer(),
1531                               m_resumeScopingFromRange->startOffset(ec2) + 1,
1532                               ec);
1533         if (ec || ec2) {
1534             if (ec2) // A non-zero |ec| happens when navigating during search.
1535                 ASSERT_NOT_REACHED();
1536             return;
1537         }
1538     }
1539
1540     // This timeout controls how long we scope before releasing control.  This
1541     // value does not prevent us from running for longer than this, but it is
1542     // periodically checked to see if we have exceeded our allocated time.
1543     const double maxScopingDuration = 0.1; // seconds
1544
1545     int matchCount = 0;
1546     bool timedOut = false;
1547     double startTime = currentTime();
1548     do {
1549         // Find next occurrence of the search string.
1550         // FIXME: (http://b/1088245) This WebKit operation may run for longer
1551         // than the timeout value, and is not interruptible as it is currently
1552         // written. We may need to rewrite it with interruptibility in mind, or
1553         // find an alternative.
1554         RefPtr<Range> resultRange(findPlainText(searchRange.get(),
1555                                                 searchText,
1556                                                 true,
1557                                                 options.matchCase));
1558         if (resultRange->collapsed(ec)) {
1559             if (!resultRange->startContainer()->isInShadowTree())
1560                 break;
1561
1562             searchRange->setStartAfter(
1563                 resultRange->startContainer()->shadowAncestorNode(), ec);
1564             searchRange->setEnd(originalEndContainer, originalEndOffset, ec);
1565             continue;
1566         }
1567
1568         // Only treat the result as a match if it is visible
1569         if (frame()->editor()->insideVisibleArea(resultRange.get())) {
1570             ++matchCount;
1571
1572             // Catch a special case where Find found something but doesn't know what
1573             // the bounding box for it is. In this case we set the first match we find
1574             // as the active rect.
1575             IntRect resultBounds = resultRange->boundingBox();
1576             IntRect activeSelectionRect;
1577             if (m_locatingActiveRect) {
1578                 activeSelectionRect = m_activeMatch.get() ?
1579                     m_activeMatch->boundingBox() : resultBounds;
1580             }
1581
1582             // If the Find function found a match it will have stored where the
1583             // match was found in m_activeSelectionRect on the current frame. If we
1584             // find this rect during scoping it means we have found the active
1585             // tickmark.
1586             bool foundActiveMatch = false;
1587             if (m_locatingActiveRect && (activeSelectionRect == resultBounds)) {
1588                 // We have found the active tickmark frame.
1589                 mainFrameImpl->m_activeMatchFrame = this;
1590                 foundActiveMatch = true;
1591                 // We also know which tickmark is active now.
1592                 m_activeMatchIndex = matchCount - 1;
1593                 // To stop looking for the active tickmark, we set this flag.
1594                 m_locatingActiveRect = false;
1595
1596                 // Notify browser of new location for the selected rectangle.
1597                 resultBounds.move(-frameView()->scrollOffset().width(),
1598                                   -frameView()->scrollOffset().height());
1599                 reportFindInPageSelection(
1600                     frame()->view()->convertToContainingWindow(resultBounds),
1601                     m_activeMatchIndex + 1,
1602                     identifier);
1603             }
1604
1605             addMarker(resultRange.get(), foundActiveMatch);
1606         }
1607
1608         // Set the new start for the search range to be the end of the previous
1609         // result range. There is no need to use a VisiblePosition here,
1610         // since findPlainText will use a TextIterator to go over the visible
1611         // text nodes. 
1612         searchRange->setStart(resultRange->endContainer(ec), resultRange->endOffset(ec), ec);
1613
1614         Node* shadowTreeRoot = searchRange->shadowTreeRootNode();
1615         if (searchRange->collapsed(ec) && shadowTreeRoot)
1616             searchRange->setEnd(shadowTreeRoot, shadowTreeRoot->childNodeCount(), ec);
1617
1618         m_resumeScopingFromRange = resultRange;
1619         timedOut = (currentTime() - startTime) >= maxScopingDuration;
1620     } while (!timedOut);
1621
1622     // Remember what we search for last time, so we can skip searching if more
1623     // letters are added to the search string (and last outcome was 0).
1624     m_lastSearchString = searchText;
1625
1626     if (matchCount > 0) {
1627         frame()->editor()->setMarkedTextMatchesAreHighlighted(true);
1628
1629         m_lastMatchCount += matchCount;
1630
1631         // Let the mainframe know how much we found during this pass.
1632         mainFrameImpl->increaseMatchCount(matchCount, identifier);
1633     }
1634
1635     if (timedOut) {
1636         // If we found anything during this pass, we should redraw. However, we
1637         // don't want to spam too much if the page is extremely long, so if we
1638         // reach a certain point we start throttling the redraw requests.
1639         if (matchCount > 0)
1640             invalidateIfNecessary();
1641
1642         // Scoping effort ran out of time, lets ask for another time-slice.
1643         scopeStringMatchesSoon(
1644             identifier,
1645             searchText,
1646             options,
1647             false); // don't reset.
1648         return; // Done for now, resume work later.
1649     }
1650
1651     // This frame has no further scoping left, so it is done. Other frames might,
1652     // of course, continue to scope matches.
1653     m_scopingComplete = true;
1654     mainFrameImpl->m_framesScopingCount--;
1655
1656     // If this is the last frame to finish scoping we need to trigger the final
1657     // update to be sent.
1658     if (!mainFrameImpl->m_framesScopingCount)
1659         mainFrameImpl->increaseMatchCount(0, identifier);
1660
1661     // This frame is done, so show any scrollbar tickmarks we haven't drawn yet.
1662     invalidateArea(InvalidateScrollbar);
1663 }
1664
1665 void WebFrameImpl::cancelPendingScopingEffort()
1666 {
1667     deleteAllValues(m_deferredScopingWork);
1668     m_deferredScopingWork.clear();
1669
1670     m_activeMatchIndex = -1;
1671 }
1672
1673 void WebFrameImpl::increaseMatchCount(int count, int identifier)
1674 {
1675     // This function should only be called on the mainframe.
1676     ASSERT(!parent());
1677
1678     m_totalMatchCount += count;
1679
1680     // Update the UI with the latest findings.
1681     if (client())
1682         client()->reportFindInPageMatchCount(identifier, m_totalMatchCount, !m_framesScopingCount);
1683 }
1684
1685 void WebFrameImpl::reportFindInPageSelection(const WebRect& selectionRect,
1686                                              int activeMatchOrdinal,
1687                                              int identifier)
1688 {
1689     // Update the UI with the latest selection rect.
1690     if (client())
1691         client()->reportFindInPageSelection(identifier, ordinalOfFirstMatchForFrame(this) + activeMatchOrdinal, selectionRect);
1692 }
1693
1694 void WebFrameImpl::resetMatchCount()
1695 {
1696     m_totalMatchCount = 0;
1697     m_framesScopingCount = 0;
1698 }
1699
1700 WebString WebFrameImpl::contentAsText(size_t maxChars) const
1701 {
1702     if (!m_frame)
1703         return WebString();
1704
1705     Vector<UChar> text;
1706     frameContentAsPlainText(maxChars, m_frame, &text);
1707     return String::adopt(text);
1708 }
1709
1710 WebString WebFrameImpl::contentAsMarkup() const
1711 {
1712     return createFullMarkup(m_frame->document());
1713 }
1714
1715 WebString WebFrameImpl::renderTreeAsText() const
1716 {
1717     return externalRepresentation(m_frame);
1718 }
1719
1720 WebString WebFrameImpl::counterValueForElementById(const WebString& id) const
1721 {
1722     if (!m_frame)
1723         return WebString();
1724
1725     Element* element = m_frame->document()->getElementById(id);
1726     if (!element)
1727         return WebString();
1728
1729     return counterValueForElement(element);
1730 }
1731
1732 WebString WebFrameImpl::markerTextForListItem(const WebElement& webElement) const
1733 {
1734     return WebCore::markerTextForListItem(const_cast<Element*>(webElement.constUnwrap<Element>()));
1735 }
1736
1737 int WebFrameImpl::pageNumberForElementById(const WebString& id,
1738                                            float pageWidthInPixels,
1739                                            float pageHeightInPixels) const
1740 {
1741     if (!m_frame)
1742         return -1;
1743
1744     Element* element = m_frame->document()->getElementById(id);
1745     if (!element)
1746         return -1;
1747
1748     FloatSize pageSize(pageWidthInPixels, pageHeightInPixels);
1749     return PrintContext::pageNumberForElement(element, pageSize);
1750 }
1751
1752 WebRect WebFrameImpl::selectionBoundsRect() const
1753 {
1754     if (hasSelection())
1755         return IntRect(frame()->selection()->bounds(false));
1756
1757     return WebRect();
1758 }
1759
1760 bool WebFrameImpl::selectionStartHasSpellingMarkerFor(int from, int length) const
1761 {
1762     if (!m_frame)
1763         return false;
1764     return m_frame->editor()->selectionStartHasSpellingMarkerFor(from, length);
1765 }
1766
1767 bool WebFrameImpl::pauseSVGAnimation(const WebString& animationId, double time, const WebString& elementId)
1768 {
1769 #if !ENABLE(SVG)
1770     return false;
1771 #else
1772     if (!m_frame)
1773         return false;
1774
1775     Document* document = m_frame->document();
1776     if (!document || !document->svgExtensions())
1777         return false;
1778
1779     Node* coreNode = document->getElementById(animationId);
1780     if (!coreNode || !SVGSMILElement::isSMILElement(coreNode))
1781         return false;
1782
1783     return document->accessSVGExtensions()->sampleAnimationAtTime(elementId, static_cast<SVGSMILElement*>(coreNode), time);
1784 #endif
1785 }
1786
1787 WebString WebFrameImpl::layerTreeAsText() const
1788 {
1789     if (!m_frame)
1790         return WebString();
1791     return WebString(m_frame->layerTreeAsText());
1792 }
1793
1794 // WebFrameImpl public ---------------------------------------------------------
1795
1796 PassRefPtr<WebFrameImpl> WebFrameImpl::create(WebFrameClient* client)
1797 {
1798     return adoptRef(new WebFrameImpl(client));
1799 }
1800
1801 WebFrameImpl::WebFrameImpl(WebFrameClient* client)
1802     : m_frameLoaderClient(this)
1803     , m_client(client)
1804     , m_activeMatchFrame(0)
1805     , m_activeMatchIndex(-1)
1806     , m_locatingActiveRect(false)
1807     , m_resumeScopingFromRange(0)
1808     , m_lastMatchCount(-1)
1809     , m_totalMatchCount(-1)
1810     , m_framesScopingCount(-1)
1811     , m_scopingComplete(false)
1812     , m_nextInvalidateAfter(0)
1813     , m_animationController(this)
1814     , m_identifier(generateFrameIdentifier())
1815 {
1816     PlatformBridge::incrementStatsCounter(webFrameActiveCount);
1817     frameCount++;
1818 }
1819
1820 WebFrameImpl::~WebFrameImpl()
1821 {
1822     PlatformBridge::decrementStatsCounter(webFrameActiveCount);
1823     frameCount--;
1824
1825     cancelPendingScopingEffort();
1826     clearPasswordListeners();
1827 }
1828
1829 void WebFrameImpl::initializeAsMainFrame(WebViewImpl* webViewImpl)
1830 {
1831     RefPtr<Frame> frame = Frame::create(webViewImpl->page(), 0, &m_frameLoaderClient);
1832     m_frame = frame.get();
1833
1834     // Add reference on behalf of FrameLoader.  See comments in
1835     // WebFrameLoaderClient::frameLoaderDestroyed for more info.
1836     ref();
1837
1838     // We must call init() after m_frame is assigned because it is referenced
1839     // during init().
1840     m_frame->init();
1841 }
1842
1843 PassRefPtr<Frame> WebFrameImpl::createChildFrame(
1844     const FrameLoadRequest& request, HTMLFrameOwnerElement* ownerElement)
1845 {
1846     RefPtr<WebFrameImpl> webframe(adoptRef(new WebFrameImpl(m_client)));
1847
1848     // Add an extra ref on behalf of the Frame/FrameLoader, which references the
1849     // WebFrame via the FrameLoaderClient interface. See the comment at the top
1850     // of this file for more info.
1851     webframe->ref();
1852
1853     RefPtr<Frame> childFrame = Frame::create(
1854         m_frame->page(), ownerElement, &webframe->m_frameLoaderClient);
1855     webframe->m_frame = childFrame.get();
1856
1857     childFrame->tree()->setName(request.frameName());
1858
1859     m_frame->tree()->appendChild(childFrame);
1860
1861     // Frame::init() can trigger onload event in the parent frame,
1862     // which may detach this frame and trigger a null-pointer access
1863     // in FrameTree::removeChild. Move init() after appendChild call
1864     // so that webframe->mFrame is in the tree before triggering
1865     // onload event handler.
1866     // Because the event handler may set webframe->mFrame to null,
1867     // it is necessary to check the value after calling init() and
1868     // return without loading URL.
1869     // (b:791612)
1870     childFrame->init(); // create an empty document
1871     if (!childFrame->tree()->parent())
1872         return 0;
1873
1874     m_frame->loader()->loadURLIntoChildFrame(
1875         request.resourceRequest().url(),
1876         request.resourceRequest().httpReferrer(),
1877         childFrame.get());
1878
1879     // A synchronous navigation (about:blank) would have already processed
1880     // onload, so it is possible for the frame to have already been destroyed by
1881     // script in the page.
1882     if (!childFrame->tree()->parent())
1883         return 0;
1884
1885     return childFrame.release();
1886 }
1887
1888 void WebFrameImpl::layout()
1889 {
1890     // layout this frame
1891     FrameView* view = m_frame->view();
1892     if (view)
1893         view->updateLayoutAndStyleIfNeededRecursive();
1894 }
1895
1896 void WebFrameImpl::paintWithContext(GraphicsContext& gc, const WebRect& rect)
1897 {
1898     IntRect dirtyRect(rect);
1899     gc.save();
1900     if (m_frame->document() && frameView()) {
1901         gc.clip(dirtyRect);
1902         frameView()->paint(&gc, dirtyRect);
1903         m_frame->page()->inspectorController()->drawNodeHighlight(gc);
1904     } else
1905         gc.fillRect(dirtyRect, Color::white, ColorSpaceDeviceRGB);
1906     gc.restore();
1907 }
1908
1909 void WebFrameImpl::paint(WebCanvas* canvas, const WebRect& rect)
1910 {
1911     if (rect.isEmpty())
1912         return;
1913     paintWithContext(GraphicsContextBuilder(canvas).context(), rect);
1914 }
1915
1916 void WebFrameImpl::createFrameView()
1917 {
1918     ASSERT(m_frame); // If m_frame doesn't exist, we probably didn't init properly.
1919
1920     Page* page = m_frame->page();
1921     ASSERT(page);
1922     ASSERT(page->mainFrame());
1923
1924     bool isMainFrame = m_frame == page->mainFrame();
1925     if (isMainFrame && m_frame->view())
1926         m_frame->view()->setParentVisible(false);
1927
1928     m_frame->setView(0);
1929
1930     WebViewImpl* webView = viewImpl();
1931
1932     RefPtr<FrameView> view;
1933     if (isMainFrame)
1934         view = FrameView::create(m_frame, webView->size());
1935     else
1936         view = FrameView::create(m_frame);
1937
1938     m_frame->setView(view);
1939
1940     if (webView->isTransparent())
1941         view->setTransparent(true);
1942
1943     // FIXME: The Mac code has a comment about this possibly being unnecessary.
1944     // See installInFrame in WebCoreFrameBridge.mm
1945     if (m_frame->ownerRenderer())
1946         m_frame->ownerRenderer()->setWidget(view.get());
1947
1948     if (HTMLFrameOwnerElement* owner = m_frame->ownerElement())
1949         view->setCanHaveScrollbars(owner->scrollingMode() != ScrollbarAlwaysOff);
1950
1951     if (isMainFrame)
1952         view->setParentVisible(true);
1953 }
1954
1955 WebFrameImpl* WebFrameImpl::fromFrame(const Frame* frame)
1956 {
1957     if (!frame)
1958         return 0;
1959
1960     return static_cast<FrameLoaderClientImpl*>(frame->loader()->client())->webFrame();
1961 }
1962
1963 WebFrameImpl* WebFrameImpl::fromFrameOwnerElement(Element* element)
1964 {
1965     if (!element
1966         || !element->isFrameOwnerElement()
1967         || (!element->hasTagName(HTMLNames::iframeTag)
1968             && !element->hasTagName(HTMLNames::frameTag)))
1969         return 0;
1970
1971     HTMLFrameOwnerElement* frameElement =
1972         static_cast<HTMLFrameOwnerElement*>(element);
1973     return fromFrame(frameElement->contentFrame());
1974 }
1975
1976 WebViewImpl* WebFrameImpl::viewImpl() const
1977 {
1978     if (!m_frame)
1979         return 0;
1980
1981     return WebViewImpl::fromPage(m_frame->page());
1982 }
1983
1984 WebDataSourceImpl* WebFrameImpl::dataSourceImpl() const
1985 {
1986     return static_cast<WebDataSourceImpl*>(dataSource());
1987 }
1988
1989 WebDataSourceImpl* WebFrameImpl::provisionalDataSourceImpl() const
1990 {
1991     return static_cast<WebDataSourceImpl*>(provisionalDataSource());
1992 }
1993
1994 void WebFrameImpl::setFindEndstateFocusAndSelection()
1995 {
1996     WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl();
1997
1998     if (this == mainFrameImpl->activeMatchFrame() && m_activeMatch.get()) {
1999         // If the user has set the selection since the match was found, we
2000         // don't focus anything.
2001         VisibleSelection selection(frame()->selection()->selection());
2002         if (!selection.isNone())
2003             return;
2004
2005         // Try to find the first focusable node up the chain, which will, for
2006         // example, focus links if we have found text within the link.
2007         Node* node = m_activeMatch->firstNode();
2008         while (node && !node->isFocusable() && node != frame()->document())
2009             node = node->parentNode();
2010
2011         if (node && node != frame()->document()) {
2012             // Found a focusable parent node. Set focus to it.
2013             frame()->document()->setFocusedNode(node);
2014             return;
2015         }
2016
2017         // Iterate over all the nodes in the range until we find a focusable node.
2018         // This, for example, sets focus to the first link if you search for
2019         // text and text that is within one or more links.
2020         node = m_activeMatch->firstNode();
2021         while (node && node != m_activeMatch->pastLastNode()) {
2022             if (node->isFocusable()) {
2023                 frame()->document()->setFocusedNode(node);
2024                 return;
2025             }
2026             node = node->traverseNextNode();
2027         }
2028
2029         // No node related to the active match was focusable, so set the
2030         // active match as the selection (so that when you end the Find session,
2031         // you'll have the last thing you found highlighted) and make sure that
2032         // we have nothing focused (otherwise you might have text selected but
2033         // a link focused, which is weird).
2034         frame()->selection()->setSelection(m_activeMatch.get());
2035         frame()->document()->setFocusedNode(0);
2036     }
2037 }
2038
2039 void WebFrameImpl::didFail(const ResourceError& error, bool wasProvisional)
2040 {
2041     if (!client())
2042         return;
2043     WebURLError webError = error;
2044     if (wasProvisional)
2045         client()->didFailProvisionalLoad(this, webError);
2046     else
2047         client()->didFailLoad(this, webError);
2048 }
2049
2050 void WebFrameImpl::setCanHaveScrollbars(bool canHaveScrollbars)
2051 {
2052     m_frame->view()->setCanHaveScrollbars(canHaveScrollbars);
2053 }
2054
2055 bool WebFrameImpl::registerPasswordListener(
2056     WebInputElement inputElement,
2057     WebPasswordAutocompleteListener* listener)
2058 {
2059     RefPtr<HTMLInputElement> element(inputElement.unwrap<HTMLInputElement>());
2060     if (!m_passwordListeners.add(element, listener).second) {
2061         delete listener;
2062         return false;
2063     }
2064     return true;
2065 }
2066
2067 void WebFrameImpl::notifiyPasswordListenerOfAutocomplete(
2068     const WebInputElement& inputElement)
2069 {
2070     const HTMLInputElement* element = inputElement.constUnwrap<HTMLInputElement>();
2071     WebPasswordAutocompleteListener* listener = getPasswordListener(element);
2072     // Password listeners need to autocomplete other fields that depend on the
2073     // input element with autofill suggestions.
2074     if (listener)
2075         listener->performInlineAutocomplete(element->value(), false, false);
2076 }
2077
2078 WebPasswordAutocompleteListener* WebFrameImpl::getPasswordListener(
2079     const HTMLInputElement* inputElement)
2080 {
2081     return m_passwordListeners.get(RefPtr<HTMLInputElement>(const_cast<HTMLInputElement*>(inputElement)));
2082 }
2083
2084 // WebFrameImpl private --------------------------------------------------------
2085
2086 void WebFrameImpl::closing()
2087 {
2088     m_frame = 0;
2089 }
2090
2091 void WebFrameImpl::invalidateArea(AreaToInvalidate area)
2092 {
2093     ASSERT(frame() && frame()->view());
2094     FrameView* view = frame()->view();
2095
2096     if ((area & InvalidateAll) == InvalidateAll)
2097         view->invalidateRect(view->frameRect());
2098     else {
2099         if ((area & InvalidateContentArea) == InvalidateContentArea) {
2100             IntRect contentArea(
2101                 view->x(), view->y(), view->visibleWidth(), view->visibleHeight());
2102             IntRect frameRect = view->frameRect();
2103             contentArea.move(-frameRect.x(), -frameRect.y());
2104             view->invalidateRect(contentArea);
2105         }
2106
2107         if ((area & InvalidateScrollbar) == InvalidateScrollbar) {
2108             // Invalidate the vertical scroll bar region for the view.
2109             IntRect scrollBarVert(
2110                 view->x() + view->visibleWidth(), view->y(),
2111                 ScrollbarTheme::nativeTheme()->scrollbarThickness(),
2112                 view->visibleHeight());
2113             IntRect frameRect = view->frameRect();
2114             scrollBarVert.move(-frameRect.x(), -frameRect.y());
2115             view->invalidateRect(scrollBarVert);
2116         }
2117     }
2118 }
2119
2120 void WebFrameImpl::addMarker(Range* range, bool activeMatch)
2121 {
2122     // Use a TextIterator to visit the potentially multiple nodes the range
2123     // covers.
2124     TextIterator markedText(range);
2125     for (; !markedText.atEnd(); markedText.advance()) {
2126         RefPtr<Range> textPiece = markedText.range();
2127         int exception = 0;
2128
2129         DocumentMarker marker = {
2130             DocumentMarker::TextMatch,
2131             textPiece->startOffset(exception),
2132             textPiece->endOffset(exception),
2133             "",
2134             activeMatch
2135         };
2136
2137         if (marker.endOffset > marker.startOffset) {
2138             // Find the node to add a marker to and add it.
2139             Node* node = textPiece->startContainer(exception);
2140             frame()->document()->markers()->addMarker(node, marker);
2141
2142             // Rendered rects for markers in WebKit are not populated until each time
2143             // the markers are painted. However, we need it to happen sooner, because
2144             // the whole purpose of tickmarks on the scrollbar is to show where
2145             // matches off-screen are (that haven't been painted yet).
2146             Vector<DocumentMarker> markers = frame()->document()->markers()->markersForNode(node);
2147             frame()->document()->markers()->setRenderedRectForMarker(
2148                 textPiece->startContainer(exception),
2149                 markers[markers.size() - 1],
2150                 range->boundingBox());
2151         }
2152     }
2153 }
2154
2155 void WebFrameImpl::setMarkerActive(Range* range, bool active)
2156 {
2157     WebCore::ExceptionCode ec;
2158     if (!range || range->collapsed(ec))
2159         return;
2160
2161     frame()->document()->markers()->setMarkersActive(range, active);
2162 }
2163
2164 int WebFrameImpl::ordinalOfFirstMatchForFrame(WebFrameImpl* frame) const
2165 {
2166     int ordinal = 0;
2167     WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl();
2168     // Iterate from the main frame up to (but not including) |frame| and
2169     // add up the number of matches found so far.
2170     for (WebFrameImpl* it = mainFrameImpl;
2171          it != frame;
2172          it = static_cast<WebFrameImpl*>(it->traverseNext(true))) {
2173         if (it->m_lastMatchCount > 0)
2174             ordinal += it->m_lastMatchCount;
2175     }
2176     return ordinal;
2177 }
2178
2179 bool WebFrameImpl::shouldScopeMatches(const String& searchText)
2180 {
2181     // Don't scope if we can't find a frame or a view or if the frame is not visible.
2182     // The user may have closed the tab/application, so abort.
2183     if (!frame() || !frame()->view() || !hasVisibleContent())
2184         return false;
2185
2186     ASSERT(frame()->document() && frame()->view());
2187
2188     // If the frame completed the scoping operation and found 0 matches the last
2189     // time it was searched, then we don't have to search it again if the user is
2190     // just adding to the search string or sending the same search string again.
2191     if (m_scopingComplete && !m_lastSearchString.isEmpty() && !m_lastMatchCount) {
2192         // Check to see if the search string prefixes match.
2193         String previousSearchPrefix =
2194             searchText.substring(0, m_lastSearchString.length());
2195
2196         if (previousSearchPrefix == m_lastSearchString)
2197             return false; // Don't search this frame, it will be fruitless.
2198     }
2199
2200     return true;
2201 }
2202
2203 void WebFrameImpl::scopeStringMatchesSoon(int identifier, const WebString& searchText,
2204                                           const WebFindOptions& options, bool reset)
2205 {
2206     m_deferredScopingWork.append(new DeferredScopeStringMatches(
2207         this, identifier, searchText, options, reset));
2208 }
2209
2210 void WebFrameImpl::callScopeStringMatches(DeferredScopeStringMatches* caller,
2211                                           int identifier, const WebString& searchText,
2212                                           const WebFindOptions& options, bool reset)
2213 {
2214     m_deferredScopingWork.remove(m_deferredScopingWork.find(caller));
2215
2216     scopeStringMatches(identifier, searchText, options, reset);
2217
2218     // This needs to happen last since searchText is passed by reference.
2219     delete caller;
2220 }
2221
2222 void WebFrameImpl::invalidateIfNecessary()
2223 {
2224     if (m_lastMatchCount > m_nextInvalidateAfter) {
2225         // FIXME: (http://b/1088165) Optimize the drawing of the tickmarks and
2226         // remove this. This calculation sets a milestone for when next to
2227         // invalidate the scrollbar and the content area. We do this so that we
2228         // don't spend too much time drawing the scrollbar over and over again.
2229         // Basically, up until the first 500 matches there is no throttle.
2230         // After the first 500 matches, we set set the milestone further and
2231         // further out (750, 1125, 1688, 2K, 3K).
2232         static const int startSlowingDownAfter = 500;
2233         static const int slowdown = 750;
2234         int i = (m_lastMatchCount / startSlowingDownAfter);
2235         m_nextInvalidateAfter += i * slowdown;
2236
2237         invalidateArea(InvalidateScrollbar);
2238     }
2239 }
2240
2241 void WebFrameImpl::clearPasswordListeners()
2242 {
2243     deleteAllValues(m_passwordListeners);
2244     m_passwordListeners.clear();
2245 }
2246
2247 void WebFrameImpl::loadJavaScriptURL(const KURL& url)
2248 {
2249     // This is copied from ScriptController::executeIfJavaScriptURL.
2250     // Unfortunately, we cannot just use that method since it is private, and
2251     // it also doesn't quite behave as we require it to for bookmarklets.  The
2252     // key difference is that we need to suppress loading the string result
2253     // from evaluating the JS URL if executing the JS URL resulted in a
2254     // location change.  We also allow a JS URL to be loaded even if scripts on
2255     // the page are otherwise disabled.
2256
2257     if (!m_frame->document() || !m_frame->page())
2258         return;
2259
2260     String script = decodeURLEscapeSequences(url.string().substring(strlen("javascript:")));
2261     ScriptValue result = m_frame->script()->executeScript(script, true);
2262
2263     String scriptResult;
2264     if (!result.getString(scriptResult))
2265         return;
2266
2267     if (!m_frame->navigationScheduler()->locationChangePending())
2268         m_frame->loader()->writer()->replaceDocument(scriptResult);
2269 }
2270
2271 } // namespace WebKit