Refactor FrameLoader loading interface

Source/web/WebLocalFrameImpl.cpp

Index: Source/web/WebLocalFrameImpl.cpp
diff --git a/Source/web/WebLocalFrameImpl.cpp b/Source/web/WebLocalFrameImpl.cpp
index d38c46be87265b9739e3e78615aaf734c4372266..08a563e22231331f48eabfe1a9dfb10fab2d3095 100644
--- a/Source/web/WebLocalFrameImpl.cpp
+++ b/Source/web/WebLocalFrameImpl.cpp
@@ -913,16 +913,41 @@ v8::Local<v8::Context> WebLocalFrameImpl::mainWorldScriptContext() const
     return toV8Context(frame(), DOMWrapperWorld::mainWorld());
 }
 
-void WebLocalFrameImpl::reload(bool ignoreCache)
+WebURLRequest WebLocalFrameImpl::requestFromHistoryItem(const WebHistoryItem& item,
+    WebURLRequest::CachePolicy cachePolicy) const
+{
+    RefPtrWillBeRawPtr<HistoryItem> historyItem = PassRefPtrWillBeRawPtr<HistoryItem>(item);
+    ResourceRequest request = FrameLoader::resourceRequestFromHistoryItem(
+        historyItem.get(), static_cast<ResourceRequestCachePolicy>(cachePolicy));
+    return WrappedResourceRequest(request);
+}
+
+WebURLRequest WebLocalFrameImpl::requestForReload(WebFrameLoadType loadType,
+    const WebURL& overrideUrl) const
 {
     ASSERT(frame());
-    frame()->loader().reload(ignoreCache ? EndToEndReload : NormalReload);
+    ResourceRequest request = frame()->loader().resourceRequestForReload(
+        *frame(), static_cast<FrameLoadType>(loadType), overrideUrl);
+    return WrappedResourceRequest(request);
+}
+
+void WebLocalFrameImpl::reload(bool ignoreCache)
+{
+    // TODO(clamy): Remove this function once RenderFrame calls loadRequest for
+    // all requests.
+    reloadWithOverrideURL(KURL(), ignoreCache);
 }
 
 void WebLocalFrameImpl::reloadWithOverrideURL(const WebURL& overrideUrl, bool ignoreCache)
 {
+    // TODO(clamy): Remove this function once RenderFrame calls loadRequest for
+    // all requests.
     ASSERT(frame());
-    frame()->loader().reload(ignoreCache ? EndToEndReload : NormalReload, overrideUrl);
+    WebFrameLoadType loadType = ignoreCache ? ReloadFromOrigin : Reload;
+    WebURLRequest request = requestForReload(loadType, overrideUrl);
+    if (request.isNull())
+        return;
+    loadRequest(request, loadType, WebHistoryItem(), WebHistoryDifferentDocumentLoad);
 }
 
 void WebLocalFrameImpl::reloadImage(const WebNode& webNode)
@@ -934,27 +959,35 @@ void WebLocalFrameImpl::reloadImage(const WebNode& webNode)
     }
 }
 
-void WebLocalFrameImpl::loadRequest(const WebURLRequest& request)
+void WebLocalFrameImpl::loadRequest(const WebURLRequest& request, WebFrameLoadType webFrameLoadType,
+    const WebHistoryItem& item, WebHistoryLoadType webHistoryLoadType)
 {
     ASSERT(frame());
     ASSERT(!request.isNull());
     const ResourceRequest& resourceRequest = request.toResourceRequest();
 
-    if (resourceRequest.url().protocolIs("javascript")) {
+    if (resourceRequest.url().protocolIs("javascript") && webFrameLoadType == Standard) {

[Nate Chapin, 2015/06/02 17:19:35]

Are there any situations where this will get called with
RedirectWithLockedBackForwardList?

[clamy, 2015/06/03 14:39:14]

I don't think so. Added an ASSERT to check that it never happens.

         loadJavaScriptURL(resourceRequest.url());
         return;
     }
 
-    frame()->loader().load(FrameLoadRequest(0, resourceRequest));
+    FrameLoadRequest frameRequest = FrameLoadRequest(nullptr, resourceRequest);
+    if (webFrameLoadType == Reload || webFrameLoadType == ReloadFromOrigin)
+        frameRequest = FrameLoader::frameRequestForReload(resourceRequest);
+
+    RefPtrWillBeRawPtr<HistoryItem> historyItem = PassRefPtrWillBeRawPtr<HistoryItem>(item);
+    frame()->loader().load(
+        frameRequest, static_cast<FrameLoadType>(webFrameLoadType), historyItem.get(),
+        static_cast<HistoryLoadType>(webHistoryLoadType));
 }
 
-void WebLocalFrameImpl::loadHistoryItem(const WebHistoryItem& item, WebHistoryLoadType loadType, WebURLRequest::CachePolicy cachePolicy)
+void WebLocalFrameImpl::loadHistoryItem(const WebHistoryItem& item, WebHistoryLoadType loadType,
+    WebURLRequest::CachePolicy cachePolicy)
 {
-    ASSERT(frame());
-    RefPtrWillBeRawPtr<HistoryItem> historyItem = PassRefPtrWillBeRawPtr<HistoryItem>(item);
-    ASSERT(historyItem);
-    frame()->loader().loadHistoryItem(historyItem.get(), FrameLoadTypeBackForward,
-        static_cast<HistoryLoadType>(loadType), static_cast<ResourceRequestCachePolicy>(cachePolicy));
+    // TODO(clamy): Remove this function once RenderFrame calls loadRequest for
+    // all requests.
+    WebURLRequest request = requestFromHistoryItem(item, cachePolicy);
+    loadRequest(request, BackForward, item, loadType);
 }
 
 void WebLocalFrameImpl::loadData(const WebData& data, const WebString& mimeType, const WebString& textEncoding, const WebURL& baseURL, const WebURL& unreachableURL, bool replace)
@@ -1709,10 +1742,14 @@ PassRefPtrWillBeRawPtr<LocalFrame> WebLocalFrameImpl::createChildFrame(const Fra
     if (isBackForwardLoadType(frame()->loader().loadType()) && !frame()->document()->loadEventFinished())
         childItem = PassRefPtrWillBeRawPtr<HistoryItem>(webframeChild->client()->historyItemForNewChildFrame(webframeChild));
 
-    if (childItem)
-        child->loader().loadHistoryItem(childItem.get(), FrameLoadTypeInitialHistoryLoad);
-    else
-        child->loader().load(request);
+    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());
 
     // Note a synchronous navigation (about:blank) would have already processed
     // onload, so it is possible for the child frame to have already been