Refactor FrameLoader loading interface

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 895 matching lines @@
     if (!frame()->script().callFunction(function, receiver, argc, static_cast<v8::Local<v8::Value>*>(argv)).ToLocal(&result))
         return v8::Local<v8::Value>();
     return result;
 }
 
 v8::Local<v8::Context> WebLocalFrameImpl::mainWorldScriptContext() const
 {
     return toV8Context(frame(), DOMWrapperWorld::mainWorld());
 }
 
+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());
+    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)
 {
-    ASSERT(frame());
-    frame()->loader().reload(ignoreCache ? EndToEndReload : NormalReload);
+    // 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)
 {
     const Node* node = webNode.constUnwrap<Node>();
     if (isHTMLImageElement(*node)) {
         const HTMLImageElement& imageElement = toHTMLImageElement(*node);
         imageElement.forceReload();
     }
 }
 
-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)
 {
     ASSERT(frame());
 
     // If we are loading substitute data to replace an existing load, then
     // inherit all of the properties of that original request. This way,
     // reload will re-attempt the original request. It is essential that
     // we only do this when there is an unreachableURL since a non-empty
@@ skipping 734 matching lines @@
     // 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.
     RefPtrWillBeRawPtr<HistoryItem> childItem = nullptr;
     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
     // detached by script in the page.
     if (!child->tree().parent())
         return nullptr;
     return child;
 }
 
 void WebLocalFrameImpl::didChangeContentsSize(const IntSize& size)
@@ skipping 362 matching lines @@
 {
     m_frameWidget = frameWidget;
 }
 
 WebFrameWidgetImpl* WebLocalFrameImpl::frameWidget() const
 {
     return m_frameWidget;
 }
 
 } // namespace blink