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