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 418eb40597c102f668079733dda017fc4a88daad..d7e7585b7876dc7241420e36f609c8bcf0978562 100644
--- a/Source/web/WebLocalFrameImpl.cpp
+++ b/Source/web/WebLocalFrameImpl.cpp
@@ -913,16 +913,49 @@ 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(const WebHistoryItem& item,
+    WebFrameLoadType loadType, const WebURL& overrideUrl) const
 {
     ASSERT(frame());
-    frame()->loader().reload(ignoreCache ? EndToEndReload : NormalReload);
+    RefPtrWillBeRawPtr<HistoryItem> historyItem = PassRefPtrWillBeRawPtr<HistoryItem>(item);
+    ResourceRequest request = FrameLoader::resourceRequestForReload(
+        historyItem.get(), *frame(), static_cast<FrameLoadType>(loadType), overrideUrl);
+    return WrappedResourceRequest(request);
+}
+
+WebHistoryItem WebLocalFrameImpl::CurrentItem() const
+{
+    return WebHistoryItem(frame()->loader().currentItem());
+}
+
+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 ?
+        WebFrameLoadTypeReloadFromOrigin : WebFrameLoadTypeReload;
+    WebHistoryItem item = CurrentItem();
+    if (item.isNull())
+        return;
+    WebURLRequest request = RequestForReload(item, loadType, overrideUrl);
+    loadRequest(request, loadType, WebHistoryItem());
 }
 
 void WebLocalFrameImpl::reloadImage(const WebNode& webNode)
@@ -934,27 +967,38 @@ void WebLocalFrameImpl::reloadImage(const WebNode& webNode)
     }
 }
 
-void WebLocalFrameImpl::loadRequest(const WebURLRequest& request)
+void WebLocalFrameImpl::loadRequest(const WebURLRequest& request, WebFrameLoadType webFrameLoadType,
+    const WebHistoryItem& item)
 {
     ASSERT(frame());
     ASSERT(!request.isNull());
     const ResourceRequest& resourceRequest = request.toResourceRequest();
 
-    if (resourceRequest.url().protocolIs("javascript")) {
+    if (resourceRequest.url().protocolIs("javascript")
+        && webFrameLoadType == WebFrameLoadTypeStandard) {
         loadJavaScriptURL(resourceRequest.url());
         return;
     }
 
-    frame()->loader().load(FrameLoadRequest(0, resourceRequest));
+    FrameLoadRequest frameRequest = FrameLoadRequest(nullptr, resourceRequest);
+    if (webFrameLoadType == WebFrameLoadTypeReload
+        || webFrameLoadType == WebFrameLoadTypeReloadFromOrigin)
+        frameRequest = FrameLoader::frameRequestForReload(resourceRequest);
+
+    RefPtrWillBeRawPtr<HistoryItem> historyItem = PassRefPtrWillBeRawPtr<HistoryItem>(item);
+    frame()->loader().load(
+        frameRequest, static_cast<FrameLoadType>(webFrameLoadType), historyItem.get());
 }
 
-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);
+    WebFrameLoadType frameLoadType = loadType == WebHistorySameDocumentLoad ?
+        WebFrameLoadTypeHistorySameDocument : WebFrameLoadTypeBackForward;
+    loadRequest(request, frameLoadType, item);
 }
 
 void WebLocalFrameImpl::loadData(const WebData& data, const WebString& mimeType, const WebString& textEncoding, const WebURL& baseURL, const WebURL& unreachableURL, bool replace)
@@ -1709,10 +1753,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