OOPIF: History navigations for new child frames.

third_party/WebKit/Source/web/WebLocalFrameImpl.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 128 matching lines @@
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutTreeAsText.h"
 #include "core/layout/LayoutView.h"
 #include "core/style/StyleInheritedData.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/HistoryItem.h"
 #include "core/loader/MixedContentChecker.h"
 #include "core/loader/NavigationScheduler.h"
+#include "core/loader/ProgressTracker.h"
 #include "core/page/FocusController.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
 #include "core/page/PrintContext.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/ScopeRecorder.h"
 #include "core/paint/TransformRecorder.h"
 #include "core/timing/DOMWindowPerformance.h"
 #include "core/timing/Performance.h"
 #include "modules/app_banner/AppBannerController.h"
@@ skipping 1591 matching lines @@
     // solution. subResourceAttributeName returns just one attribute name. The
     // element might not have the attribute, and there might be other attributes
     // which can identify the element.
     RefPtrWillBeRawPtr<LocalFrame> child = webframeChild->initializeCoreFrame(frame()->host(), ownerElement, name, ownerElement->getAttribute(ownerElement->subResourceAttributeName()));
     // Initializing the core frame may cause the new child to be detached, since
     // it may dispatch a load event in the parent.
     if (!child->tree().parent())
         return nullptr;
 
     // If we're moving in the back/forward list, we might want to replace the content
-    // of this child frame with whatever was there at that point.
+    // of this child frame with whatever was there at that point. The client may want
+    // to do this asynchronously, in which case shouldLoadRequest will be set to false.
+    bool shouldLoadRequest = true;
     RefPtrWillBeRawPtr<HistoryItem> childItem = nullptr;
-    if (isBackForwardLoadType(frame()->loader().loadType()) && !frame()->document()->loadEventFinished())
-        childItem = PassRefPtrWillBeRawPtr<HistoryItem>(webframeChild->client()->historyItemForNewChildFrame(webframeChild));
+    if (isBackForwardLoadType(frame()->loader().loadType()) && !frame()->document()->loadEventFinished()) {
+        childItem = PassRefPtrWillBeRawPtr<HistoryItem>(webframeChild->client()->historyItemForNewChildFrame(&shouldLoadRequest));
+        if (!shouldLoadRequest) {
+            // The load will start in the browser process, so let the progress tracker
+            // know about it.
+            child->loader().progress().progressStarted();

[dcheng, 2015/11/25 06:18:55]

I feel a bit sad about this: we added NavigationPolicyHandledByClient to try to
handle this use case. I guess there's no way to use that here?

[Charlie Reis, 2015/11/25 18:41:15]

Hmm.  That's in shouldContinueForNavigationPolicy, after
decidePolicyForNavigation.  We don't get that far because we don't know what the
destination item is.

There's a chance we could restructure this to make the fallback case easier to
handle as well, but I'm less sure about the implications.  Suppose (in OOPIF
modes) we always load |request| here instead of looking for a history item for
the new child frame.  When we get to decidePolicyForNavigation, we punt it to
the browser process via OpenURL (hitting the NavigationPolicyHandledByClient
case you mention in FrameLoader).  The browser process would then look for a
history item to use instead.  If it doesn't find one, it can navigate to the
fallback URL using the rest of the OpenURL params.

There's a risk that starting to navigate to |request| will affect some state in
Blink, even though we aren't actually going to go it.  (For example, I was
worried that about:blank might just commit directly without going through
decidePolicyForNavigation, but thankfully that's not the case.)

Do you think we should tackle this now or as a separate attempt to fix the
fallback case?  (I'm noticing that we already call
ProgressTracker::progressStarted from
ScriptController::executeScriptIfJavaScriptURL, so it's not entirely hidden
within Frameloader.)

+            return child;
+        }
+    }
 
     FrameLoadRequest newRequest = request;
     FrameLoadType loadType = FrameLoadTypeStandard;
     if (childItem) {
         newRequest = FrameLoadRequest(request.originDocument(),
             FrameLoader::resourceRequestFromHistoryItem(childItem.get(), UseProtocolCachePolicy));
         loadType = FrameLoadTypeInitialHistoryLoad;
     }
     child->loader().load(newRequest, loadType, childItem.get());
 
@@ skipping 211 matching lines @@
 void WebLocalFrameImpl::initializeToReplaceRemoteFrame(WebRemoteFrame* oldWebFrame, const WebString& name, WebSandboxFlags flags, const WebFrameOwnerProperties& frameOwnerProperties)
 {
     Frame* oldFrame = toCoreFrame(oldWebFrame);
     // Note: this *always* temporarily sets a frame owner, even for main frames!
     // When a core Frame is created with no owner, it attempts to set itself as
     // the main frame of the Page. However, this is a provisional frame, and may
     // disappear, so Page::m_mainFrame can't be updated just yet.
     OwnPtrWillBeRawPtr<FrameOwner> tempOwner = RemoteBridgeFrameOwner::create(nullptr, SandboxNone, WebFrameOwnerProperties());
     RefPtrWillBeRawPtr<LocalFrame> frame = LocalFrame::create(m_frameLoaderClientImpl.get(), oldFrame->host(), tempOwner.get());
     frame->setOwner(oldFrame->owner());
-    frame->tree().setName(name);
     setParent(oldWebFrame->parent());
     setOpener(oldWebFrame->opener());
+    frame->tree().setName(name);
     setCoreFrame(frame);
 
     if (frame->owner() && !frame->owner()->isLocal()) {
         toRemoteBridgeFrameOwner(frame->owner())->setSandboxFlags(static_cast<SandboxFlags>(flags));
         // Since a remote frame doesn't get the notifications about frame owner
         // property modifications, we need to sync up those properties here.
         WebLocalFrameImpl::fromFrame(frame.get())->setFrameOwnerProperties(frameOwnerProperties);
     }
 
     // We must call init() after m_frame is assigned because it is referenced
@@ skipping 204 matching lines @@
 }
 
 WebSandboxFlags WebLocalFrameImpl::effectiveSandboxFlags() const
 {
     if (!frame())
         return WebSandboxFlags::None;
     return static_cast<WebSandboxFlags>(frame()->loader().effectiveSandboxFlags());
 }
 
 } // namespace blink