Add KURL::protocolIsJavascript member function

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 136 matching lines @@
   Member<Document> m_originDocument;
   bool m_replacesCurrentItem;
   bool m_isLocationChange;
   RefPtr<UserGestureToken> m_userGestureToken;
 };
 
 class ScheduledURLNavigation : public ScheduledNavigation {
  protected:
   ScheduledURLNavigation(double delay,
                          Document* originDocument,
-                         const String& url,
+                         const KURL& url,
                          bool replacesCurrentItem,
                          bool isLocationChange)
       : ScheduledNavigation(delay,
                             originDocument,
                             replacesCurrentItem,
                             isLocationChange),
         m_url(url),
         m_shouldCheckMainWorldContentSecurityPolicy(
             CheckContentSecurityPolicy) {
     if (ContentSecurityPolicy::shouldBypassMainWorld(originDocument)) {
@@ skipping 10 matching lines @@
     request.setReplacesCurrentItem(replacesCurrentItem());
     request.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
 
     ScheduledNavigationType type =
         isLocationChange() ? ScheduledNavigationType::ScheduledLocationChange
                            : ScheduledNavigationType::ScheduledURLNavigation;
     maybeLogScheduledNavigationClobber(type, frame);
     frame->loader().load(request);
   }
 
-  String url() const { return m_url; }
+  KURL url() const { return m_url; }
 
  private:
-  String m_url;
+  KURL m_url;
   ContentSecurityPolicyDisposition m_shouldCheckMainWorldContentSecurityPolicy;
 };
 
 class ScheduledRedirect final : public ScheduledURLNavigation {
  public:
   static ScheduledRedirect* create(double delay,
                                    Document* originDocument,
-                                   const String& url,
+                                   const KURL& url,
                                    bool replacesCurrentItem) {
     return new ScheduledRedirect(delay, originDocument, url,
                                  replacesCurrentItem);
   }
 
   bool shouldStartTimer(LocalFrame* frame) override {
     return frame->document()->loadEventFinished();
   }
 
   void fire(LocalFrame* frame) override {
     std::unique_ptr<UserGestureIndicator> gestureIndicator =
         createUserGestureIndicator();
     FrameLoadRequest request(originDocument(), url(), "_self");
     request.setReplacesCurrentItem(replacesCurrentItem());
     if (equalIgnoringFragmentIdentifier(frame->document()->url(),
                                         request.resourceRequest().url())) {
       request.resourceRequest().setCachePolicy(
           WebCachePolicy::ValidatingCacheData);
     }
     request.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
     maybeLogScheduledNavigationClobber(
         ScheduledNavigationType::ScheduledRedirect, frame);
     frame->loader().load(request);
   }
 
  private:
   ScheduledRedirect(double delay,
                     Document* originDocument,
-                    const String& url,
+                    const KURL& url,
                     bool replacesCurrentItem)
       : ScheduledURLNavigation(delay,
                                originDocument,
                                url,
                                replacesCurrentItem,
                                false) {
     clearUserGesture();
   }
 };
 
 class ScheduledLocationChange final : public ScheduledURLNavigation {
  public:
   static ScheduledLocationChange* create(Document* originDocument,
-                                         const String& url,
+                                         const KURL& url,
                                          bool replacesCurrentItem) {
     return new ScheduledLocationChange(originDocument, url,
                                        replacesCurrentItem);
   }
 
  private:
   ScheduledLocationChange(Document* originDocument,
-                          const String& url,
+                          const KURL& url,
                           bool replacesCurrentItem)
       : ScheduledURLNavigation(0.0,
                                originDocument,
                                url,
                                replacesCurrentItem,
-                               !protocolIsJavaScript(url)) {}
+                               !url.protocolIsJavaScript()) {}
 };
 
 class ScheduledReload final : public ScheduledNavigation {
  public:
   static ScheduledReload* create() { return new ScheduledReload; }
 
   void fire(LocalFrame* frame) override {
     std::unique_ptr<UserGestureIndicator> gestureIndicator =
         createUserGestureIndicator();
     ResourceRequest resourceRequest = frame->loader().resourceRequestForReload(
@@ skipping 107 matching lines @@
 //    to prevent Documents from being reattached during destruction, since it
 //    can cause bugs with security origin confusion. This is primarily intended
 //    to block /synchronous/ navigations during things lke
 //    Document::detachLayoutTree().
 inline bool NavigationScheduler::shouldScheduleReload() const {
   return m_frame->page() && m_frame->isNavigationAllowed() &&
          NavigationDisablerForBeforeUnload::isNavigationAllowed();
 }
 
 inline bool NavigationScheduler::shouldScheduleNavigation(
-    const String& url) const {
+    const KURL& url) const {
   return m_frame->page() && m_frame->isNavigationAllowed() &&
-         (protocolIsJavaScript(url) ||
+         (url.protocolIsJavaScript() ||
           NavigationDisablerForBeforeUnload::isNavigationAllowed());
 }
 
-void NavigationScheduler::scheduleRedirect(double delay, const String& url) {
+void NavigationScheduler::scheduleRedirect(double delay, const KURL& url) {
   if (!shouldScheduleNavigation(url))
     return;
   if (delay < 0 || delay > INT_MAX / 1000)
     return;
   if (url.isEmpty())
     return;
 
   // We want a new back/forward list item if the refresh timeout is > 1 second.
   if (!m_redirect || delay <= m_redirect->delay()) {
     schedule(
@@ skipping 13 matching lines @@
   // create a new back/forward item. The definition of "during load" is any time
   // before all handlers for the load event have been run. See
   // https://bugs.webkit.org/show_bug.cgi?id=14957 for the original motivation
   // for this.
   Frame* parentFrame = targetFrame->tree().parent();
   return parentFrame && parentFrame->isLocalFrame() &&
          !toLocalFrame(parentFrame)->loader().allAncestorsAreComplete();
 }
 
 void NavigationScheduler::scheduleLocationChange(Document* originDocument,
-                                                 const String& url,
+                                                 const KURL& url,
                                                  bool replacesCurrentItem) {
   if (!shouldScheduleNavigation(url))
     return;
 
   replacesCurrentItem = replacesCurrentItem || mustReplaceCurrentItem(m_frame);
 
   // 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");
+    if (url.hasFragmentIdentifier() &&
+        equalIgnoringFragmentIdentifier(m_frame->document()->url(), url)) {
+      FrameLoadRequest request(originDocument, url, "_self");
       request.setReplacesCurrentItem(replacesCurrentItem);
       if (replacesCurrentItem)
         request.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
       m_frame->loader().load(request);
       return;
     }
   }
 
   schedule(ScheduledLocationChange::create(originDocument, url,
                                            replacesCurrentItem));
@@ skipping 91 matching lines @@
   m_navigateTaskHandle.cancel();
   m_redirect.clear();
 }
 
 DEFINE_TRACE(NavigationScheduler) {
   visitor->trace(m_frame);
   visitor->trace(m_redirect);
 }
 
 }  // namespace blink