third_party/WebKit/Source/web/WebRemoteFrameImpl.cpp

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "config.h"
   6 #include "web/WebRemoteFrameImpl.h"
   7
   8 #include "core/frame/FrameView.h"
   9 #include "core/frame/RemoteFrame.h"
  10 #include "core/frame/Settings.h"
  11 #include "core/page/Page.h"
  12 #include "platform/heap/Handle.h"
  13 #include "public/platform/WebFloatRect.h"
  14 #include "public/platform/WebRect.h"
  15 #include "public/web/WebDocument.h"
  16 #include "public/web/WebPerformance.h"
  17 #include "public/web/WebRange.h"
  18 #include "public/web/WebTreeScopeType.h"
  19 #include "web/RemoteBridgeFrameOwner.h"
  20 #include "web/WebViewImpl.h"
  21 #include <v8/include/v8.h>
  22
  23 namespace blink {
  24
  25 WebRemoteFrame* WebRemoteFrame::create(WebTreeScopeType scope, WebRemoteFrameClient* client)
  26 {
  27     return WebRemoteFrameImpl::create(scope, client);
  28 }
  29
  30 WebRemoteFrame* WebRemoteFrameImpl::create(WebTreeScopeType scope, WebRemoteFrameClient* client)
  31 {
  32     WebRemoteFrameImpl* frame = new WebRemoteFrameImpl(scope, client);
  33 #if ENABLE(OILPAN)
  34     return frame;
  35 #else
  36     return adoptRef(frame).leakRef();
  37 #endif
  38 }
  39
  40 WebRemoteFrameImpl::~WebRemoteFrameImpl()
  41 {
  42 }
  43
  44 #if ENABLE(OILPAN)
  45 DEFINE_TRACE(WebRemoteFrameImpl)
  46 {
  47     visitor->trace(m_frameClient);
  48     visitor->trace(m_frame);
  49     visitor->trace(m_ownersForChildren);
  50     visitor->template registerWeakMembers<WebFrame, &WebFrame::clearWeakFrames>(this);
  51     WebFrame::traceFrames(visitor, this);
  52 }
  53 #endif
  54
  55 bool WebRemoteFrameImpl::isWebLocalFrame() const
  56 {
  57     return false;
  58 }
  59
  60 WebLocalFrame* WebRemoteFrameImpl::toWebLocalFrame()
  61 {
  62     ASSERT_NOT_REACHED();
  63     return nullptr;
  64 }
  65
  66 bool WebRemoteFrameImpl::isWebRemoteFrame() const
  67 {
  68     return true;
  69 }
  70
  71 WebRemoteFrame* WebRemoteFrameImpl::toWebRemoteFrame()
  72 {
  73     return this;
  74 }
  75
  76 void WebRemoteFrameImpl::close()
  77 {
  78 #if ENABLE(OILPAN)
  79     m_selfKeepAlive.clear();
  80 #else
  81     deref();
  82 #endif
  83 }
  84
  85 WebString WebRemoteFrameImpl::uniqueName() const
  86 {
  87     ASSERT_NOT_REACHED();
  88     return WebString();
  89 }
  90
  91 WebString WebRemoteFrameImpl::assignedName() const
  92 {
  93     ASSERT_NOT_REACHED();
  94     return WebString();
  95 }
  96
  97 void WebRemoteFrameImpl::setName(const WebString&)
  98 {
  99     ASSERT_NOT_REACHED();
 100 }
 101
 102 WebVector<WebIconURL> WebRemoteFrameImpl::iconURLs(int iconTypesMask) const
 103 {
 104     ASSERT_NOT_REACHED();
 105     return WebVector<WebIconURL>();
 106 }
 107
 108 void WebRemoteFrameImpl::setRemoteWebLayer(WebLayer* webLayer)
 109 {
 110     if (!frame())
 111         return;
 112
 113     frame()->setRemotePlatformLayer(webLayer);
 114 }
 115
 116 void WebRemoteFrameImpl::setSharedWorkerRepositoryClient(WebSharedWorkerRepositoryClient*)
 117 {
 118     ASSERT_NOT_REACHED();
 119 }
 120
 121 void WebRemoteFrameImpl::setCanHaveScrollbars(bool)
 122 {
 123     ASSERT_NOT_REACHED();
 124 }
 125
 126 WebSize WebRemoteFrameImpl::scrollOffset() const
 127 {
 128     ASSERT_NOT_REACHED();
 129     return WebSize();
 130 }
 131
 132 void WebRemoteFrameImpl::setScrollOffset(const WebSize&)
 133 {
 134     ASSERT_NOT_REACHED();
 135 }
 136
 137 WebSize WebRemoteFrameImpl::contentsSize() const
 138 {
 139     ASSERT_NOT_REACHED();
 140     return WebSize();
 141 }
 142
 143 bool WebRemoteFrameImpl::hasVisibleContent() const
 144 {
 145     ASSERT_NOT_REACHED();
 146     return false;
 147 }
 148
 149 WebRect WebRemoteFrameImpl::visibleContentRect() const
 150 {
 151     ASSERT_NOT_REACHED();
 152     return WebRect();
 153 }
 154
 155 bool WebRemoteFrameImpl::hasHorizontalScrollbar() const
 156 {
 157     ASSERT_NOT_REACHED();
 158     return false;
 159 }
 160
 161 bool WebRemoteFrameImpl::hasVerticalScrollbar() const
 162 {
 163     ASSERT_NOT_REACHED();
 164     return false;
 165 }
 166
 167 WebView* WebRemoteFrameImpl::view() const
 168 {
 169     if (!frame())
 170         return nullptr;
 171     return WebViewImpl::fromPage(frame()->page());
 172 }
 173
 174 void WebRemoteFrameImpl::removeChild(WebFrame* frame)
 175 {
 176     WebFrame::removeChild(frame);
 177     m_ownersForChildren.remove(frame);
 178 }
 179
 180 WebDocument WebRemoteFrameImpl::document() const
 181 {
 182     // TODO(dcheng): this should also ASSERT_NOT_REACHED, but a lot of
 183     // code tries to access the document of a remote frame at the moment.
 184     return WebDocument();
 185 }
 186
 187 WebPerformance WebRemoteFrameImpl::performance() const
 188 {
 189     ASSERT_NOT_REACHED();
 190     return WebPerformance();
 191 }
 192
 193 bool WebRemoteFrameImpl::dispatchBeforeUnloadEvent()
 194 {
 195     ASSERT_NOT_REACHED();
 196     return false;
 197 }
 198
 199 void WebRemoteFrameImpl::dispatchUnloadEvent()
 200 {
 201     ASSERT_NOT_REACHED();
 202 }
 203
 204 NPObject* WebRemoteFrameImpl::windowObject() const
 205 {
 206     ASSERT_NOT_REACHED();
 207     return nullptr;
 208 }
 209
 210 void WebRemoteFrameImpl::bindToWindowObject(const WebString& name, NPObject*)
 211 {
 212     ASSERT_NOT_REACHED();
 213 }
 214
 215 void WebRemoteFrameImpl::bindToWindowObject(const WebString& name, NPObject*, void*)
 216 {
 217     ASSERT_NOT_REACHED();
 218 }
 219
 220 void WebRemoteFrameImpl::executeScript(const WebScriptSource&)
 221 {
 222     ASSERT_NOT_REACHED();
 223 }
 224
 225 void WebRemoteFrameImpl::executeScriptInIsolatedWorld(
 226     int worldID, const WebScriptSource* sources, unsigned numSources,
 227     int extensionGroup)
 228 {
 229     ASSERT_NOT_REACHED();
 230 }
 231
 232 void WebRemoteFrameImpl::setIsolatedWorldSecurityOrigin(int worldID, const WebSecurityOrigin&)
 233 {
 234     ASSERT_NOT_REACHED();
 235 }
 236
 237 void WebRemoteFrameImpl::setIsolatedWorldContentSecurityPolicy(int worldID, const WebString&)
 238 {
 239     ASSERT_NOT_REACHED();
 240 }
 241
 242 void WebRemoteFrameImpl::addMessageToConsole(const WebConsoleMessage&)
 243 {
 244     ASSERT_NOT_REACHED();
 245 }
 246
 247 void WebRemoteFrameImpl::collectGarbage()
 248 {
 249     ASSERT_NOT_REACHED();
 250 }
 251
 252 bool WebRemoteFrameImpl::checkIfRunInsecureContent(const WebURL&) const
 253 {
 254     ASSERT_NOT_REACHED();
 255     return false;
 256 }
 257
 258 v8::Local<v8::Value> WebRemoteFrameImpl::executeScriptAndReturnValue(
 259     const WebScriptSource&)
 260 {
 261     ASSERT_NOT_REACHED();
 262     return v8::Local<v8::Value>();
 263 }
 264
 265 void WebRemoteFrameImpl::executeScriptInIsolatedWorld(
 266     int worldID, const WebScriptSource* sourcesIn, unsigned numSources,
 267     int extensionGroup, WebVector<v8::Local<v8::Value>>* results)
 268 {
 269     ASSERT_NOT_REACHED();
 270 }
 271
 272 v8::Local<v8::Value> WebRemoteFrameImpl::callFunctionEvenIfScriptDisabled(
 273     v8::Local<v8::Function>,
 274     v8::Local<v8::Value>,
 275     int argc,
 276     v8::Local<v8::Value> argv[])
 277 {
 278     ASSERT_NOT_REACHED();
 279     return v8::Local<v8::Value>();
 280 }
 281
 282 v8::Local<v8::Context> WebRemoteFrameImpl::mainWorldScriptContext() const
 283 {
 284     ASSERT_NOT_REACHED();
 285     return v8::Local<v8::Context>();
 286 }
 287
 288 v8::Local<v8::Context> WebRemoteFrameImpl::deprecatedMainWorldScriptContext() const
 289 {
 290     return toV8Context(frame(), DOMWrapperWorld::mainWorld());
 291 }
 292
 293 void WebRemoteFrameImpl::reload(bool ignoreCache)
 294 {
 295     ASSERT_NOT_REACHED();
 296 }
 297
 298 void WebRemoteFrameImpl::reloadWithOverrideURL(const WebURL& overrideUrl, bool ignoreCache)
 299 {
 300     ASSERT_NOT_REACHED();
 301 }
 302
 303 void WebRemoteFrameImpl::loadRequest(const WebURLRequest&)
 304 {
 305     ASSERT_NOT_REACHED();
 306 }
 307
 308 void WebRemoteFrameImpl::loadHistoryItem(const WebHistoryItem&, WebHistoryLoadType, WebURLRequest::CachePolicy)
 309 {
 310     ASSERT_NOT_REACHED();
 311 }
 312
 313 void WebRemoteFrameImpl::loadData(
 314     const WebData&, const WebString& mimeType, const WebString& textEncoding,
 315     const WebURL& baseURL, const WebURL& unreachableURL, bool replace)
 316 {
 317     ASSERT_NOT_REACHED();
 318 }
 319
 320 void WebRemoteFrameImpl::loadHTMLString(
 321     const WebData& html, const WebURL& baseURL, const WebURL& unreachableURL,
 322     bool replace)
 323 {
 324     ASSERT_NOT_REACHED();
 325 }
 326
 327 void WebRemoteFrameImpl::stopLoading()
 328 {
 329     // TODO(dcheng,japhet): Calling this method should stop loads
 330     // in all subframes, both remote and local.
 331 }
 332
 333 WebDataSource* WebRemoteFrameImpl::provisionalDataSource() const
 334 {
 335     ASSERT_NOT_REACHED();
 336     return nullptr;
 337 }
 338
 339 WebDataSource* WebRemoteFrameImpl::dataSource() const
 340 {
 341     ASSERT_NOT_REACHED();
 342     return nullptr;
 343 }
 344
 345 void WebRemoteFrameImpl::enableViewSourceMode(bool enable)
 346 {
 347     ASSERT_NOT_REACHED();
 348 }
 349
 350 bool WebRemoteFrameImpl::isViewSourceModeEnabled() const
 351 {
 352     ASSERT_NOT_REACHED();
 353     return false;
 354 }
 355
 356 void WebRemoteFrameImpl::setReferrerForRequest(WebURLRequest&, const WebURL& referrer)
 357 {
 358     ASSERT_NOT_REACHED();
 359 }
 360
 361 void WebRemoteFrameImpl::dispatchWillSendRequest(WebURLRequest&)
 362 {
 363     ASSERT_NOT_REACHED();
 364 }
 365
 366 WebURLLoader* WebRemoteFrameImpl::createAssociatedURLLoader(const WebURLLoaderOptions&)
 367 {
 368     ASSERT_NOT_REACHED();
 369     return nullptr;
 370 }
 371
 372 unsigned WebRemoteFrameImpl::unloadListenerCount() const
 373 {
 374     ASSERT_NOT_REACHED();
 375     return 0;
 376 }
 377
 378 void WebRemoteFrameImpl::replaceSelection(const WebString&)
 379 {
 380     ASSERT_NOT_REACHED();
 381 }
 382
 383 void WebRemoteFrameImpl::insertText(const WebString&)
 384 {
 385     ASSERT_NOT_REACHED();
 386 }
 387
 388 void WebRemoteFrameImpl::setMarkedText(const WebString&, unsigned location, unsigned length)
 389 {
 390     ASSERT_NOT_REACHED();
 391 }
 392
 393 void WebRemoteFrameImpl::unmarkText()
 394 {
 395     ASSERT_NOT_REACHED();
 396 }
 397
 398 bool WebRemoteFrameImpl::hasMarkedText() const
 399 {
 400     ASSERT_NOT_REACHED();
 401     return false;
 402 }
 403
 404 WebRange WebRemoteFrameImpl::markedRange() const
 405 {
 406     ASSERT_NOT_REACHED();
 407     return WebRange();
 408 }
 409
 410 bool WebRemoteFrameImpl::firstRectForCharacterRange(unsigned location, unsigned length, WebRect&) const
 411 {
 412     ASSERT_NOT_REACHED();
 413     return false;
 414 }
 415
 416 size_t WebRemoteFrameImpl::characterIndexForPoint(const WebPoint&) const
 417 {
 418     ASSERT_NOT_REACHED();
 419     return 0;
 420 }
 421
 422 bool WebRemoteFrameImpl::executeCommand(const WebString&, const WebNode&)
 423 {
 424     ASSERT_NOT_REACHED();
 425     return false;
 426 }
 427
 428 bool WebRemoteFrameImpl::executeCommand(const WebString&, const WebString& value, const WebNode&)
 429 {
 430     ASSERT_NOT_REACHED();
 431     return false;
 432 }
 433
 434 bool WebRemoteFrameImpl::isCommandEnabled(const WebString&) const
 435 {
 436     ASSERT_NOT_REACHED();
 437     return false;
 438 }
 439
 440 void WebRemoteFrameImpl::enableContinuousSpellChecking(bool)
 441 {
 442 }
 443
 444 bool WebRemoteFrameImpl::isContinuousSpellCheckingEnabled() const
 445 {
 446     return false;
 447 }
 448
 449 void WebRemoteFrameImpl::requestTextChecking(const WebElement&)
 450 {
 451     ASSERT_NOT_REACHED();
 452 }
 453
 454 void WebRemoteFrameImpl::replaceMisspelledRange(const WebString&)
 455 {
 456     ASSERT_NOT_REACHED();
 457 }
 458
 459 void WebRemoteFrameImpl::removeSpellingMarkers()
 460 {
 461     ASSERT_NOT_REACHED();
 462 }
 463
 464 bool WebRemoteFrameImpl::hasSelection() const
 465 {
 466     ASSERT_NOT_REACHED();
 467     return false;
 468 }
 469
 470 WebRange WebRemoteFrameImpl::selectionRange() const
 471 {
 472     ASSERT_NOT_REACHED();
 473     return WebRange();
 474 }
 475
 476 WebString WebRemoteFrameImpl::selectionAsText() const
 477 {
 478     ASSERT_NOT_REACHED();
 479     return WebString();
 480 }
 481
 482 WebString WebRemoteFrameImpl::selectionAsMarkup() const
 483 {
 484     ASSERT_NOT_REACHED();
 485     return WebString();
 486 }
 487
 488 bool WebRemoteFrameImpl::selectWordAroundCaret()
 489 {
 490     ASSERT_NOT_REACHED();
 491     return false;
 492 }
 493
 494 void WebRemoteFrameImpl::selectRange(const WebPoint& base, const WebPoint& extent)
 495 {
 496     ASSERT_NOT_REACHED();
 497 }
 498
 499 void WebRemoteFrameImpl::selectRange(const WebRange&)
 500 {
 501     ASSERT_NOT_REACHED();
 502 }
 503
 504 void WebRemoteFrameImpl::moveRangeSelection(const WebPoint& base, const WebPoint& extent, WebFrame::TextGranularity granularity)
 505 {
 506     ASSERT_NOT_REACHED();
 507 }
 508
 509 void WebRemoteFrameImpl::moveCaretSelection(const WebPoint&)
 510 {
 511     ASSERT_NOT_REACHED();
 512 }
 513
 514 bool WebRemoteFrameImpl::setEditableSelectionOffsets(int start, int end)
 515 {
 516     ASSERT_NOT_REACHED();
 517     return false;
 518 }
 519
 520 bool WebRemoteFrameImpl::setCompositionFromExistingText(int compositionStart, int compositionEnd, const WebVector<WebCompositionUnderline>& underlines)
 521 {
 522     ASSERT_NOT_REACHED();
 523     return false;
 524 }
 525
 526 void WebRemoteFrameImpl::extendSelectionAndDelete(int before, int after)
 527 {
 528     ASSERT_NOT_REACHED();
 529 }
 530
 531 void WebRemoteFrameImpl::setCaretVisible(bool)
 532 {
 533     ASSERT_NOT_REACHED();
 534 }
 535
 536 int WebRemoteFrameImpl::printBegin(const WebPrintParams&, const WebNode& constrainToNode)
 537 {
 538     ASSERT_NOT_REACHED();
 539     return 0;
 540 }
 541
 542 float WebRemoteFrameImpl::printPage(int pageToPrint, WebCanvas*)
 543 {
 544     ASSERT_NOT_REACHED();
 545     return 0.0;
 546 }
 547
 548 float WebRemoteFrameImpl::getPrintPageShrink(int page)
 549 {
 550     ASSERT_NOT_REACHED();
 551     return 0.0;
 552 }
 553
 554 void WebRemoteFrameImpl::printEnd()
 555 {
 556     ASSERT_NOT_REACHED();
 557 }
 558
 559 bool WebRemoteFrameImpl::isPrintScalingDisabledForPlugin(const WebNode&)
 560 {
 561     ASSERT_NOT_REACHED();
 562     return false;
 563 }
 564
 565 bool WebRemoteFrameImpl::hasCustomPageSizeStyle(int pageIndex)
 566 {
 567     ASSERT_NOT_REACHED();
 568     return false;
 569 }
 570
 571 bool WebRemoteFrameImpl::isPageBoxVisible(int pageIndex)
 572 {
 573     ASSERT_NOT_REACHED();
 574     return false;
 575 }
 576
 577 void WebRemoteFrameImpl::pageSizeAndMarginsInPixels(
 578     int pageIndex,
 579     WebSize& pageSize,
 580     int& marginTop,
 581     int& marginRight,
 582     int& marginBottom,
 583     int& marginLeft)
 584 {
 585     ASSERT_NOT_REACHED();
 586 }
 587
 588 WebString WebRemoteFrameImpl::pageProperty(const WebString& propertyName, int pageIndex)
 589 {
 590     ASSERT_NOT_REACHED();
 591     return WebString();
 592 }
 593
 594 void WebRemoteFrameImpl::printPagesWithBoundaries(WebCanvas*, const WebSize&)
 595 {
 596     ASSERT_NOT_REACHED();
 597 }
 598
 599 bool WebRemoteFrameImpl::find(
 600     int identifier, const WebString& searchText, const WebFindOptions&,
 601     bool wrapWithinFrame, WebRect* selectionRect)
 602 {
 603     ASSERT_NOT_REACHED();
 604     return false;
 605 }
 606
 607 void WebRemoteFrameImpl::stopFinding(bool clearSelection)
 608 {
 609     ASSERT_NOT_REACHED();
 610 }
 611
 612 void WebRemoteFrameImpl::scopeStringMatches(
 613     int identifier, const WebString& searchText, const WebFindOptions&,
 614     bool reset)
 615 {
 616     ASSERT_NOT_REACHED();
 617 }
 618
 619 void WebRemoteFrameImpl::cancelPendingScopingEffort()
 620 {
 621     ASSERT_NOT_REACHED();
 622 }
 623
 624 void WebRemoteFrameImpl::increaseMatchCount(int count, int identifier)
 625 {
 626     ASSERT_NOT_REACHED();
 627 }
 628
 629 void WebRemoteFrameImpl::resetMatchCount()
 630 {
 631     ASSERT_NOT_REACHED();
 632 }
 633
 634 int WebRemoteFrameImpl::findMatchMarkersVersion() const
 635 {
 636     ASSERT_NOT_REACHED();
 637     return 0;
 638 }
 639
 640 WebFloatRect WebRemoteFrameImpl::activeFindMatchRect()
 641 {
 642     ASSERT_NOT_REACHED();
 643     return WebFloatRect();
 644 }
 645
 646 void WebRemoteFrameImpl::findMatchRects(WebVector<WebFloatRect>&)
 647 {
 648     ASSERT_NOT_REACHED();
 649 }
 650
 651 int WebRemoteFrameImpl::selectNearestFindMatch(const WebFloatPoint&, WebRect* selectionRect)
 652 {
 653     ASSERT_NOT_REACHED();
 654     return 0;
 655 }
 656
 657 void WebRemoteFrameImpl::setTickmarks(const WebVector<WebRect>&)
 658 {
 659     ASSERT_NOT_REACHED();
 660 }
 661
 662 void WebRemoteFrameImpl::dispatchMessageEventWithOriginCheck(
 663     const WebSecurityOrigin& intendedTargetOrigin,
 664     const WebDOMEvent&)
 665 {
 666     ASSERT_NOT_REACHED();
 667 }
 668
 669 WebString WebRemoteFrameImpl::contentAsText(size_t maxChars) const
 670 {
 671     ASSERT_NOT_REACHED();
 672     return WebString();
 673 }
 674
 675 WebString WebRemoteFrameImpl::contentAsMarkup() const
 676 {
 677     ASSERT_NOT_REACHED();
 678     return WebString();
 679 }
 680
 681 WebString WebRemoteFrameImpl::layoutTreeAsText(LayoutAsTextControls toShow) const
 682 {
 683     ASSERT_NOT_REACHED();
 684     return WebString();
 685 }
 686
 687 WebString WebRemoteFrameImpl::markerTextForListItem(const WebElement&) const
 688 {
 689     ASSERT_NOT_REACHED();
 690     return WebString();
 691 }
 692
 693 WebRect WebRemoteFrameImpl::selectionBoundsRect() const
 694 {
 695     ASSERT_NOT_REACHED();
 696     return WebRect();
 697 }
 698
 699 bool WebRemoteFrameImpl::selectionStartHasSpellingMarkerFor(int from, int length) const
 700 {
 701     ASSERT_NOT_REACHED();
 702     return false;
 703 }
 704
 705 WebString WebRemoteFrameImpl::layerTreeAsText(bool showDebugInfo) const
 706 {
 707     ASSERT_NOT_REACHED();
 708     return WebString();
 709 }
 710
 711 WebLocalFrame* WebRemoteFrameImpl::createLocalChild(WebTreeScopeType scope, const WebString& name, WebSandboxFlags sandboxFlags, WebFrameClient* client, WebFrame* previousSibling)
 712 {
 713     WebLocalFrameImpl* child = toWebLocalFrameImpl(WebLocalFrame::create(scope, client));
 714     WillBeHeapHashMap<WebFrame*, OwnPtrWillBeMember<FrameOwner>>::AddResult result =
 715         m_ownersForChildren.add(child, RemoteBridgeFrameOwner::create(child, static_cast<SandboxFlags>(sandboxFlags)));
 716     insertAfter(child, previousSibling);
 717     // FIXME: currently this calls LocalFrame::init() on the created LocalFrame, which may
 718     // result in the browser observing two navigations to about:blank (one from the initial
 719     // frame creation, and one from swapping it into the remote process). FrameLoader might
 720     // need a special initialization function for this case to avoid that duplicate navigation.
 721     child->initializeCoreFrame(frame()->host(), result.storedValue->value.get(), name, nullAtom);
 722     // Partially related with the above FIXME--the init() call may trigger JS dispatch. However,
 723     // if the parent is remote, it should never be detached synchronously...
 724     ASSERT(child->frame());
 725     return child;
 726 }
 727
 728
 729 void WebRemoteFrameImpl::initializeCoreFrame(FrameHost* host, FrameOwner* owner, const AtomicString& name)
 730 {
 731     setCoreFrame(RemoteFrame::create(m_frameClient.get(), host, owner));
 732     frame()->createView();
 733     m_frame->tree().setName(name, nullAtom);
 734 }
 735
 736 WebRemoteFrame* WebRemoteFrameImpl::createRemoteChild(WebTreeScopeType scope, const WebString& name, WebSandboxFlags sandboxFlags, WebRemoteFrameClient* client)
 737 {
 738     WebRemoteFrameImpl* child = toWebRemoteFrameImpl(WebRemoteFrame::create(scope, client));
 739     WillBeHeapHashMap<WebFrame*, OwnPtrWillBeMember<FrameOwner>>::AddResult result =
 740         m_ownersForChildren.add(child, RemoteBridgeFrameOwner::create(nullptr, static_cast<SandboxFlags>(sandboxFlags)));
 741     appendChild(child);
 742     child->initializeCoreFrame(frame()->host(), result.storedValue->value.get(), name);
 743     return child;
 744 }
 745
 746 void WebRemoteFrameImpl::setCoreFrame(PassRefPtrWillBeRawPtr<RemoteFrame> frame)
 747 {
 748     m_frame = frame;
 749 }
 750
 751 WebRemoteFrameImpl* WebRemoteFrameImpl::fromFrame(RemoteFrame& frame)
 752 {
 753     if (!frame.client())
 754         return nullptr;
 755     return static_cast<RemoteFrameClientImpl*>(frame.client())->webFrame();
 756 }
 757
 758 void WebRemoteFrameImpl::initializeFromFrame(WebLocalFrame* source) const
 759 {
 760     ASSERT(source);
 761     WebLocalFrameImpl* localFrameImpl = toWebLocalFrameImpl(source);
 762
 763     client()->initializeChildFrame(
 764         localFrameImpl->frame()->view()->frameRect(),
 765         localFrameImpl->frame()->page()->deviceScaleFactor());
 766 }
 767
 768 void WebRemoteFrameImpl::setReplicatedOrigin(const WebSecurityOrigin& origin) const
 769 {
 770     ASSERT(frame());
 771     frame()->securityContext()->setReplicatedOrigin(origin);
 772 }
 773
 774 void WebRemoteFrameImpl::setReplicatedSandboxFlags(WebSandboxFlags flags) const
 775 {
 776     ASSERT(frame());
 777     frame()->securityContext()->enforceSandboxFlags(static_cast<SandboxFlags>(flags));
 778 }
 779
 780 void WebRemoteFrameImpl::setReplicatedName(const WebString& name) const
 781 {
 782     ASSERT(frame());
 783     frame()->tree().setName(name, nullAtom);
 784 }
 785
 786 void WebRemoteFrameImpl::DispatchLoadEventForFrameOwner() const
 787 {
 788     ASSERT(frame()->owner()->isLocal());
 789     frame()->owner()->dispatchLoad();
 790 }
 791
 792 void WebRemoteFrameImpl::didStartLoading()
 793 {
 794     frame()->setIsLoading(true);
 795 }
 796
 797 void WebRemoteFrameImpl::didStopLoading()
 798 {
 799     frame()->setIsLoading(false);
 800     if (parent() && parent()->isWebLocalFrame()) {
 801         WebLocalFrameImpl* parentFrame =
 802             toWebLocalFrameImpl(parent()->toWebLocalFrame());
 803         parentFrame->frame()->loader().checkCompleted();
 804     }
 805 }
 806
 807 WebRemoteFrameImpl::WebRemoteFrameImpl(WebTreeScopeType scope, WebRemoteFrameClient* client)
 808     : WebRemoteFrame(scope)
 809     , m_frameClient(RemoteFrameClientImpl::create(this))
 810     , m_client(client)
 811 #if ENABLE(OILPAN)
 812     , m_selfKeepAlive(this)
 813 #endif
 814 {
 815 }
 816
 817 } // namespace blink