code.vuplus.com Git - vuplus_webkit/blob - Source/WebKit/chromium/src/WebFrameImpl.cpp

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