Change bool ignoreCache to WebFrameLoadType

third_party/WebKit/Source/core/loader/NavigationScheduler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2009 Adam Barth. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
@@ skipping 101 matching lines @@
     {
         if (ContentSecurityPolicy::shouldBypassMainWorld(originDocument))
             m_shouldCheckMainWorldContentSecurityPolicy = DoNotCheckContentSecurityPolicy;
     }
 
     void fire(LocalFrame* frame) override
     {
         OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         FrameLoadRequest request(originDocument(), m_url, "_self", m_shouldCheckMainWorldContentSecurityPolicy);
         request.setReplacesCurrentItem(replacesCurrentItem());
-        request.setClientRedirect(ClientRedirect);
+        request.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
         frame->loader().load(request);
     }
 
     String url() const { return m_url; }
 
 private:
     String m_url;
     ContentSecurityPolicyDisposition m_shouldCheckMainWorldContentSecurityPolicy;
 };
 
 class ScheduledRedirect final : public ScheduledURLNavigation {
 public:
     static RawPtr<ScheduledRedirect> create(double delay, Document* originDocument, const String& url, bool replacesCurrentItem)
     {
         return new ScheduledRedirect(delay, originDocument, url, replacesCurrentItem);
     }
 
     bool shouldStartTimer(LocalFrame* frame) override { return frame->document()->loadEventFinished(); }
 
     void fire(LocalFrame* frame) override
     {
         OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         FrameLoadRequest request(originDocument(), url(), "_self");
         request.setReplacesCurrentItem(replacesCurrentItem());
         if (equalIgnoringFragmentIdentifier(frame->document()->url(), request.resourceRequest().url()))
             request.resourceRequest().setCachePolicy(ValidatingCacheData);
-        request.setClientRedirect(ClientRedirect);
+        request.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
         frame->loader().load(request);
     }
 
 private:
     ScheduledRedirect(double delay, Document* originDocument, const String& url, bool replacesCurrentItem)
         : ScheduledURLNavigation(delay, originDocument, url, replacesCurrentItem, false)
     {
         clearUserGesture();
     }
 };
@@ skipping 13 matching lines @@
 class ScheduledReload final : public ScheduledNavigation {
 public:
     static RawPtr<ScheduledReload> create()
     {
         return new ScheduledReload;
     }
 
     void fire(LocalFrame* frame) override
     {
         OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
-        ResourceRequest resourceRequest =
-            frame->loader().resourceRequestForReload(FrameLoadTypeReload, KURL(), ClientRedirect);
+        ResourceRequest resourceRequest = frame->loader().resourceRequestForReload(FrameLoadTypeReload, KURL(), ClientRedirectPolicy::ClientRedirect);
         if (resourceRequest.isNull())
             return;
         FrameLoadRequest request = FrameLoadRequest(nullptr, resourceRequest);
-        request.setClientRedirect(ClientRedirect);
+        request.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
         frame->loader().load(request, FrameLoadTypeReload);
     }
 
 private:
     ScheduledReload()
         : ScheduledNavigation(0.0, nullptr, true, true)
     {
     }
 };
 
 class ScheduledPageBlock final : public ScheduledURLNavigation {
 public:
     static RawPtr<ScheduledPageBlock> create(Document* originDocument, const String& url)
     {
         return new ScheduledPageBlock(originDocument, url);
     }
 
     void fire(LocalFrame* frame) override
     {
         OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         SubstituteData substituteData(SharedBuffer::create(), "text/plain", "UTF-8", KURL(), ForceSynchronousLoad);
         FrameLoadRequest request(originDocument(), url(), substituteData);
         request.setReplacesCurrentItem(true);
-        request.setClientRedirect(ClientRedirect);
+        request.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
         frame->loader().load(request);
     }
 private:
     ScheduledPageBlock(Document* originDocument, const String& url)
         : ScheduledURLNavigation(0.0, originDocument, url, true, true)
     {
     }
 
 };
 
@@ skipping 104 matching lines @@
     // If the URL we're going to navigate to is the same as the current one, except for the
     // fragment part, we don't need to schedule the location change. We'll skip this
     // optimization for cross-origin navigations to minimize the navigator's ability to
     // execute timing attacks.
     if (originDocument->getSecurityOrigin()->canAccess(m_frame->document()->getSecurityOrigin())) {
         KURL parsedURL(ParsedURLString, url);
         if (parsedURL.hasFragmentIdentifier() && equalIgnoringFragmentIdentifier(m_frame->document()->url(), parsedURL)) {
             FrameLoadRequest request(originDocument, m_frame->document()->completeURL(url), "_self");
             request.setReplacesCurrentItem(replacesCurrentItem);
             if (replacesCurrentItem)
-                request.setClientRedirect(ClientRedirect);
+                request.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
             m_frame->loader().load(request);
             return;
         }
     }
 
     schedule(ScheduledLocationChange::create(originDocument, url, replacesCurrentItem));
 }
 
 void NavigationScheduler::schedulePageBlock(Document* originDocument)
 {
@@ skipping 84 matching lines @@
     m_redirect.clear();
 }
 
 DEFINE_TRACE(NavigationScheduler)
 {
     visitor->trace(m_frame);
     visitor->trace(m_redirect);
 }
 
 } // namespace blink