Oilpan: move NavigationScheduler's redirect actions onto the heap.

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 36 matching lines @@
 #include "core/loader/FrameLoaderStateMachine.h"
 #include "core/page/Page.h"
 #include "platform/SharedBuffer.h"
 #include "platform/UserGestureIndicator.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
 
 unsigned NavigationDisablerForBeforeUnload::s_navigationDisableCount = 0;
 
-class ScheduledNavigation {
-    WTF_MAKE_NONCOPYABLE(ScheduledNavigation); WTF_MAKE_FAST_ALLOCATED(ScheduledNavigation);
+class ScheduledNavigation : public NoBaseWillBeGarbageCollectedFinalized<ScheduledNavigation> {
+    WTF_MAKE_NONCOPYABLE(ScheduledNavigation); WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(ScheduledNavigation);
 public:
     ScheduledNavigation(double delay, Document* originDocument, bool lockBackForwardList, bool isLocationChange)
         : m_delay(delay)
         , m_originDocument(originDocument)
         , m_lockBackForwardList(lockBackForwardList)
         , m_isLocationChange(isLocationChange)
         , m_wasUserGesture(UserGestureIndicator::processingUserGesture())
     {
         if (m_wasUserGesture)
             m_userGestureToken = UserGestureIndicator::currentToken();
     }
     virtual ~ScheduledNavigation() { }
 
     virtual void fire(LocalFrame*) = 0;
 
     virtual bool shouldStartTimer(LocalFrame*) { return true; }
 
     double delay() const { return m_delay; }
     Document* originDocument() const { return m_originDocument.get(); }
     bool lockBackForwardList() const { return m_lockBackForwardList; }
     bool isLocationChange() const { return m_isLocationChange; }
     PassOwnPtr<UserGestureIndicator> createUserGestureIndicator()
     {
         if (m_wasUserGesture &&  m_userGestureToken)
             return adoptPtr(new UserGestureIndicator(m_userGestureToken));
         return adoptPtr(new UserGestureIndicator(DefinitelyNotProcessingUserGesture));
     }
 
+    DEFINE_INLINE_VIRTUAL_TRACE()
+    {
+        visitor->trace(m_originDocument);
+    }
+
 protected:
     void clearUserGesture() { m_wasUserGesture = false; }
 
 private:
     double m_delay;
-    RefPtrWillBePersistent<Document> m_originDocument;
+    RefPtrWillBeMember<Document> m_originDocument;
     bool m_lockBackForwardList;
     bool m_isLocationChange;
     bool m_wasUserGesture;
     RefPtr<UserGestureToken> m_userGestureToken;
 };
 
 class ScheduledURLNavigation : public ScheduledNavigation {
 protected:
     ScheduledURLNavigation(double delay, Document* originDocument, const String& url, bool lockBackForwardList, bool isLocationChange)
         : ScheduledNavigation(delay, originDocument, lockBackForwardList, isLocationChange)
@@ skipping 15 matching lines @@
 
     String url() const { return m_url; }
 
 private:
     String m_url;
     ContentSecurityPolicyDisposition m_shouldCheckMainWorldContentSecurityPolicy;
 };
 
 class ScheduledRedirect final : public ScheduledURLNavigation {
 public:
-    ScheduledRedirect(double delay, Document* originDocument, const String& url, bool lockBackForwardList)
-        : ScheduledURLNavigation(delay, originDocument, url, lockBackForwardList, false)
+    static PassOwnPtrWillBeRawPtr<ScheduledRedirect> create(double delay, Document* originDocument, const String& url, bool lockBackForwardList)
     {
-        clearUserGesture();
+        return adoptPtrWillBeNoop(new ScheduledRedirect(delay, originDocument, url, lockBackForwardList));
     }
 
     virtual bool shouldStartTimer(LocalFrame* frame) override { return frame->document()->loadEventFinished(); }
 
     virtual void fire(LocalFrame* frame) override
     {
         OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         FrameLoadRequest request(originDocument(), url(), "_self");
         request.setLockBackForwardList(lockBackForwardList());
         if (equalIgnoringFragmentIdentifier(frame->document()->url(), request.resourceRequest().url()))
             request.resourceRequest().setCachePolicy(ReloadIgnoringCacheData);
         request.setClientRedirect(ClientRedirect);
         frame->loader().load(request);
     }
+private:
+    ScheduledRedirect(double delay, Document* originDocument, const String& url, bool lockBackForwardList)
+        : ScheduledURLNavigation(delay, originDocument, url, lockBackForwardList, false)
+    {
+        clearUserGesture();
+    }
 };
 
 class ScheduledLocationChange final : public ScheduledURLNavigation {
 public:
+    static PassOwnPtrWillBeRawPtr<ScheduledLocationChange> create(Document* originDocument, const String& url, bool lockBackForwardList)
+    {
+        return adoptPtrWillBeNoop(new ScheduledLocationChange(originDocument, url, lockBackForwardList));
+    }
+
+private:
     ScheduledLocationChange(Document* originDocument, const String& url, bool lockBackForwardList)
         : ScheduledURLNavigation(0.0, originDocument, url, lockBackForwardList, !protocolIsJavaScript(url)) { }
 };
 
 class ScheduledReload final : public ScheduledNavigation {
 public:
-    ScheduledReload()
-        : ScheduledNavigation(0.0, nullptr, true, true)
+    static PassOwnPtrWillBeRawPtr<ScheduledReload> create()
     {
+        return adoptPtrWillBeNoop(new ScheduledReload);
     }
 
     virtual void fire(LocalFrame* frame) override
     {
         OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         frame->loader().reload(NormalReload, KURL(), ClientRedirect);
     }
+
+private:
+    ScheduledReload()
+        : ScheduledNavigation(0.0, nullptr, true, true)
+    {
+    }
 };
 
 class ScheduledPageBlock final : public ScheduledURLNavigation {
 public:
-    ScheduledPageBlock(Document* originDocument, const String& url)
-        : ScheduledURLNavigation(0.0, originDocument, url, true, true)
+    static PassOwnPtrWillBeRawPtr<ScheduledPageBlock> create(Document* originDocument, const String& url)
     {
+        return adoptPtrWillBeNoop(new ScheduledPageBlock(originDocument, url));
     }
 
     virtual 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.setLockBackForwardList(true);
         request.setClientRedirect(ClientRedirect);
         frame->loader().load(request);
     }
+private:
+    ScheduledPageBlock(Document* originDocument, const String& url)
+        : ScheduledURLNavigation(0.0, originDocument, url, true, true)
+    {
+    }
+
 };
 
 class ScheduledFormSubmission final : public ScheduledNavigation {
 public:
-    ScheduledFormSubmission(Document* document, PassRefPtrWillBeRawPtr<FormSubmission> submission, bool lockBackForwardList)
-        : ScheduledNavigation(0, document, lockBackForwardList, true)
-        , m_submission(submission)
+    static PassOwnPtrWillBeRawPtr<ScheduledFormSubmission> create(Document* document, PassRefPtrWillBeRawPtr<FormSubmission> submission, bool lockBackForwardList)
     {
-        ASSERT(m_submission->form());
+        return adoptPtrWillBeNoop(new ScheduledFormSubmission(document, submission, lockBackForwardList));
     }
 
     virtual void fire(LocalFrame* frame) override
     {
         OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         FrameLoadRequest frameRequest(originDocument());
         m_submission->populateFrameLoadRequest(frameRequest);
         frameRequest.setLockBackForwardList(lockBackForwardList());
         frameRequest.setTriggeringEvent(m_submission->event());
         frameRequest.setForm(m_submission->form());
         frame->loader().load(frameRequest);
     }
 
+    DEFINE_INLINE_VIRTUAL_TRACE()
+    {
+        visitor->trace(m_submission);
+        ScheduledNavigation::trace(visitor);
+    }
+
 private:
-    RefPtrWillBePersistent<FormSubmission> m_submission;
+    ScheduledFormSubmission(Document* document, PassRefPtrWillBeRawPtr<FormSubmission> submission, bool lockBackForwardList)
+        : ScheduledNavigation(0, document, lockBackForwardList, true)
+        , m_submission(submission)
+    {
+        ASSERT(m_submission->form());
+    }
+
+    RefPtrWillBeMember<FormSubmission> m_submission;
 };
 
 NavigationScheduler::NavigationScheduler(LocalFrame* frame)
     : m_frame(frame)
     , m_timer(this, &NavigationScheduler::timerFired)
 {
 }
 
 NavigationScheduler::~NavigationScheduler()
 {
@@ skipping 18 matching lines @@
 {
     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(adoptPtr(new ScheduledRedirect(delay, m_frame->document(), url, delay <= 1)));
+        schedule(ScheduledRedirect::create(delay, m_frame->document(), url, delay <= 1));
 }
 
 bool NavigationScheduler::mustLockBackForwardList(LocalFrame* targetFrame)
 {
     // Non-user navigation before the page has finished firing onload should not create a new back/forward item.
     // See https://webkit.org/b/42861 for the original motivation for this.
     if (!UserGestureIndicator::processingUserGesture() && !targetFrame->document()->loadEventFinished())
         return true;
 
     // From the HTML5 spec for location.assign():
@@ skipping 29 matching lines @@
         if (parsedURL.hasFragmentIdentifier() && equalIgnoringFragmentIdentifier(m_frame->document()->url(), parsedURL)) {
             FrameLoadRequest request(originDocument, m_frame->document()->completeURL(url), "_self");
             request.setLockBackForwardList(lockBackForwardList);
             if (lockBackForwardList)
                 request.setClientRedirect(ClientRedirect);
             m_frame->loader().load(request);
             return;
         }
     }
 
-    schedule(adoptPtr(new ScheduledLocationChange(originDocument, url, lockBackForwardList)));
+    schedule(ScheduledLocationChange::create(originDocument, url, lockBackForwardList));
 }
 
 void NavigationScheduler::schedulePageBlock(Document* originDocument)
 {
     ASSERT(m_frame->page());
     const KURL& url = m_frame->document()->url();
-    schedule(adoptPtr(new ScheduledPageBlock(originDocument, url)));
+    schedule(ScheduledPageBlock::create(originDocument, url));
 }
 
 void NavigationScheduler::scheduleFormSubmission(Document* document, PassRefPtrWillBeRawPtr<FormSubmission> submission)
 {
     ASSERT(m_frame->page());
-    schedule(adoptPtr(new ScheduledFormSubmission(document, submission, mustLockBackForwardList(m_frame))));
+    schedule(ScheduledFormSubmission::create(document, submission, mustLockBackForwardList(m_frame)));
 }
 
 void NavigationScheduler::scheduleReload()
 {
     if (!shouldScheduleReload())
         return;
     if (m_frame->document()->url().isEmpty())
         return;
-    schedule(adoptPtr(new ScheduledReload));
+    schedule(ScheduledReload::create());
 }
 
 void NavigationScheduler::timerFired(Timer<NavigationScheduler>*)
 {
     if (!m_frame->page())
         return;
     if (m_frame->page()->defersLoading()) {
         InspectorInstrumentation::frameClearedScheduledNavigation(m_frame);
         return;
     }
 
     RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
 
-    OwnPtr<ScheduledNavigation> redirect(m_redirect.release());
+    OwnPtrWillBeRawPtr<ScheduledNavigation> redirect(m_redirect.release());
     redirect->fire(m_frame);
     InspectorInstrumentation::frameClearedScheduledNavigation(m_frame);
 }
 
-void NavigationScheduler::schedule(PassOwnPtr<ScheduledNavigation> redirect)
+void NavigationScheduler::schedule(PassOwnPtrWillBeRawPtr<ScheduledNavigation> redirect)
 {
     ASSERT(m_frame->page());
 
     // In a back/forward navigation, we sometimes restore history state to iframes, even though the state was generated
     // dynamically and JS will try to put something different in the iframe. In this case, we will load stale things
     // and/or confuse the JS when it shortly thereafter tries to schedule a location change. Let the JS have its way.
     // FIXME: This check seems out of place.
     if (!m_frame->loader().stateMachine()->committedFirstRealDocumentLoad() && m_frame->loader().provisionalDocumentLoader()) {
         RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
         m_frame->loader().provisionalDocumentLoader()->stopLoading();
@@ skipping 25 matching lines @@
 {
     if (m_timer.isActive())
         InspectorInstrumentation::frameClearedScheduledNavigation(m_frame);
     m_timer.stop();
     m_redirect.clear();
 }
 
 DEFINE_TRACE(NavigationScheduler)
 {
     visitor->trace(m_frame);
+    visitor->trace(m_redirect);
 }
 
 } // namespace blink