Change bool ignoreCache to WebFrameLoadType

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 832 matching lines @@
     ScriptState* scriptState = ScriptState::forMainWorld(frame());
     DCHECK(scriptState);
     return scriptState->context();
 }
 
 bool WebFrame::scriptCanAccess(WebFrame* target)
 {
     return BindingSecurity::shouldAllowAccessToFrame(mainThreadIsolate(), callingDOMWindow(mainThreadIsolate()), target->toImplBase()->frame(), DoNotReportSecurityError);
 }
 
-void WebLocalFrameImpl::reload(bool ignoreCache)
+void WebLocalFrameImpl::reload(WebFrameLoadType loadType)
 {
     // TODO(clamy): Remove this function once RenderFrame calls load for all
     // requests.
-    reloadWithOverrideURL(KURL(), ignoreCache);
+    reloadWithOverrideURL(KURL(), loadType);
 }
 
-void WebLocalFrameImpl::reloadWithOverrideURL(const WebURL& overrideUrl, bool ignoreCache)
+void WebLocalFrameImpl::reloadWithOverrideURL(const WebURL& overrideUrl, WebFrameLoadType loadType)
 {
     // TODO(clamy): Remove this function once RenderFrame calls load for all
     // requests.
     DCHECK(frame());
-    WebFrameLoadType loadType = ignoreCache ?
-        WebFrameLoadType::ReloadBypassingCache : WebFrameLoadType::Reload;
+    DCHECK(loadType == WebFrameLoadType::Reload || loadType == WebFrameLoadType::ReloadBypassingCache);
     WebURLRequest request = requestForReload(loadType, overrideUrl);
     if (request.isNull())
         return;
     load(request, loadType, WebHistoryItem(), WebHistoryDifferentDocumentLoad, false);
 }
 
 void WebLocalFrameImpl::reloadImage(const WebNode& webNode)
 {
     const Node* node = webNode.constUnwrap<Node>();
     if (isHTMLImageElement(*node)) {
@@ skipping 1044 matching lines @@
     const ResourceRequest& resourceRequest = request.toResourceRequest();
 
     if (resourceRequest.url().protocolIs("javascript")
         && webFrameLoadType == WebFrameLoadType::Standard) {
         loadJavaScriptURL(resourceRequest.url());
         return;
     }
 
     FrameLoadRequest frameRequest = FrameLoadRequest(nullptr, resourceRequest);
     if (isClientRedirect)
-        frameRequest.setClientRedirect(ClientRedirect);
+        frameRequest.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
     RawPtr<HistoryItem> historyItem = RawPtr<HistoryItem>(item);
     frame()->loader().load(
         frameRequest, static_cast<FrameLoadType>(webFrameLoadType), historyItem.get(),
         static_cast<HistoryLoadType>(webHistoryLoadType));
 }
 
 void WebLocalFrameImpl::loadData(const WebData& data, const WebString& mimeType,
     const WebString& textEncoding, const WebURL& baseURL, const WebURL& unreachableURL, bool replace,
     WebFrameLoadType webFrameLoadType, const WebHistoryItem& item,
     WebHistoryLoadType webHistoryLoadType, bool isClientRedirect)
 {
     DCHECK(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
     // unreachableURL informs FrameLoader::reload to load unreachableURL
     // instead of the currently loaded URL.
     ResourceRequest request;
     if (replace && !unreachableURL.isEmpty() && frame()->loader().provisionalDocumentLoader())
         request = frame()->loader().provisionalDocumentLoader()->originalRequest();
     request.setURL(baseURL);
     request.setCheckForBrowserSideNavigation(false);
 
     FrameLoadRequest frameRequest(0, request, SubstituteData(data, mimeType, textEncoding, unreachableURL));
     DCHECK(frameRequest.substituteData().isValid());
     frameRequest.setReplacesCurrentItem(replace);
     if (isClientRedirect)
-        frameRequest.setClientRedirect(ClientRedirect);
+        frameRequest.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
 
     RawPtr<HistoryItem> historyItem = RawPtr<HistoryItem>(item);
     frame()->loader().load(
         frameRequest, static_cast<FrameLoadType>(webFrameLoadType), historyItem.get(),
         static_cast<HistoryLoadType>(webHistoryLoadType));
 }
 
 bool WebLocalFrameImpl::isLoading() const
 {
     if (!frame() || !frame()->document())
@@ skipping 201 matching lines @@
         return WebSandboxFlags::None;
     return static_cast<WebSandboxFlags>(frame()->loader().effectiveSandboxFlags());
 }
 
 void WebLocalFrameImpl::forceSandboxFlags(WebSandboxFlags flags)
 {
     frame()->loader().forceSandboxFlags(static_cast<SandboxFlags>(flags));
 }
 
 } // namespace blink