src/third_party/WebKit/Source/web/WebLocalFrameImpl.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 //    |           WebFrame
  39 //    |              O
  40 //    |              |
  41 //   Page O------- LocalFrame (m_mainFrame) O-------O FrameView
  42 //                   ||
  43 //                   ||
  44 //               FrameLoader
  45 //
  46 // FrameLoader and LocalFrame are formerly one object that was split apart because
  47 // it got too big. They basically have the same lifetime, hence the double line.
  48 //
  49 // From the perspective of the embedder, WebFrame is simply an object that it
  50 // allocates by calling WebFrame::create() and must be freed by calling close().
  51 // Internally, WebFrame is actually refcounted and it holds a reference to its
  52 // corresponding LocalFrame in blink.
  53 //
  54 // Oilpan: the middle objects + Page in the above diagram are Oilpan heap allocated,
  55 // WebView and FrameView are currently not. In terms of ownership and control, the
  56 // relationships stays the same, but the references from the off-heap WebView to the
  57 // on-heap Page is handled by a Persistent<>, not a RefPtr<>. Similarly, the mutual
  58 // strong references between the on-heap LocalFrame and the off-heap FrameView
  59 // is through a RefPtr (from LocalFrame to FrameView), and a Persistent refers
  60 // to the LocalFrame in the other direction.
  61 //
  62 // From the embedder's point of view, the use of Oilpan brings no changes. close()
  63 // must still be used to signal that the embedder is through with the WebFrame.
  64 // Calling it will bring about the release and finalization of the frame object,
  65 // and everything underneath.
  66 //
  67 // How frames are destroyed
  68 // ------------------------
  69 //
  70 // The main frame is never destroyed and is re-used. The FrameLoader is re-used
  71 // and a reference to the main frame is kept by the Page.
  72 //
  73 // When frame content is replaced, all subframes are destroyed. This happens
  74 // in FrameLoader::detachFromParent for each subframe in a pre-order depth-first
  75 // traversal. Note that child node order may not match DOM node order!
  76 // detachFromParent() calls FrameLoaderClient::detachedFromParent(), which calls
  77 // WebFrame::frameDetached(). This triggers WebFrame to clear its reference to
  78 // LocalFrame, and also notifies the embedder via WebFrameClient that the frame is
  79 // detached. Most embedders will invoke close() on the WebFrame at this point,
  80 // triggering its deletion unless something else is still retaining a reference.
  81 //
  82 // The client is expected to be set whenever the WebLocalFrameImpl is attached to
  83 // the DOM.
  84
  85 #include "config.h"
  86 #include "web/WebLocalFrameImpl.h"
  87
  88 #include "bindings/core/v8/DOMWrapperWorld.h"
  89 #include "bindings/core/v8/ExceptionState.h"
  90 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
  91 #include "bindings/core/v8/ScriptController.h"
  92 #include "bindings/core/v8/ScriptSourceCode.h"
  93 #include "bindings/core/v8/ScriptValue.h"
  94 #include "bindings/core/v8/V8Binding.h"
  95 #include "bindings/core/v8/V8GCController.h"
  96 #include "bindings/core/v8/V8PerIsolateData.h"
  97 #include "core/HTMLNames.h"
  98 #include "core/dom/Document.h"
  99 #include "core/dom/IconURL.h"
 100 #include "core/dom/MessagePort.h"
 101 #include "core/dom/Node.h"
 102 #include "core/dom/NodeTraversal.h"
 103 #include "core/dom/shadow/ShadowRoot.h"
 104 #include "core/editing/Editor.h"
 105 #include "core/editing/FrameSelection.h"
 106 #include "core/editing/InputMethodController.h"
 107 #include "core/editing/PlainTextRange.h"
 108 #include "core/editing/SpellChecker.h"
 109 #include "core/editing/TextAffinity.h"
 110 #include "core/editing/TextIterator.h"
 111 #include "core/editing/htmlediting.h"
 112 #include "core/editing/markup.h"
 113 #include "core/fetch/ResourceFetcher.h"
 114 #include "core/frame/Console.h"
 115 #include "core/frame/LocalDOMWindow.h"
 116 #include "core/frame/FrameHost.h"
 117 #include "core/frame/FrameView.h"
 118 #include "core/frame/Settings.h"
 119 #include "core/html/HTMLAnchorElement.h"
 120 #include "core/html/HTMLCollection.h"
 121 #include "core/html/HTMLFormElement.h"
 122 #include "core/html/HTMLFrameElementBase.h"
 123 #include "core/html/HTMLFrameOwnerElement.h"
 124 #include "core/html/HTMLHeadElement.h"
 125 #include "core/html/HTMLInputElement.h"
 126 #include "core/html/HTMLLinkElement.h"
 127 #include "core/html/PluginDocument.h"
 128 #include "core/inspector/ConsoleMessage.h"
 129 #include "core/inspector/InspectorController.h"
 130 #include "core/inspector/ScriptCallStack.h"
 131 #include "core/loader/DocumentLoader.h"
 132 #include "core/loader/FrameLoadRequest.h"
 133 #include "core/loader/FrameLoader.h"
 134 #include "core/loader/HistoryItem.h"
 135 #include "core/loader/SubstituteData.h"
 136 #include "core/page/Chrome.h"
 137 #include "core/page/EventHandler.h"
 138 #include "core/page/FocusController.h"
 139 #include "core/page/FrameTree.h"
 140 #include "core/page/Page.h"
 141 #include "core/page/PrintContext.h"
 142 #include "core/rendering/HitTestResult.h"
 143 #include "core/rendering/RenderBox.h"
 144 #include "core/rendering/RenderFrame.h"
 145 #include "core/rendering/RenderLayer.h"
 146 #include "core/rendering/RenderObject.h"
 147 #include "core/rendering/RenderTreeAsText.h"
 148 #include "core/rendering/RenderView.h"
 149 #include "core/rendering/style/StyleInheritedData.h"
 150 #include "core/timing/Performance.h"
 151 #include "modules/geolocation/GeolocationController.h"
 152 #include "modules/notifications/NotificationController.h"
 153 #include "modules/notifications/NotificationPermissionClient.h"
 154 #include "modules/screen_orientation/ScreenOrientationController.h"
 155 #include "platform/TraceEvent.h"
 156 #include "platform/UserGestureIndicator.h"
 157 #include "platform/clipboard/ClipboardUtilities.h"
 158 #include "platform/fonts/FontCache.h"
 159 #include "platform/graphics/GraphicsContext.h"
 160 #include "platform/graphics/GraphicsLayerClient.h"
 161 #include "platform/graphics/skia/SkiaUtils.h"
 162 #include "platform/heap/Handle.h"
 163 #include "platform/network/ResourceRequest.h"
 164 #include "platform/scroll/ScrollTypes.h"
 165 #include "platform/scroll/ScrollbarTheme.h"
 166 #include "platform/weborigin/KURL.h"
 167 #include "platform/weborigin/SchemeRegistry.h"
 168 #include "platform/weborigin/SecurityPolicy.h"
 169 #include "public/platform/Platform.h"
 170 #include "public/platform/WebFloatPoint.h"
 171 #include "public/platform/WebFloatRect.h"
 172 #include "public/platform/WebLayer.h"
 173 #include "public/platform/WebPoint.h"
 174 #include "public/platform/WebRect.h"
 175 #include "public/platform/WebSize.h"
 176 #include "public/platform/WebURLError.h"
 177 #include "public/platform/WebVector.h"
 178 #include "public/web/WebConsoleMessage.h"
 179 #include "public/web/WebDOMEvent.h"
 180 #include "public/web/WebDocument.h"
 181 #include "public/web/WebFindOptions.h"
 182 #include "public/web/WebFormElement.h"
 183 #include "public/web/WebFrameClient.h"
 184 #include "public/web/WebHistoryItem.h"
 185 #include "public/web/WebIconURL.h"
 186 #include "public/web/WebInputElement.h"
 187 #include "public/web/WebNode.h"
 188 #include "public/web/WebPerformance.h"
 189 #include "public/web/WebPlugin.h"
 190 #include "public/web/WebPrintParams.h"
 191 #include "public/web/WebRange.h"
 192 #include "public/web/WebScriptSource.h"
 193 #include "public/web/WebSecurityOrigin.h"
 194 #include "public/web/WebSerializedScriptValue.h"
 195 #include "web/AssociatedURLLoader.h"
 196 #include "web/CompositionUnderlineVectorBuilder.h"
 197 #include "web/FindInPageCoordinates.h"
 198 #include "web/GeolocationClientProxy.h"
 199 #include "web/LocalFileSystemClient.h"
 200 #include "web/MIDIClientProxy.h"
 201 #include "web/NotificationPermissionClientImpl.h"
 202 #include "web/PageOverlay.h"
 203 #include "web/SharedWorkerRepositoryClientImpl.h"
 204 #include "web/TextFinder.h"
 205 #include "web/WebDataSourceImpl.h"
 206 #include "web/WebDevToolsAgentPrivate.h"
 207 #include "web/WebPluginContainerImpl.h"
 208 #include "web/WebViewImpl.h"
 209 #include "wtf/CurrentTime.h"
 210 #include "wtf/HashMap.h"
 211 #include <algorithm>
 212
 213 namespace blink {
 214
 215 static int frameCount = 0;
 216
 217 // Key for a StatsCounter tracking how many WebFrames are active.
 218 static const char webFrameActiveCount[] = "WebFrameActiveCount";
 219
 220 static void frameContentAsPlainText(size_t maxChars, LocalFrame* frame, StringBuilder& output)
 221 {
 222     Document* document = frame->document();
 223     if (!document)
 224         return;
 225
 226     if (!frame->view())
 227         return;
 228
 229     // Select the document body.
 230     RefPtrWillBeRawPtr<Range> range(document->createRange());
 231     TrackExceptionState exceptionState;
 232     range->selectNodeContents(document->body(), exceptionState);
 233
 234     if (!exceptionState.hadException()) {
 235         // The text iterator will walk nodes giving us text. This is similar to
 236         // the plainText() function in core/editing/TextIterator.h, but we implement the maximum
 237         // size and also copy the results directly into a wstring, avoiding the
 238         // string conversion.
 239         for (TextIterator it(range.get()); !it.atEnd(); it.advance()) {
 240             it.appendTextToStringBuilder(output, 0, maxChars - output.length());
 241             if (output.length() >= maxChars)
 242                 return; // Filled up the buffer.
 243         }
 244     }
 245
 246     // The separator between frames when the frames are converted to plain text.
 247     const LChar frameSeparator[] = { '\n', '\n' };
 248     const size_t frameSeparatorLength = WTF_ARRAY_LENGTH(frameSeparator);
 249
 250     // Recursively walk the children.
 251     const FrameTree& frameTree = frame->tree();
 252     for (Frame* curChild = frameTree.firstChild(); curChild; curChild = curChild->tree().nextSibling()) {
 253         if (!curChild->isLocalFrame())
 254             continue;
 255         LocalFrame* curLocalChild = toLocalFrame(curChild);
 256         // Ignore the text of non-visible frames.
 257         RenderView* contentRenderer = curLocalChild->contentRenderer();
 258         RenderPart* ownerRenderer = curLocalChild->ownerRenderer();
 259         if (!contentRenderer || !contentRenderer->width() || !contentRenderer->height()
 260             || (contentRenderer->x() + contentRenderer->width() <= 0) || (contentRenderer->y() + contentRenderer->height() <= 0)
 261             || (ownerRenderer && ownerRenderer->style() && ownerRenderer->style()->visibility() != VISIBLE)) {
 262             continue;
 263         }
 264
 265         // Make sure the frame separator won't fill up the buffer, and give up if
 266         // it will. The danger is if the separator will make the buffer longer than
 267         // maxChars. This will cause the computation above:
 268         //   maxChars - output->size()
 269         // to be a negative number which will crash when the subframe is added.
 270         if (output.length() >= maxChars - frameSeparatorLength)
 271             return;
 272
 273         output.append(frameSeparator, frameSeparatorLength);
 274         frameContentAsPlainText(maxChars, curLocalChild, output);
 275         if (output.length() >= maxChars)
 276             return; // Filled up the buffer.
 277     }
 278 }
 279
 280 WebPluginContainerImpl* WebLocalFrameImpl::pluginContainerFromFrame(LocalFrame* frame)
 281 {
 282     if (!frame)
 283         return 0;
 284     if (!frame->document() || !frame->document()->isPluginDocument())
 285         return 0;
 286     PluginDocument* pluginDocument = toPluginDocument(frame->document());
 287     return toWebPluginContainerImpl(pluginDocument->pluginWidget());
 288 }
 289
 290 WebPluginContainerImpl* WebLocalFrameImpl::pluginContainerFromNode(LocalFrame* frame, const WebNode& node)
 291 {
 292     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame);
 293     if (pluginContainer)
 294         return pluginContainer;
 295     return toWebPluginContainerImpl(node.pluginContainer());
 296 }
 297
 298 // Simple class to override some of PrintContext behavior. Some of the methods
 299 // made virtual so that they can be overridden by ChromePluginPrintContext.
 300 class ChromePrintContext : public PrintContext {
 301     WTF_MAKE_NONCOPYABLE(ChromePrintContext);
 302 public:
 303     ChromePrintContext(LocalFrame* frame)
 304         : PrintContext(frame)
 305         , m_printedPageWidth(0)
 306     {
 307     }
 308
 309     virtual ~ChromePrintContext() { }
 310
 311     virtual void begin(float width, float height)
 312     {
 313         ASSERT(!m_printedPageWidth);
 314         m_printedPageWidth = width;
 315         PrintContext::begin(m_printedPageWidth, height);
 316     }
 317
 318     virtual float getPageShrink(int pageNumber) const
 319     {
 320         IntRect pageRect = m_pageRects[pageNumber];
 321         return m_printedPageWidth / pageRect.width();
 322     }
 323
 324     float spoolSinglePage(GraphicsContext& graphicsContext, int pageNumber)
 325     {
 326         // FIXME: Why is it ok to proceed without all the null checks that
 327         // spoolAllPagesWithBoundaries does?
 328         frame()->view()->updateLayoutAndStyleForPainting();
 329         return spoolPage(graphicsContext, pageNumber);
 330     }
 331
 332     void spoolAllPagesWithBoundaries(GraphicsContext& graphicsContext, const FloatSize& pageSizeInPixels)
 333     {
 334         if (!frame()->document() || !frame()->view() || !frame()->document()->renderView())
 335             return;
 336
 337         frame()->view()->updateLayoutAndStyleForPainting();
 338
 339         float pageHeight;
 340         computePageRects(FloatRect(FloatPoint(0, 0), pageSizeInPixels), 0, 0, 1, pageHeight);
 341
 342         const float pageWidth = pageSizeInPixels.width();
 343         size_t numPages = pageRects().size();
 344         int totalHeight = numPages * (pageSizeInPixels.height() + 1) - 1;
 345
 346         // Fill the whole background by white.
 347         graphicsContext.setFillColor(Color::white);
 348         graphicsContext.fillRect(FloatRect(0, 0, pageWidth, totalHeight));
 349
 350         int currentHeight = 0;
 351         for (size_t pageIndex = 0; pageIndex < numPages; pageIndex++) {
 352             // Draw a line for a page boundary if this isn't the first page.
 353             if (pageIndex > 0) {
 354                 graphicsContext.save();
 355                 graphicsContext.setStrokeColor(Color(0, 0, 255));
 356                 graphicsContext.setFillColor(Color(0, 0, 255));
 357                 graphicsContext.drawLine(IntPoint(0, currentHeight), IntPoint(pageWidth, currentHeight));
 358                 graphicsContext.restore();
 359             }
 360
 361             graphicsContext.save();
 362
 363             graphicsContext.translate(0, currentHeight);
 364 #if OS(WIN) || OS(MACOSX)
 365             // Account for the disabling of scaling in spoolPage. In the context
 366             // of spoolAllPagesWithBoundaries the scale HAS NOT been pre-applied.
 367             float scale = getPageShrink(pageIndex);
 368             graphicsContext.scale(scale, scale);
 369 #endif
 370             spoolPage(graphicsContext, pageIndex);
 371             graphicsContext.restore();
 372
 373             currentHeight += pageSizeInPixels.height() + 1;
 374         }
 375     }
 376
 377 protected:
 378     // Spools the printed page, a subrect of frame(). Skip the scale step.
 379     // NativeTheme doesn't play well with scaling. Scaling is done browser side
 380     // instead. Returns the scale to be applied.
 381     // On Linux, we don't have the problem with NativeTheme, hence we let WebKit
 382     // do the scaling and ignore the return value.
 383     virtual float spoolPage(GraphicsContext& context, int pageNumber)
 384     {
 385         IntRect pageRect = m_pageRects[pageNumber];
 386         float scale = m_printedPageWidth / pageRect.width();
 387
 388         context.save();
 389 #if OS(POSIX) && !OS(MACOSX)
 390         context.scale(scale, scale);
 391 #endif
 392         context.translate(static_cast<float>(-pageRect.x()), static_cast<float>(-pageRect.y()));
 393         context.clip(pageRect);
 394         frame()->view()->paintContents(&context, pageRect);
 395         outputLinkAndLinkedDestinations(context, frame()->document(), pageRect);
 396         context.restore();
 397         return scale;
 398     }
 399
 400 private:
 401     // Set when printing.
 402     float m_printedPageWidth;
 403 };
 404
 405 // Simple class to override some of PrintContext behavior. This is used when
 406 // the frame hosts a plugin that supports custom printing. In this case, we
 407 // want to delegate all printing related calls to the plugin.
 408 class ChromePluginPrintContext FINAL : public ChromePrintContext {
 409 public:
 410     ChromePluginPrintContext(LocalFrame* frame, WebPluginContainerImpl* plugin, const WebPrintParams& printParams)
 411         : ChromePrintContext(frame), m_plugin(plugin), m_printParams(printParams)
 412     {
 413     }
 414
 415     virtual ~ChromePluginPrintContext() { }
 416
 417     virtual void begin(float width, float height) OVERRIDE
 418     {
 419     }
 420
 421     virtual void end() OVERRIDE
 422     {
 423         m_plugin->printEnd();
 424     }
 425
 426     virtual float getPageShrink(int pageNumber) const OVERRIDE
 427     {
 428         // We don't shrink the page (maybe we should ask the widget ??)
 429         return 1.0;
 430     }
 431
 432     virtual void computePageRects(const FloatRect& printRect, float headerHeight, float footerHeight, float userScaleFactor, float& outPageHeight) OVERRIDE
 433     {
 434         m_printParams.printContentArea = IntRect(printRect);
 435         m_pageRects.fill(IntRect(printRect), m_plugin->printBegin(m_printParams));
 436     }
 437
 438     virtual void computePageRectsWithPageSize(const FloatSize& pageSizeInPixels, bool allowHorizontalTiling) OVERRIDE
 439     {
 440         ASSERT_NOT_REACHED();
 441     }
 442
 443 protected:
 444     // Spools the printed page, a subrect of frame(). Skip the scale step.
 445     // NativeTheme doesn't play well with scaling. Scaling is done browser side
 446     // instead. Returns the scale to be applied.
 447     virtual float spoolPage(GraphicsContext& context, int pageNumber) OVERRIDE
 448     {
 449         m_plugin->printPage(pageNumber, &context);
 450         return 1.0;
 451     }
 452
 453 private:
 454     // Set when printing.
 455     WebPluginContainerImpl* m_plugin;
 456     WebPrintParams m_printParams;
 457 };
 458
 459 static WebDataSource* DataSourceForDocLoader(DocumentLoader* loader)
 460 {
 461     return loader ? WebDataSourceImpl::fromDocumentLoader(loader) : 0;
 462 }
 463
 464 // WebFrame -------------------------------------------------------------------
 465
 466 int WebFrame::instanceCount()
 467 {
 468     return frameCount;
 469 }
 470
 471 WebLocalFrame* WebLocalFrame::frameForCurrentContext()
 472 {
 473     v8::Handle<v8::Context> context = v8::Isolate::GetCurrent()->GetCurrentContext();
 474     if (context.IsEmpty())
 475         return 0;
 476     return frameForContext(context);
 477 }
 478
 479 WebLocalFrame* WebLocalFrame::frameForContext(v8::Handle<v8::Context> context)
 480 {
 481     return WebLocalFrameImpl::fromFrame(toFrameIfNotDetached(context));
 482 }
 483
 484 WebLocalFrame* WebLocalFrame::fromFrameOwnerElement(const WebElement& element)
 485 {
 486     return WebLocalFrameImpl::fromFrameOwnerElement(PassRefPtrWillBeRawPtr<Element>(element).get());
 487 }
 488
 489 bool WebLocalFrameImpl::isWebLocalFrame() const
 490 {
 491     return true;
 492 }
 493
 494 WebLocalFrame* WebLocalFrameImpl::toWebLocalFrame()
 495 {
 496     return this;
 497 }
 498
 499 bool WebLocalFrameImpl::isWebRemoteFrame() const
 500 {
 501     return false;
 502 }
 503
 504 WebRemoteFrame* WebLocalFrameImpl::toWebRemoteFrame()
 505 {
 506     ASSERT_NOT_REACHED();
 507     return 0;
 508 }
 509
 510 void WebLocalFrameImpl::close()
 511 {
 512     m_client = 0;
 513
 514 #if ENABLE(OILPAN)
 515     m_selfKeepAlive.clear();
 516 #else
 517     deref(); // Balances ref() acquired in WebFrame::create
 518 #endif
 519 }
 520
 521 WebString WebLocalFrameImpl::uniqueName() const
 522 {
 523     return frame()->tree().uniqueName();
 524 }
 525
 526 WebString WebLocalFrameImpl::assignedName() const
 527 {
 528     return frame()->tree().name();
 529 }
 530
 531 void WebLocalFrameImpl::setName(const WebString& name)
 532 {
 533     frame()->tree().setName(name);
 534 }
 535
 536 WebVector<WebIconURL> WebLocalFrameImpl::iconURLs(int iconTypesMask) const
 537 {
 538     // The URL to the icon may be in the header. As such, only
 539     // ask the loader for the icon if it's finished loading.
 540     if (frame()->loader().state() == FrameStateComplete)
 541         return frame()->document()->iconURLs(iconTypesMask);
 542     return WebVector<WebIconURL>();
 543 }
 544
 545 void WebLocalFrameImpl::setIsRemote(bool isRemote)
 546 {
 547     m_isRemote = isRemote;
 548     if (isRemote)
 549         client()->initializeChildFrame(frame()->view()->frameRect(), frame()->view()->visibleContentScaleFactor());
 550 }
 551
 552 void WebLocalFrameImpl::setRemoteWebLayer(WebLayer* webLayer)
 553 {
 554     if (!frame())
 555         return;
 556
 557     frame()->setRemotePlatformLayer(webLayer);
 558 }
 559
 560 void WebLocalFrameImpl::setPermissionClient(WebPermissionClient* permissionClient)
 561 {
 562     m_permissionClient = permissionClient;
 563 }
 564
 565 void WebLocalFrameImpl::setSharedWorkerRepositoryClient(WebSharedWorkerRepositoryClient* client)
 566 {
 567     m_sharedWorkerRepositoryClient = SharedWorkerRepositoryClientImpl::create(client);
 568 }
 569
 570 WebSize WebLocalFrameImpl::scrollOffset() const
 571 {
 572     FrameView* view = frameView();
 573     if (!view)
 574         return WebSize();
 575     return view->scrollOffset();
 576 }
 577
 578 WebSize WebLocalFrameImpl::minimumScrollOffset() const
 579 {
 580     FrameView* view = frameView();
 581     if (!view)
 582         return WebSize();
 583     return toIntSize(view->minimumScrollPosition());
 584 }
 585
 586 WebSize WebLocalFrameImpl::maximumScrollOffset() const
 587 {
 588     FrameView* view = frameView();
 589     if (!view)
 590         return WebSize();
 591     return toIntSize(view->maximumScrollPosition());
 592 }
 593
 594 void WebLocalFrameImpl::setScrollOffset(const WebSize& offset)
 595 {
 596     if (FrameView* view = frameView())
 597         view->setScrollOffset(IntPoint(offset.width, offset.height));
 598 }
 599
 600 WebSize WebLocalFrameImpl::contentsSize() const
 601 {
 602     if (FrameView* view = frameView())
 603         return view->contentsSize();
 604     return WebSize();
 605 }
 606
 607 bool WebLocalFrameImpl::hasVisibleContent() const
 608 {
 609     if (RenderPart* renderer = frame()->ownerRenderer()) {
 610         if (renderer->style()->visibility() != VISIBLE)
 611             return false;
 612     }
 613
 614     if (FrameView* view = frameView())
 615         return view->visibleWidth() > 0 && view->visibleHeight() > 0;
 616     return false;
 617 }
 618
 619 WebRect WebLocalFrameImpl::visibleContentRect() const
 620 {
 621     if (FrameView* view = frameView())
 622         return view->visibleContentRect();
 623     return WebRect();
 624 }
 625
 626 bool WebLocalFrameImpl::hasHorizontalScrollbar() const
 627 {
 628     return frame() && frame()->view() && frame()->view()->horizontalScrollbar();
 629 }
 630
 631 bool WebLocalFrameImpl::hasVerticalScrollbar() const
 632 {
 633     return frame() && frame()->view() && frame()->view()->verticalScrollbar();
 634 }
 635
 636 WebView* WebLocalFrameImpl::view() const
 637 {
 638     return viewImpl();
 639 }
 640
 641 void WebLocalFrameImpl::setOpener(WebFrame* opener)
 642 {
 643     // FIXME: Does this need to move up into WebFrame too?
 644     if (WebFrame::opener() && !opener && m_client)
 645         m_client->didDisownOpener(this);
 646
 647     WebFrame::setOpener(opener);
 648
 649     ASSERT(m_frame);
 650     if (m_frame && m_frame->document())
 651         m_frame->document()->initSecurityContext();
 652 }
 653
 654 WebDocument WebLocalFrameImpl::document() const
 655 {
 656     if (!frame() || !frame()->document())
 657         return WebDocument();
 658     return WebDocument(frame()->document());
 659 }
 660
 661 WebPerformance WebLocalFrameImpl::performance() const
 662 {
 663     if (!frame())
 664         return WebPerformance();
 665     return WebPerformance(&frame()->domWindow()->performance());
 666 }
 667
 668 bool WebLocalFrameImpl::dispatchBeforeUnloadEvent()
 669 {
 670     if (!frame())
 671         return true;
 672     return frame()->loader().shouldClose();
 673 }
 674
 675 void WebLocalFrameImpl::dispatchUnloadEvent()
 676 {
 677     if (!frame())
 678         return;
 679     frame()->loader().closeURL();
 680 }
 681
 682 NPObject* WebLocalFrameImpl::windowObject() const
 683 {
 684     if (!frame())
 685         return 0;
 686     return frame()->script().windowScriptNPObject();
 687 }
 688
 689 void WebLocalFrameImpl::bindToWindowObject(const WebString& name, NPObject* object)
 690 {
 691     bindToWindowObject(name, object, 0);
 692 }
 693
 694 void WebLocalFrameImpl::bindToWindowObject(const WebString& name, NPObject* object, void*)
 695 {
 696     if (!frame() || !frame()->script().canExecuteScripts(NotAboutToExecuteScript))
 697         return;
 698     frame()->script().bindToWindowObject(frame(), String(name), object);
 699 }
 700
 701 void WebLocalFrameImpl::executeScript(const WebScriptSource& source)
 702 {
 703     ASSERT(frame());
 704     TextPosition position(OrdinalNumber::fromOneBasedInt(source.startLine), OrdinalNumber::first());
 705     v8::HandleScope handleScope(toIsolate(frame()));
 706     frame()->script().executeScriptInMainWorld(ScriptSourceCode(source.code, source.url, position));
 707 }
 708
 709 void WebLocalFrameImpl::executeScriptInIsolatedWorld(int worldID, const WebScriptSource* sourcesIn, unsigned numSources, int extensionGroup)
 710 {
 711     ASSERT(frame());
 712     RELEASE_ASSERT(worldID > 0);
 713     RELEASE_ASSERT(worldID < EmbedderWorldIdLimit);
 714
 715     Vector<ScriptSourceCode> sources;
 716     for (unsigned i = 0; i < numSources; ++i) {
 717         TextPosition position(OrdinalNumber::fromOneBasedInt(sourcesIn[i].startLine), OrdinalNumber::first());
 718         sources.append(ScriptSourceCode(sourcesIn[i].code, sourcesIn[i].url, position));
 719     }
 720
 721     v8::HandleScope handleScope(toIsolate(frame()));
 722     frame()->script().executeScriptInIsolatedWorld(worldID, sources, extensionGroup, 0);
 723 }
 724
 725 void WebLocalFrameImpl::setIsolatedWorldSecurityOrigin(int worldID, const WebSecurityOrigin& securityOrigin)
 726 {
 727     ASSERT(frame());
 728     DOMWrapperWorld::setIsolatedWorldSecurityOrigin(worldID, securityOrigin.get());
 729 }
 730
 731 void WebLocalFrameImpl::setIsolatedWorldContentSecurityPolicy(int worldID, const WebString& policy)
 732 {
 733     ASSERT(frame());
 734     DOMWrapperWorld::setIsolatedWorldContentSecurityPolicy(worldID, policy);
 735 }
 736
 737 void WebLocalFrameImpl::setIsolatedWorldHumanReadableName(int worldID, const WebString& humanReadableName)
 738 {
 739     ASSERT(frame());
 740     DOMWrapperWorld::setIsolatedWorldHumanReadableName(worldID, humanReadableName);
 741 }
 742
 743 void WebLocalFrameImpl::addMessageToConsole(const WebConsoleMessage& message)
 744 {
 745     ASSERT(frame());
 746
 747     MessageLevel webCoreMessageLevel;
 748     switch (message.level) {
 749     case WebConsoleMessage::LevelDebug:
 750         webCoreMessageLevel = DebugMessageLevel;
 751         break;
 752     case WebConsoleMessage::LevelLog:
 753         webCoreMessageLevel = LogMessageLevel;
 754         break;
 755     case WebConsoleMessage::LevelWarning:
 756         webCoreMessageLevel = WarningMessageLevel;
 757         break;
 758     case WebConsoleMessage::LevelError:
 759         webCoreMessageLevel = ErrorMessageLevel;
 760         break;
 761     default:
 762         ASSERT_NOT_REACHED();
 763         return;
 764     }
 765
 766     frame()->document()->addConsoleMessage(ConsoleMessage::create(OtherMessageSource, webCoreMessageLevel, message.text));
 767 }
 768
 769 void WebLocalFrameImpl::collectGarbage()
 770 {
 771     if (!frame())
 772         return;
 773     if (!frame()->settings()->scriptEnabled())
 774         return;
 775     V8GCController::collectGarbage(v8::Isolate::GetCurrent());
 776 }
 777
 778 bool WebLocalFrameImpl::checkIfRunInsecureContent(const WebURL& url) const
 779 {
 780     ASSERT(frame());
 781     return frame()->loader().mixedContentChecker()->canFrameInsecureContent(frame()->document()->securityOrigin(), url);
 782 }
 783
 784 v8::Handle<v8::Value> WebLocalFrameImpl::executeScriptAndReturnValue(const WebScriptSource& source)
 785 {
 786     ASSERT(frame());
 787
 788     TextPosition position(OrdinalNumber::fromOneBasedInt(source.startLine), OrdinalNumber::first());
 789     return frame()->script().executeScriptInMainWorldAndReturnValue(ScriptSourceCode(source.code, source.url, position));
 790 }
 791
 792 void WebLocalFrameImpl::executeScriptInIsolatedWorld(int worldID, const WebScriptSource* sourcesIn, unsigned numSources, int extensionGroup, WebVector<v8::Local<v8::Value> >* results)
 793 {
 794     ASSERT(frame());
 795     RELEASE_ASSERT(worldID > 0);
 796     RELEASE_ASSERT(worldID < EmbedderWorldIdLimit);
 797
 798     Vector<ScriptSourceCode> sources;
 799
 800     for (unsigned i = 0; i < numSources; ++i) {
 801         TextPosition position(OrdinalNumber::fromOneBasedInt(sourcesIn[i].startLine), OrdinalNumber::first());
 802         sources.append(ScriptSourceCode(sourcesIn[i].code, sourcesIn[i].url, position));
 803     }
 804
 805     if (results) {
 806         Vector<v8::Local<v8::Value> > scriptResults;
 807         frame()->script().executeScriptInIsolatedWorld(worldID, sources, extensionGroup, &scriptResults);
 808         WebVector<v8::Local<v8::Value> > v8Results(scriptResults.size());
 809         for (unsigned i = 0; i < scriptResults.size(); i++)
 810             v8Results[i] = v8::Local<v8::Value>::New(toIsolate(frame()), scriptResults[i]);
 811         results->swap(v8Results);
 812     } else {
 813         v8::HandleScope handleScope(toIsolate(frame()));
 814         frame()->script().executeScriptInIsolatedWorld(worldID, sources, extensionGroup, 0);
 815     }
 816 }
 817
 818 v8::Handle<v8::Value> WebLocalFrameImpl::callFunctionEvenIfScriptDisabled(v8::Handle<v8::Function> function, v8::Handle<v8::Value> receiver, int argc, v8::Handle<v8::Value> argv[])
 819 {
 820     ASSERT(frame());
 821     return frame()->script().callFunction(function, receiver, argc, argv);
 822 }
 823
 824 v8::Local<v8::Context> WebLocalFrameImpl::mainWorldScriptContext() const
 825 {
 826     return toV8Context(frame(), DOMWrapperWorld::mainWorld());
 827 }
 828
 829 void WebLocalFrameImpl::reload(bool ignoreCache)
 830 {
 831     ASSERT(frame());
 832     frame()->loader().reload(ignoreCache ? EndToEndReload : NormalReload);
 833 }
 834
 835 void WebLocalFrameImpl::reloadWithOverrideURL(const WebURL& overrideUrl, bool ignoreCache)
 836 {
 837     ASSERT(frame());
 838     frame()->loader().reload(ignoreCache ? EndToEndReload : NormalReload, overrideUrl);
 839 }
 840
 841 void WebLocalFrameImpl::loadRequest(const WebURLRequest& request)
 842 {
 843     ASSERT(frame());
 844     ASSERT(!request.isNull());
 845     const ResourceRequest& resourceRequest = request.toResourceRequest();
 846
 847     if (resourceRequest.url().protocolIs("javascript")) {
 848         loadJavaScriptURL(resourceRequest.url());
 849         return;
 850     }
 851
 852     frame()->loader().load(FrameLoadRequest(0, resourceRequest));
 853 }
 854
 855 void WebLocalFrameImpl::loadHistoryItem(const WebHistoryItem& item, WebHistoryLoadType loadType, WebURLRequest::CachePolicy cachePolicy)
 856 {
 857     ASSERT(frame());
 858     RefPtr<HistoryItem> historyItem = PassRefPtr<HistoryItem>(item);
 859     ASSERT(historyItem);
 860     frame()->loader().loadHistoryItem(historyItem.get(), static_cast<HistoryLoadType>(loadType), static_cast<ResourceRequestCachePolicy>(cachePolicy));
 861 }
 862
 863 void WebLocalFrameImpl::loadData(const WebData& data, const WebString& mimeType, const WebString& textEncoding, const WebURL& baseURL, const WebURL& unreachableURL, bool replace)
 864 {
 865     ASSERT(frame());
 866
 867     // If we are loading substitute data to replace an existing load, then
 868     // inherit all of the properties of that original request. This way,
 869     // reload will re-attempt the original request. It is essential that
 870     // we only do this when there is an unreachableURL since a non-empty
 871     // unreachableURL informs FrameLoader::reload to load unreachableURL
 872     // instead of the currently loaded URL.
 873     ResourceRequest request;
 874     if (replace && !unreachableURL.isEmpty() && frame()->loader().provisionalDocumentLoader())
 875         request = frame()->loader().provisionalDocumentLoader()->originalRequest();
 876     request.setURL(baseURL);
 877
 878     FrameLoadRequest frameRequest(0, request, SubstituteData(data, mimeType, textEncoding, unreachableURL));
 879     ASSERT(frameRequest.substituteData().isValid());
 880     frameRequest.setLockBackForwardList(replace);
 881     frame()->loader().load(frameRequest);
 882 }
 883
 884 void WebLocalFrameImpl::loadHTMLString(const WebData& data, const WebURL& baseURL, const WebURL& unreachableURL, bool replace)
 885 {
 886     ASSERT(frame());
 887     loadData(data, WebString::fromUTF8("text/html"), WebString::fromUTF8("UTF-8"), baseURL, unreachableURL, replace);
 888 }
 889
 890 void WebLocalFrameImpl::stopLoading()
 891 {
 892     if (!frame())
 893         return;
 894     // FIXME: Figure out what we should really do here. It seems like a bug
 895     // that FrameLoader::stopLoading doesn't call stopAllLoaders.
 896     frame()->loader().stopAllLoaders();
 897 }
 898
 899 WebDataSource* WebLocalFrameImpl::provisionalDataSource() const
 900 {
 901     ASSERT(frame());
 902
 903     // We regard the policy document loader as still provisional.
 904     DocumentLoader* documentLoader = frame()->loader().provisionalDocumentLoader();
 905     if (!documentLoader)
 906         documentLoader = frame()->loader().policyDocumentLoader();
 907
 908     return DataSourceForDocLoader(documentLoader);
 909 }
 910
 911 WebDataSource* WebLocalFrameImpl::dataSource() const
 912 {
 913     ASSERT(frame());
 914     return DataSourceForDocLoader(frame()->loader().documentLoader());
 915 }
 916
 917 void WebLocalFrameImpl::enableViewSourceMode(bool enable)
 918 {
 919     if (frame())
 920         frame()->setInViewSourceMode(enable);
 921 }
 922
 923 bool WebLocalFrameImpl::isViewSourceModeEnabled() const
 924 {
 925     if (!frame())
 926         return false;
 927     return frame()->inViewSourceMode();
 928 }
 929
 930 void WebLocalFrameImpl::setReferrerForRequest(WebURLRequest& request, const WebURL& referrerURL)
 931 {
 932     String referrer = referrerURL.isEmpty() ? frame()->document()->outgoingReferrer() : String(referrerURL.spec().utf16());
 933     referrer = SecurityPolicy::generateReferrerHeader(frame()->document()->referrerPolicy(), request.url(), referrer);
 934     if (referrer.isEmpty())
 935         return;
 936     request.setHTTPReferrer(referrer, static_cast<WebReferrerPolicy>(frame()->document()->referrerPolicy()));
 937 }
 938
 939 void WebLocalFrameImpl::dispatchWillSendRequest(WebURLRequest& request)
 940 {
 941     ResourceResponse response;
 942     frame()->loader().client()->dispatchWillSendRequest(0, 0, request.toMutableResourceRequest(), response);
 943 }
 944
 945 WebURLLoader* WebLocalFrameImpl::createAssociatedURLLoader(const WebURLLoaderOptions& options)
 946 {
 947     return new AssociatedURLLoader(this, options);
 948 }
 949
 950 unsigned WebLocalFrameImpl::unloadListenerCount() const
 951 {
 952     return frame()->domWindow()->pendingUnloadEventListeners();
 953 }
 954
 955 void WebLocalFrameImpl::replaceSelection(const WebString& text)
 956 {
 957     bool selectReplacement = false;
 958     bool smartReplace = true;
 959     frame()->editor().replaceSelectionWithText(text, selectReplacement, smartReplace);
 960 }
 961
 962 void WebLocalFrameImpl::insertText(const WebString& text)
 963 {
 964     if (frame()->inputMethodController().hasComposition())
 965         frame()->inputMethodController().confirmComposition(text);
 966     else
 967         frame()->editor().insertText(text, 0);
 968 }
 969
 970 void WebLocalFrameImpl::setMarkedText(const WebString& text, unsigned location, unsigned length)
 971 {
 972     Vector<CompositionUnderline> decorations;
 973     frame()->inputMethodController().setComposition(text, decorations, location, length);
 974 }
 975
 976 void WebLocalFrameImpl::unmarkText()
 977 {
 978     frame()->inputMethodController().cancelComposition();
 979 }
 980
 981 bool WebLocalFrameImpl::hasMarkedText() const
 982 {
 983     return frame()->inputMethodController().hasComposition();
 984 }
 985
 986 WebRange WebLocalFrameImpl::markedRange() const
 987 {
 988     return frame()->inputMethodController().compositionRange();
 989 }
 990
 991 bool WebLocalFrameImpl::firstRectForCharacterRange(unsigned location, unsigned length, WebRect& rect) const
 992 {
 993     if ((location + length < location) && (location + length))
 994         length = 0;
 995
 996     Element* editable = frame()->selection().rootEditableElementOrDocumentElement();
 997     ASSERT(editable);
 998     RefPtrWillBeRawPtr<Range> range = PlainTextRange(location, location + length).createRange(*editable);
 999     if (!range)
1000         return false;
1001     IntRect intRect = frame()->editor().firstRectForRange(range.get());
1002     rect = WebRect(intRect);
1003     rect = frame()->view()->contentsToWindow(rect);
1004     return true;
1005 }
1006
1007 size_t WebLocalFrameImpl::characterIndexForPoint(const WebPoint& webPoint) const
1008 {
1009     if (!frame())
1010         return kNotFound;
1011
1012     IntPoint point = frame()->view()->windowToContents(webPoint);
1013     HitTestResult result = frame()->eventHandler().hitTestResultAtPoint(point, HitTestRequest::ReadOnly | HitTestRequest::Active);
1014     RefPtrWillBeRawPtr<Range> range = frame()->rangeForPoint(result.roundedPointInInnerNodeFrame());
1015     if (!range)
1016         return kNotFound;
1017     Element* editable = frame()->selection().rootEditableElementOrDocumentElement();
1018     ASSERT(editable);
1019     return PlainTextRange::create(*editable, *range.get()).start();
1020 }
1021
1022 bool WebLocalFrameImpl::executeCommand(const WebString& name, const WebNode& node)
1023 {
1024     ASSERT(frame());
1025
1026     if (name.length() <= 2)
1027         return false;
1028
1029     // Since we don't have NSControl, we will convert the format of command
1030     // string and call the function on Editor directly.
1031     String command = name;
1032
1033     // Make sure the first letter is upper case.
1034     command.replace(0, 1, command.substring(0, 1).upper());
1035
1036     // Remove the trailing ':' if existing.
1037     if (command[command.length() - 1] == UChar(':'))
1038         command = command.substring(0, command.length() - 1);
1039
1040     WebPluginContainerImpl* pluginContainer = pluginContainerFromNode(frame(), node);
1041     if (pluginContainer && pluginContainer->executeEditCommand(name))
1042         return true;
1043
1044     return frame()->editor().executeCommand(command);
1045 }
1046
1047 bool WebLocalFrameImpl::executeCommand(const WebString& name, const WebString& value, const WebNode& node)
1048 {
1049     ASSERT(frame());
1050
1051     WebPluginContainerImpl* pluginContainer = pluginContainerFromNode(frame(), node);
1052     if (pluginContainer && pluginContainer->executeEditCommand(name, value))
1053         return true;
1054
1055     return frame()->editor().executeCommand(name, value);
1056 }
1057
1058 bool WebLocalFrameImpl::isCommandEnabled(const WebString& name) const
1059 {
1060     ASSERT(frame());
1061     return frame()->editor().command(name).isEnabled();
1062 }
1063
1064 void WebLocalFrameImpl::enableContinuousSpellChecking(bool enable)
1065 {
1066     if (enable == isContinuousSpellCheckingEnabled())
1067         return;
1068     frame()->spellChecker().toggleContinuousSpellChecking();
1069 }
1070
1071 bool WebLocalFrameImpl::isContinuousSpellCheckingEnabled() const
1072 {
1073     return frame()->spellChecker().isContinuousSpellCheckingEnabled();
1074 }
1075
1076 void WebLocalFrameImpl::requestTextChecking(const WebElement& webElement)
1077 {
1078     if (webElement.isNull())
1079         return;
1080     frame()->spellChecker().requestTextChecking(*webElement.constUnwrap<Element>());
1081 }
1082
1083 void WebLocalFrameImpl::replaceMisspelledRange(const WebString& text)
1084 {
1085     // If this caret selection has two or more markers, this function replace the range covered by the first marker with the specified word as Microsoft Word does.
1086     if (pluginContainerFromFrame(frame()))
1087         return;
1088     frame()->spellChecker().replaceMisspelledRange(text);
1089 }
1090
1091 void WebLocalFrameImpl::removeSpellingMarkers()
1092 {
1093     frame()->spellChecker().removeSpellingMarkers();
1094 }
1095
1096 bool WebLocalFrameImpl::hasSelection() const
1097 {
1098     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
1099     if (pluginContainer)
1100         return pluginContainer->plugin()->hasSelection();
1101
1102     // frame()->selection()->isNone() never returns true.
1103     return frame()->selection().start() != frame()->selection().end();
1104 }
1105
1106 WebRange WebLocalFrameImpl::selectionRange() const
1107 {
1108     return frame()->selection().toNormalizedRange();
1109 }
1110
1111 WebString WebLocalFrameImpl::selectionAsText() const
1112 {
1113     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
1114     if (pluginContainer)
1115         return pluginContainer->plugin()->selectionAsText();
1116
1117     RefPtrWillBeRawPtr<Range> range = frame()->selection().toNormalizedRange();
1118     if (!range)
1119         return WebString();
1120
1121     String text = range->text();
1122 #if OS(WIN)
1123     replaceNewlinesWithWindowsStyleNewlines(text);
1124 #endif
1125     replaceNBSPWithSpace(text);
1126     return text;
1127 }
1128
1129 WebString WebLocalFrameImpl::selectionAsMarkup() const
1130 {
1131     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
1132     if (pluginContainer)
1133         return pluginContainer->plugin()->selectionAsMarkup();
1134
1135     RefPtrWillBeRawPtr<Range> range = frame()->selection().toNormalizedRange();
1136     if (!range)
1137         return WebString();
1138
1139     return createMarkup(range.get(), 0, AnnotateForInterchange, false, ResolveNonLocalURLs);
1140 }
1141
1142 void WebLocalFrameImpl::selectWordAroundPosition(LocalFrame* frame, VisiblePosition position)
1143 {
1144     VisibleSelection selection(position);
1145     selection.expandUsingGranularity(WordGranularity);
1146
1147     TextGranularity granularity = selection.isRange() ? WordGranularity : CharacterGranularity;
1148     frame->selection().setSelection(selection, granularity);
1149 }
1150
1151 bool WebLocalFrameImpl::selectWordAroundCaret()
1152 {
1153     FrameSelection& selection = frame()->selection();
1154     if (selection.isNone() || selection.isRange())
1155         return false;
1156     selectWordAroundPosition(frame(), selection.selection().visibleStart());
1157     return true;
1158 }
1159
1160 void WebLocalFrameImpl::selectRange(const WebPoint& base, const WebPoint& extent)
1161 {
1162     moveRangeSelection(base, extent);
1163 }
1164
1165 void WebLocalFrameImpl::selectRange(const WebRange& webRange)
1166 {
1167     if (RefPtrWillBeRawPtr<Range> range = static_cast<PassRefPtrWillBeRawPtr<Range> >(webRange))
1168         frame()->selection().setSelectedRange(range.get(), VP_DEFAULT_AFFINITY, FrameSelection::NonDirectional, NotUserTriggered);
1169 }
1170
1171 void WebLocalFrameImpl::moveRangeSelection(const WebPoint& base, const WebPoint& extent)
1172 {
1173     VisiblePosition basePosition = visiblePositionForWindowPoint(base);
1174     VisiblePosition extentPosition = visiblePositionForWindowPoint(extent);
1175     VisibleSelection newSelection = VisibleSelection(basePosition, extentPosition);
1176     frame()->selection().setSelection(newSelection, CharacterGranularity);
1177 }
1178
1179 void WebLocalFrameImpl::moveCaretSelection(const WebPoint& point)
1180 {
1181     Element* editable = frame()->selection().rootEditableElement();
1182     if (!editable)
1183         return;
1184
1185     VisiblePosition position = visiblePositionForWindowPoint(point);
1186     frame()->selection().moveTo(position, UserTriggered);
1187 }
1188
1189 bool WebLocalFrameImpl::setEditableSelectionOffsets(int start, int end)
1190 {
1191     return frame()->inputMethodController().setEditableSelectionOffsets(PlainTextRange(start, end));
1192 }
1193
1194 bool WebLocalFrameImpl::setCompositionFromExistingText(int compositionStart, int compositionEnd, const WebVector<WebCompositionUnderline>& underlines)
1195 {
1196     if (!frame()->editor().canEdit())
1197         return false;
1198
1199     InputMethodController& inputMethodController = frame()->inputMethodController();
1200     inputMethodController.cancelComposition();
1201
1202     if (compositionStart == compositionEnd)
1203         return true;
1204
1205     inputMethodController.setCompositionFromExistingText(CompositionUnderlineVectorBuilder(underlines), compositionStart, compositionEnd);
1206
1207     return true;
1208 }
1209
1210 void WebLocalFrameImpl::extendSelectionAndDelete(int before, int after)
1211 {
1212     if (WebPlugin* plugin = focusedPluginIfInputMethodSupported()) {
1213         plugin->extendSelectionAndDelete(before, after);
1214         return;
1215     }
1216     frame()->inputMethodController().extendSelectionAndDelete(before, after);
1217 }
1218
1219 void WebLocalFrameImpl::setCaretVisible(bool visible)
1220 {
1221     frame()->selection().setCaretVisible(visible);
1222 }
1223
1224 VisiblePosition WebLocalFrameImpl::visiblePositionForWindowPoint(const WebPoint& point)
1225 {
1226     // FIXME(bokan): crbug.com/371902 - These scale/pinch transforms shouldn't
1227     // be ad hoc and explicit.
1228     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
1229     FloatPoint unscaledPoint(point);
1230     unscaledPoint.scale(1 / view()->pageScaleFactor(), 1 / view()->pageScaleFactor());
1231     unscaledPoint.moveBy(pinchViewport.visibleRect().location());
1232
1233     HitTestRequest request = HitTestRequest::Move | HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::IgnoreClipping;
1234     HitTestResult result(frame()->view()->windowToContents(roundedIntPoint(unscaledPoint)));
1235     frame()->document()->renderView()->layer()->hitTest(request, result);
1236
1237     if (Node* node = result.innerNode())
1238         return frame()->selection().selection().visiblePositionRespectingEditingBoundary(result.localPoint(), node);
1239     return VisiblePosition();
1240 }
1241
1242 WebPlugin* WebLocalFrameImpl::focusedPluginIfInputMethodSupported()
1243 {
1244     WebPluginContainerImpl* container = WebLocalFrameImpl::pluginContainerFromNode(frame(), WebNode(frame()->document()->focusedElement()));
1245     if (container && container->supportsInputMethod())
1246         return container->plugin();
1247     return 0;
1248 }
1249
1250 int WebLocalFrameImpl::printBegin(const WebPrintParams& printParams, const WebNode& constrainToNode)
1251 {
1252     ASSERT(!frame()->document()->isFrameSet());
1253     WebPluginContainerImpl* pluginContainer = 0;
1254     if (constrainToNode.isNull()) {
1255         // If this is a plugin document, check if the plugin supports its own
1256         // printing. If it does, we will delegate all printing to that.
1257         pluginContainer = pluginContainerFromFrame(frame());
1258     } else {
1259         // We only support printing plugin nodes for now.
1260         pluginContainer = toWebPluginContainerImpl(constrainToNode.pluginContainer());
1261     }
1262
1263     if (pluginContainer && pluginContainer->supportsPaginatedPrint())
1264         m_printContext = adoptPtrWillBeNoop(new ChromePluginPrintContext(frame(), pluginContainer, printParams));
1265     else
1266         m_printContext = adoptPtrWillBeNoop(new ChromePrintContext(frame()));
1267
1268     FloatRect rect(0, 0, static_cast<float>(printParams.printContentArea.width), static_cast<float>(printParams.printContentArea.height));
1269     m_printContext->begin(rect.width(), rect.height());
1270     float pageHeight;
1271     // We ignore the overlays calculation for now since they are generated in the
1272     // browser. pageHeight is actually an output parameter.
1273     m_printContext->computePageRects(rect, 0, 0, 1.0, pageHeight);
1274
1275     return static_cast<int>(m_printContext->pageCount());
1276 }
1277
1278 float WebLocalFrameImpl::getPrintPageShrink(int page)
1279 {
1280     ASSERT(m_printContext && page >= 0);
1281     return m_printContext->getPageShrink(page);
1282 }
1283
1284 float WebLocalFrameImpl::printPage(int page, WebCanvas* canvas)
1285 {
1286 #if ENABLE(PRINTING)
1287     ASSERT(m_printContext && page >= 0 && frame() && frame()->document());
1288
1289     GraphicsContext graphicsContext(canvas);
1290     graphicsContext.setPrinting(true);
1291     return m_printContext->spoolSinglePage(graphicsContext, page);
1292 #else
1293     return 0;
1294 #endif
1295 }
1296
1297 void WebLocalFrameImpl::printEnd()
1298 {
1299     ASSERT(m_printContext);
1300     m_printContext->end();
1301     m_printContext.clear();
1302 }
1303
1304 bool WebLocalFrameImpl::isPrintScalingDisabledForPlugin(const WebNode& node)
1305 {
1306     WebPluginContainerImpl* pluginContainer =  node.isNull() ? pluginContainerFromFrame(frame()) : toWebPluginContainerImpl(node.pluginContainer());
1307
1308     if (!pluginContainer || !pluginContainer->supportsPaginatedPrint())
1309         return false;
1310
1311     return pluginContainer->isPrintScalingDisabled();
1312 }
1313
1314 int WebLocalFrameImpl::getPrintCopiesForPlugin(const WebNode& node)
1315 {
1316     WebPluginContainerImpl* pluginContainer = node.isNull() ? pluginContainerFromFrame(frame()) : toWebPluginContainerImpl(node.pluginContainer());
1317
1318     if (!pluginContainer || !pluginContainer->supportsPaginatedPrint())
1319         return 1;
1320
1321     return pluginContainer->getCopiesToPrint();
1322 }
1323
1324 bool WebLocalFrameImpl::hasCustomPageSizeStyle(int pageIndex)
1325 {
1326     return frame()->document()->styleForPage(pageIndex)->pageSizeType() != PAGE_SIZE_AUTO;
1327 }
1328
1329 bool WebLocalFrameImpl::isPageBoxVisible(int pageIndex)
1330 {
1331     return frame()->document()->isPageBoxVisible(pageIndex);
1332 }
1333
1334 void WebLocalFrameImpl::pageSizeAndMarginsInPixels(int pageIndex, WebSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft)
1335 {
1336     IntSize size = pageSize;
1337     frame()->document()->pageSizeAndMarginsInPixels(pageIndex, size, marginTop, marginRight, marginBottom, marginLeft);
1338     pageSize = size;
1339 }
1340
1341 WebString WebLocalFrameImpl::pageProperty(const WebString& propertyName, int pageIndex)
1342 {
1343     ASSERT(m_printContext);
1344     return m_printContext->pageProperty(frame(), propertyName.utf8().data(), pageIndex);
1345 }
1346
1347 bool WebLocalFrameImpl::find(int identifier, const WebString& searchText, const WebFindOptions& options, bool wrapWithinFrame, WebRect* selectionRect)
1348 {
1349     return ensureTextFinder().find(identifier, searchText, options, wrapWithinFrame, selectionRect);
1350 }
1351
1352 void WebLocalFrameImpl::stopFinding(bool clearSelection)
1353 {
1354     if (m_textFinder) {
1355         if (!clearSelection)
1356             setFindEndstateFocusAndSelection();
1357         m_textFinder->stopFindingAndClearSelection();
1358     }
1359 }
1360
1361 void WebLocalFrameImpl::scopeStringMatches(int identifier, const WebString& searchText, const WebFindOptions& options, bool reset)
1362 {
1363     ensureTextFinder().scopeStringMatches(identifier, searchText, options, reset);
1364 }
1365
1366 void WebLocalFrameImpl::cancelPendingScopingEffort()
1367 {
1368     if (m_textFinder)
1369         m_textFinder->cancelPendingScopingEffort();
1370 }
1371
1372 void WebLocalFrameImpl::increaseMatchCount(int count, int identifier)
1373 {
1374     // This function should only be called on the mainframe.
1375     ASSERT(!parent());
1376     ensureTextFinder().increaseMatchCount(identifier, count);
1377 }
1378
1379 void WebLocalFrameImpl::resetMatchCount()
1380 {
1381     ensureTextFinder().resetMatchCount();
1382 }
1383
1384 void WebLocalFrameImpl::dispatchMessageEventWithOriginCheck(const WebSecurityOrigin& intendedTargetOrigin, const WebDOMEvent& event)
1385 {
1386     ASSERT(!event.isNull());
1387     frame()->domWindow()->dispatchMessageEventWithOriginCheck(intendedTargetOrigin.get(), event, nullptr);
1388 }
1389
1390 int WebLocalFrameImpl::findMatchMarkersVersion() const
1391 {
1392     ASSERT(!parent());
1393
1394     if (m_textFinder)
1395         return m_textFinder->findMatchMarkersVersion();
1396     return 0;
1397 }
1398
1399 int WebLocalFrameImpl::selectNearestFindMatch(const WebFloatPoint& point, WebRect* selectionRect)
1400 {
1401     ASSERT(!parent());
1402     return ensureTextFinder().selectNearestFindMatch(point, selectionRect);
1403 }
1404
1405 WebFloatRect WebLocalFrameImpl::activeFindMatchRect()
1406 {
1407     ASSERT(!parent());
1408
1409     if (m_textFinder)
1410         return m_textFinder->activeFindMatchRect();
1411     return WebFloatRect();
1412 }
1413
1414 void WebLocalFrameImpl::findMatchRects(WebVector<WebFloatRect>& outputRects)
1415 {
1416     ASSERT(!parent());
1417     ensureTextFinder().findMatchRects(outputRects);
1418 }
1419
1420 void WebLocalFrameImpl::setTickmarks(const WebVector<WebRect>& tickmarks)
1421 {
1422     if (frameView()) {
1423         Vector<IntRect> tickmarksConverted(tickmarks.size());
1424         for (size_t i = 0; i < tickmarks.size(); ++i)
1425             tickmarksConverted[i] = tickmarks[i];
1426         frameView()->setTickmarks(tickmarksConverted);
1427         invalidateScrollbar();
1428     }
1429 }
1430
1431 WebString WebLocalFrameImpl::contentAsText(size_t maxChars) const
1432 {
1433     if (!frame())
1434         return WebString();
1435     StringBuilder text;
1436     frameContentAsPlainText(maxChars, frame(), text);
1437     return text.toString();
1438 }
1439
1440 WebString WebLocalFrameImpl::contentAsMarkup() const
1441 {
1442     if (!frame())
1443         return WebString();
1444     return createMarkup(frame()->document());
1445 }
1446
1447 WebString WebLocalFrameImpl::renderTreeAsText(RenderAsTextControls toShow) const
1448 {
1449     RenderAsTextBehavior behavior = RenderAsTextBehaviorNormal;
1450
1451     if (toShow & RenderAsTextDebug)
1452         behavior |= RenderAsTextShowCompositedLayers | RenderAsTextShowAddresses | RenderAsTextShowIDAndClass | RenderAsTextShowLayerNesting;
1453
1454     if (toShow & RenderAsTextPrinting)
1455         behavior |= RenderAsTextPrintingMode;
1456
1457     return externalRepresentation(frame(), behavior);
1458 }
1459
1460 WebString WebLocalFrameImpl::markerTextForListItem(const WebElement& webElement) const
1461 {
1462     return blink::markerTextForListItem(const_cast<Element*>(webElement.constUnwrap<Element>()));
1463 }
1464
1465 void WebLocalFrameImpl::printPagesWithBoundaries(WebCanvas* canvas, const WebSize& pageSizeInPixels)
1466 {
1467     ASSERT(m_printContext);
1468
1469     GraphicsContext graphicsContext(canvas);
1470     graphicsContext.setPrinting(true);
1471
1472     m_printContext->spoolAllPagesWithBoundaries(graphicsContext, FloatSize(pageSizeInPixels.width, pageSizeInPixels.height));
1473 }
1474
1475 WebRect WebLocalFrameImpl::selectionBoundsRect() const
1476 {
1477     return hasSelection() ? WebRect(IntRect(frame()->selection().bounds())) : WebRect();
1478 }
1479
1480 bool WebLocalFrameImpl::selectionStartHasSpellingMarkerFor(int from, int length) const
1481 {
1482     if (!frame())
1483         return false;
1484     return frame()->spellChecker().selectionStartHasSpellingMarkerFor(from, length);
1485 }
1486
1487 WebString WebLocalFrameImpl::layerTreeAsText(bool showDebugInfo) const
1488 {
1489     if (!frame())
1490         return WebString();
1491
1492     return WebString(frame()->layerTreeAsText(showDebugInfo ? LayerTreeIncludesDebugInfo : LayerTreeNormal));
1493 }
1494
1495 // WebLocalFrameImpl public ---------------------------------------------------------
1496
1497 WebLocalFrame* WebLocalFrame::create(WebFrameClient* client)
1498 {
1499     return WebLocalFrameImpl::create(client);
1500 }
1501
1502 WebLocalFrameImpl* WebLocalFrameImpl::create(WebFrameClient* client)
1503 {
1504     WebLocalFrameImpl* frame = new WebLocalFrameImpl(client);
1505 #if ENABLE(OILPAN)
1506     return frame;
1507 #else
1508     return adoptRef(frame).leakRef();
1509 #endif
1510 }
1511
1512 WebLocalFrameImpl::WebLocalFrameImpl(WebFrameClient* client)
1513     : m_frameLoaderClientImpl(this)
1514     , m_client(client)
1515     , m_permissionClient(0)
1516     , m_inputEventsScaleFactorForEmulation(1)
1517     , m_userMediaClientImpl(this)
1518     , m_geolocationClientProxy(GeolocationClientProxy::create(client ? client->geolocationClient() : 0))
1519 #if ENABLE(OILPAN)
1520     , m_selfKeepAlive(this)
1521 #endif
1522 {
1523     Platform::current()->incrementStatsCounter(webFrameActiveCount);
1524     frameCount++;
1525 }
1526
1527 WebLocalFrameImpl::~WebLocalFrameImpl()
1528 {
1529     Platform::current()->decrementStatsCounter(webFrameActiveCount);
1530     frameCount--;
1531
1532     cancelPendingScopingEffort();
1533 }
1534
1535 void WebLocalFrameImpl::trace(Visitor* visitor)
1536 {
1537 #if ENABLE(OILPAN)
1538     visitor->trace(m_frame);
1539     visitor->trace(m_printContext);
1540     visitor->trace(m_geolocationClientProxy);
1541
1542     WebFrame::traceChildren(visitor, this);
1543 #endif
1544 }
1545
1546 void WebLocalFrameImpl::setCoreFrame(PassRefPtrWillBeRawPtr<LocalFrame> frame)
1547 {
1548     m_frame = frame;
1549
1550     // FIXME: we shouldn't add overhead to every frame by registering these objects when they're not used.
1551     if (m_frame) {
1552         OwnPtr<NotificationPresenterImpl> notificationPresenter = adoptPtr(new NotificationPresenterImpl());
1553         if (m_client)
1554             notificationPresenter->initialize(m_client->notificationPresenter());
1555
1556         provideNotification(*m_frame, notificationPresenter.release());
1557         provideNotificationPermissionClientTo(*m_frame, NotificationPermissionClientImpl::create());
1558         provideUserMediaTo(*m_frame, &m_userMediaClientImpl);
1559         provideGeolocationTo(*m_frame, m_geolocationClientProxy.get());
1560         m_geolocationClientProxy->setController(GeolocationController::from(m_frame.get()));
1561         provideMIDITo(*m_frame, MIDIClientProxy::create(m_client ? m_client->webMIDIClient() : 0));
1562         provideLocalFileSystemTo(*m_frame, LocalFileSystemClient::create());
1563
1564         if (RuntimeEnabledFeatures::screenOrientationEnabled())
1565             ScreenOrientationController::provideTo(*m_frame, m_client ? m_client->webScreenOrientationClient() : 0);
1566     }
1567 }
1568
1569 PassRefPtrWillBeRawPtr<LocalFrame> WebLocalFrameImpl::initializeCoreFrame(FrameHost* host, FrameOwner* owner, const AtomicString& name, const AtomicString& fallbackName)
1570 {
1571     RefPtrWillBeRawPtr<LocalFrame> frame = LocalFrame::create(&m_frameLoaderClientImpl, host, owner);
1572     setCoreFrame(frame);
1573     frame->tree().setName(name, fallbackName);
1574     // We must call init() after m_frame is assigned because it is referenced
1575     // during init(). Note that this may dispatch JS events; the frame may be
1576     // detached after init() returns.
1577     frame->init();
1578     return frame;
1579 }
1580
1581 PassRefPtrWillBeRawPtr<LocalFrame> WebLocalFrameImpl::createChildFrame(const FrameLoadRequest& request, HTMLFrameOwnerElement* ownerElement)
1582 {
1583     ASSERT(m_client);
1584     WebLocalFrameImpl* webframeChild = toWebLocalFrameImpl(m_client->createChildFrame(this, request.frameName()));
1585     if (!webframeChild)
1586         return nullptr;
1587
1588     // FIXME: Using subResourceAttributeName as fallback is not a perfect
1589     // solution. subResourceAttributeName returns just one attribute name. The
1590     // element might not have the attribute, and there might be other attributes
1591     // which can identify the element.
1592     RefPtrWillBeRawPtr<LocalFrame> child = webframeChild->initializeCoreFrame(frame()->host(), ownerElement, request.frameName(), ownerElement->getAttribute(ownerElement->subResourceAttributeName()));
1593     // Initializing the core frame may cause the new child to be detached, since
1594     // it may dispatch a load event in the parent.
1595     if (!child->tree().parent())
1596         return nullptr;
1597
1598     // If we're moving in the back/forward list, we might want to replace the content
1599     // of this child frame with whatever was there at that point.
1600     RefPtr<HistoryItem> childItem;
1601     if (isBackForwardLoadType(frame()->loader().loadType()) && !frame()->document()->loadEventFinished())
1602         childItem = PassRefPtr<HistoryItem>(webframeChild->client()->historyItemForNewChildFrame(webframeChild));
1603
1604     if (childItem)
1605         child->loader().loadHistoryItem(childItem.get());
1606     else
1607         child->loader().load(FrameLoadRequest(0, request.resourceRequest(), "_self"));
1608
1609     // Note a synchronous navigation (about:blank) would have already processed
1610     // onload, so it is possible for the child frame to have already been
1611     // detached by script in the page.
1612     if (!child->tree().parent())
1613         return nullptr;
1614     return child;
1615 }
1616
1617 void WebLocalFrameImpl::didChangeContentsSize(const IntSize& size)
1618 {
1619     // This is only possible on the main frame.
1620     if (m_textFinder && m_textFinder->totalMatchCount() > 0) {
1621         ASSERT(!parent());
1622         m_textFinder->increaseMarkerVersion();
1623     }
1624 }
1625
1626 void WebLocalFrameImpl::createFrameView()
1627 {
1628     TRACE_EVENT0("blink", "WebLocalFrameImpl::createFrameView");
1629
1630     ASSERT(frame()); // If frame() doesn't exist, we probably didn't init properly.
1631
1632     WebViewImpl* webView = viewImpl();
1633     bool isLocalRoot = frame()->isLocalRoot();
1634     if (isLocalRoot)
1635         webView->suppressInvalidations(true);
1636
1637     frame()->createView(webView->size(), webView->baseBackgroundColor(), webView->isTransparent());
1638     if (webView->shouldAutoResize() && isLocalRoot)
1639         frame()->view()->enableAutoSizeMode(webView->minAutoSize(), webView->maxAutoSize());
1640
1641     frame()->view()->setInputEventsTransformForEmulation(m_inputEventsOffsetForEmulation, m_inputEventsScaleFactorForEmulation);
1642
1643     if (isLocalRoot)
1644         webView->suppressInvalidations(false);
1645 }
1646
1647 WebLocalFrameImpl* WebLocalFrameImpl::fromFrame(LocalFrame* frame)
1648 {
1649     if (!frame)
1650         return 0;
1651     return fromFrame(*frame);
1652 }
1653
1654 WebLocalFrameImpl* WebLocalFrameImpl::fromFrame(LocalFrame& frame)
1655 {
1656     FrameLoaderClient* client = frame.loader().client();
1657     if (!client || !client->isFrameLoaderClientImpl())
1658         return 0;
1659     return toFrameLoaderClientImpl(client)->webFrame();
1660 }
1661
1662 WebLocalFrameImpl* WebLocalFrameImpl::fromFrameOwnerElement(Element* element)
1663 {
1664     // FIXME: Why do we check specifically for <iframe> and <frame> here? Why can't we get the WebLocalFrameImpl from an <object> element, for example.
1665     if (!isHTMLFrameElementBase(element))
1666         return 0;
1667     return fromFrame(toLocalFrame(toHTMLFrameElementBase(element)->contentFrame()));
1668 }
1669
1670 WebViewImpl* WebLocalFrameImpl::viewImpl() const
1671 {
1672     if (!frame())
1673         return 0;
1674     return WebViewImpl::fromPage(frame()->page());
1675 }
1676
1677 WebDataSourceImpl* WebLocalFrameImpl::dataSourceImpl() const
1678 {
1679     return static_cast<WebDataSourceImpl*>(dataSource());
1680 }
1681
1682 WebDataSourceImpl* WebLocalFrameImpl::provisionalDataSourceImpl() const
1683 {
1684     return static_cast<WebDataSourceImpl*>(provisionalDataSource());
1685 }
1686
1687 void WebLocalFrameImpl::setFindEndstateFocusAndSelection()
1688 {
1689     WebLocalFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl();
1690
1691     if (this != mainFrameImpl->activeMatchFrame())
1692         return;
1693
1694     if (Range* activeMatch = m_textFinder->activeMatch()) {
1695         // If the user has set the selection since the match was found, we
1696         // don't focus anything.
1697         VisibleSelection selection(frame()->selection().selection());
1698         if (!selection.isNone())
1699             return;
1700
1701         // Need to clean out style and layout state before querying Element::isFocusable().
1702         frame()->document()->updateLayoutIgnorePendingStylesheets();
1703
1704         // Try to find the first focusable node up the chain, which will, for
1705         // example, focus links if we have found text within the link.
1706         Node* node = activeMatch->firstNode();
1707         if (node && node->isInShadowTree()) {
1708             if (Node* host = node->shadowHost()) {
1709                 if (isHTMLInputElement(*host) || isHTMLTextAreaElement(*host))
1710                     node = host;
1711             }
1712         }
1713         for (; node; node = node->parentNode()) {
1714             if (!node->isElementNode())
1715                 continue;
1716             Element* element = toElement(node);
1717             if (element->isFocusable()) {
1718                 // Found a focusable parent node. Set the active match as the
1719                 // selection and focus to the focusable node.
1720                 frame()->selection().setSelection(VisibleSelection(activeMatch));
1721                 frame()->document()->setFocusedElement(element);
1722                 return;
1723             }
1724         }
1725
1726         // Iterate over all the nodes in the range until we find a focusable node.
1727         // This, for example, sets focus to the first link if you search for
1728         // text and text that is within one or more links.
1729         node = activeMatch->firstNode();
1730         for (; node && node != activeMatch->pastLastNode(); node = NodeTraversal::next(*node)) {
1731             if (!node->isElementNode())
1732                 continue;
1733             Element* element = toElement(node);
1734             if (element->isFocusable()) {
1735                 frame()->document()->setFocusedElement(element);
1736                 return;
1737             }
1738         }
1739
1740         // No node related to the active match was focusable, so set the
1741         // active match as the selection (so that when you end the Find session,
1742         // you'll have the last thing you found highlighted) and make sure that
1743         // we have nothing focused (otherwise you might have text selected but
1744         // a link focused, which is weird).
1745         frame()->selection().setSelection(VisibleSelection(activeMatch));
1746         frame()->document()->setFocusedElement(nullptr);
1747
1748         // Finally clear the active match, for two reasons:
1749         // We just finished the find 'session' and we don't want future (potentially
1750         // unrelated) find 'sessions' operations to start at the same place.
1751         // The WebLocalFrameImpl could get reused and the activeMatch could end up pointing
1752         // to a document that is no longer valid. Keeping an invalid reference around
1753         // is just asking for trouble.
1754         m_textFinder->resetActiveMatch();
1755     }
1756 }
1757
1758 void WebLocalFrameImpl::didFail(const ResourceError& error, bool wasProvisional)
1759 {
1760     if (!client())
1761         return;
1762     WebURLError webError = error;
1763     if (wasProvisional)
1764         client()->didFailProvisionalLoad(this, webError);
1765     else
1766         client()->didFailLoad(this, webError);
1767 }
1768
1769 void WebLocalFrameImpl::setCanHaveScrollbars(bool canHaveScrollbars)
1770 {
1771     frame()->view()->setCanHaveScrollbars(canHaveScrollbars);
1772 }
1773
1774 void WebLocalFrameImpl::setInputEventsTransformForEmulation(const IntSize& offset, float contentScaleFactor)
1775 {
1776     m_inputEventsOffsetForEmulation = offset;
1777     m_inputEventsScaleFactorForEmulation = contentScaleFactor;
1778     if (frame()->view())
1779         frame()->view()->setInputEventsTransformForEmulation(m_inputEventsOffsetForEmulation, m_inputEventsScaleFactorForEmulation);
1780 }
1781
1782 void WebLocalFrameImpl::loadJavaScriptURL(const KURL& url)
1783 {
1784     // This is copied from ScriptController::executeScriptIfJavaScriptURL.
1785     // Unfortunately, we cannot just use that method since it is private, and
1786     // it also doesn't quite behave as we require it to for bookmarklets. The
1787     // key difference is that we need to suppress loading the string result
1788     // from evaluating the JS URL if executing the JS URL resulted in a
1789     // location change. We also allow a JS URL to be loaded even if scripts on
1790     // the page are otherwise disabled.
1791
1792     if (!frame()->document() || !frame()->page())
1793         return;
1794
1795     RefPtrWillBeRawPtr<Document> ownerDocument(frame()->document());
1796
1797     // Protect privileged pages against bookmarklets and other javascript manipulations.
1798     if (SchemeRegistry::shouldTreatURLSchemeAsNotAllowingJavascriptURLs(frame()->document()->url().protocol()))
1799         return;
1800
1801     String script = decodeURLEscapeSequences(url.string().substring(strlen("javascript:")));
1802     UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
1803     v8::HandleScope handleScope(toIsolate(frame()));
1804     v8::Local<v8::Value> result = frame()->script().executeScriptInMainWorldAndReturnValue(ScriptSourceCode(script));
1805     if (result.IsEmpty() || !result->IsString())
1806         return;
1807     String scriptResult = toCoreString(v8::Handle<v8::String>::Cast(result));
1808     if (!frame()->navigationScheduler().locationChangePending())
1809         frame()->loader().replaceDocumentWhileExecutingJavaScriptURL(scriptResult, ownerDocument.get());
1810 }
1811
1812 void WebLocalFrameImpl::sendPings(const WebNode& linkNode, const WebURL& destinationURL)
1813 {
1814     ASSERT(frame());
1815     const Node* node = linkNode.constUnwrap<Node>();
1816     if (isHTMLAnchorElement(node))
1817         toHTMLAnchorElement(node)->sendPings(destinationURL);
1818 }
1819
1820 bool WebLocalFrameImpl::isLoading() const
1821 {
1822     if (!frame() || !frame()->document())
1823         return false;
1824     return frame()->loader().stateMachine()->isDisplayingInitialEmptyDocument() || !frame()->document()->loadEventFinished();
1825 }
1826
1827 bool WebLocalFrameImpl::isResourceLoadInProgress() const
1828 {
1829     if (!frame() || !frame()->document())
1830         return false;
1831     return frame()->document()->fetcher()->requestCount();
1832 }
1833
1834 void WebLocalFrameImpl::addStyleSheetByURL(const WebString& url)
1835 {
1836     RefPtrWillBeRawPtr<Element> styleElement = frame()->document()->createElement(HTMLNames::linkTag, false);
1837
1838     styleElement->setAttribute(HTMLNames::typeAttr, "text/css");
1839     styleElement->setAttribute(HTMLNames::relAttr, "stylesheet");
1840     styleElement->setAttribute(HTMLNames::hrefAttr, url);
1841
1842     frame()->document()->head()->appendChild(styleElement.release(), IGNORE_EXCEPTION);
1843 }
1844
1845 void WebLocalFrameImpl::navigateToSandboxedMarkup(const WebData& markup)
1846 {
1847     ASSERT(document().securityOrigin().isUnique());
1848     frame()->loader().forceSandboxFlags(SandboxAll);
1849     loadHTMLString(markup, document().url(), WebURL(), true);
1850 }
1851
1852 void WebLocalFrameImpl::sendOrientationChangeEvent()
1853 {
1854     if (!frame())
1855         return;
1856
1857     // Screen Orientation API
1858     if (ScreenOrientationController::from(*frame()))
1859         ScreenOrientationController::from(*frame())->notifyOrientationChanged();
1860
1861     // Legacy window.orientation API.
1862     if (RuntimeEnabledFeatures::orientationEventEnabled() && frame()->domWindow())
1863         frame()->domWindow()->dispatchEvent(Event::create(EventTypeNames::orientationchange));
1864 }
1865
1866 v8::Handle<v8::Value> WebLocalFrameImpl::executeScriptAndReturnValueForTests(const WebScriptSource& source)
1867 {
1868     // FIXME: This fake UserGestureIndicator is required for a bunch of browser
1869     // tests to pass. We should update the tests to simulate input and get rid
1870     // of this.
1871     // http://code.google.com/p/chromium/issues/detail?id=86397
1872     UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
1873     return executeScriptAndReturnValue(source);
1874 }
1875
1876 void WebLocalFrameImpl::willDetachParent()
1877 {
1878     // Do not expect string scoping results from any frames that got detached
1879     // in the middle of the operation.
1880     if (m_textFinder && m_textFinder->scopingInProgress()) {
1881
1882         // There is a possibility that the frame being detached was the only
1883         // pending one. We need to make sure final replies can be sent.
1884         m_textFinder->flushCurrentScoping();
1885
1886         m_textFinder->cancelPendingScopingEffort();
1887     }
1888 }
1889
1890 WebLocalFrameImpl* WebLocalFrameImpl::activeMatchFrame() const
1891 {
1892     ASSERT(!parent());
1893
1894     if (m_textFinder)
1895         return m_textFinder->activeMatchFrame();
1896     return 0;
1897 }
1898
1899 Range* WebLocalFrameImpl::activeMatch() const
1900 {
1901     if (m_textFinder)
1902         return m_textFinder->activeMatch();
1903     return 0;
1904 }
1905
1906 TextFinder& WebLocalFrameImpl::ensureTextFinder()
1907 {
1908     if (!m_textFinder)
1909         m_textFinder = TextFinder::create(*this);
1910
1911     return *m_textFinder;
1912 }
1913
1914 void WebLocalFrameImpl::invalidateScrollbar() const
1915 {
1916     ASSERT(frame() && frame()->view());
1917     FrameView* view = frame()->view();
1918     // Invalidate the vertical scroll bar region for the view.
1919     Scrollbar* scrollbar = view->verticalScrollbar();
1920     if (scrollbar)
1921         scrollbar->invalidate();
1922 }
1923
1924 void WebLocalFrameImpl::invalidateAll() const
1925 {
1926     ASSERT(frame() && frame()->view());
1927     FrameView* view = frame()->view();
1928     view->invalidateRect(view->frameRect());
1929     invalidateScrollbar();
1930 }
1931
1932 } // namespace blink