Oilpan: Remove WillBe types (part 13)

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 38 matching lines @@
 #include "platform/UserGestureIndicator.h"
 #include "platform/scheduler/CancellableTaskFactory.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
 
 unsigned NavigationDisablerForBeforeUnload::s_navigationDisableCount = 0;
 
-class ScheduledNavigation : public NoBaseWillBeGarbageCollectedFinalized<ScheduledNavigation> {
-    WTF_MAKE_NONCOPYABLE(ScheduledNavigation); USING_FAST_MALLOC_WILL_BE_REMOVED(ScheduledNavigation);
+class ScheduledNavigation : public GarbageCollectedFinalized<ScheduledNavigation> {
+    WTF_MAKE_NONCOPYABLE(ScheduledNavigation);
 public:
     ScheduledNavigation(double delay, Document* originDocument, bool replacesCurrentItem, bool isLocationChange)
         : m_delay(delay)
         , m_originDocument(originDocument)
         , m_replacesCurrentItem(replacesCurrentItem)
         , m_isLocationChange(isLocationChange)
         , m_wasUserGesture(UserGestureIndicator::processingUserGesture())
     {
         if (m_wasUserGesture)
             m_userGestureToken = UserGestureIndicator::currentToken();
@@ skipping 18 matching lines @@
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_originDocument);
     }
 
 protected:
     void clearUserGesture() { m_wasUserGesture = false; }
 
 private:
     double m_delay;
-    RefPtrWillBeMember<Document> m_originDocument;
+    Member<Document> m_originDocument;
     bool m_replacesCurrentItem;
     bool m_isLocationChange;
     bool m_wasUserGesture;
     RefPtr<UserGestureToken> m_userGestureToken;
 };
 
 class ScheduledURLNavigation : public ScheduledNavigation {
 protected:
     ScheduledURLNavigation(double delay, Document* originDocument, const String& url, bool replacesCurrentItem, bool isLocationChange)
         : ScheduledNavigation(delay, originDocument, replacesCurrentItem, isLocationChange)
@@ skipping 15 matching lines @@
 
     String url() const { return m_url; }
 
 private:
     String m_url;
     ContentSecurityPolicyDisposition m_shouldCheckMainWorldContentSecurityPolicy;
 };
 
 class ScheduledRedirect final : public ScheduledURLNavigation {
 public:
-    static PassOwnPtrWillBeRawPtr<ScheduledRedirect> create(double delay, Document* originDocument, const String& url, bool replacesCurrentItem)
+    static RawPtr<ScheduledRedirect> create(double delay, Document* originDocument, const String& url, bool replacesCurrentItem)
     {
-        return adoptPtrWillBeNoop(new ScheduledRedirect(delay, originDocument, url, 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);
         frame->loader().load(request);
     }
 
 private:
     ScheduledRedirect(double delay, Document* originDocument, const String& url, bool replacesCurrentItem)
         : ScheduledURLNavigation(delay, originDocument, url, replacesCurrentItem, false)
     {
         clearUserGesture();
     }
 };
 
 class ScheduledLocationChange final : public ScheduledURLNavigation {
 public:
-    static PassOwnPtrWillBeRawPtr<ScheduledLocationChange> create(Document* originDocument, const String& url, bool replacesCurrentItem)
+    static RawPtr<ScheduledLocationChange> create(Document* originDocument, const String& url, bool replacesCurrentItem)
     {
-        return adoptPtrWillBeNoop(new ScheduledLocationChange(originDocument, url, replacesCurrentItem));
+        return new ScheduledLocationChange(originDocument, url, replacesCurrentItem);
     }
 
 private:
     ScheduledLocationChange(Document* originDocument, const String& url, bool replacesCurrentItem)
         : ScheduledURLNavigation(0.0, originDocument, url, replacesCurrentItem, !protocolIsJavaScript(url)) { }
 };
 
 class ScheduledReload final : public ScheduledNavigation {
 public:
-    static PassOwnPtrWillBeRawPtr<ScheduledReload> create()
+    static RawPtr<ScheduledReload> create()
     {
         return adoptPtrWillBeNoop(new ScheduledReload);
     }
 
     void fire(LocalFrame* frame) override
     {
         OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         ResourceRequest resourceRequest =
             frame->loader().resourceRequestForReload(FrameLoadTypeReload, KURL(), ClientRedirect);
         if (resourceRequest.isNull())
             return;
         FrameLoadRequest request = FrameLoadRequest(nullptr, resourceRequest);
         request.setClientRedirect(ClientRedirect);
         frame->loader().load(request, FrameLoadTypeReload);
     }
 
 private:
     ScheduledReload()
         : ScheduledNavigation(0.0, nullptr, true, true)
     {
     }
 };
 
 class ScheduledPageBlock final : public ScheduledURLNavigation {
 public:
-    static PassOwnPtrWillBeRawPtr<ScheduledPageBlock> create(Document* originDocument, const String& url)
+    static RawPtr<ScheduledPageBlock> create(Document* originDocument, const String& url)
     {
-        return adoptPtrWillBeNoop(new ScheduledPageBlock(originDocument, 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);
         frame->loader().load(request);
     }
 private:
     ScheduledPageBlock(Document* originDocument, const String& url)
         : ScheduledURLNavigation(0.0, originDocument, url, true, true)
     {
     }
 
 };
 
 class ScheduledFormSubmission final : public ScheduledNavigation {
 public:
-    static PassOwnPtrWillBeRawPtr<ScheduledFormSubmission> create(Document* document, PassRefPtrWillBeRawPtr<FormSubmission> submission, bool replacesCurrentItem)
+    static RawPtr<ScheduledFormSubmission> create(Document* document, RawPtr<FormSubmission> submission, bool replacesCurrentItem)
     {
-        return adoptPtrWillBeNoop(new ScheduledFormSubmission(document, submission, replacesCurrentItem));
+        return new ScheduledFormSubmission(document, submission, replacesCurrentItem);
     }
 
     void fire(LocalFrame* frame) override
     {
         OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         FrameLoadRequest frameRequest(originDocument());
         m_submission->populateFrameLoadRequest(frameRequest);
         frameRequest.setReplacesCurrentItem(replacesCurrentItem());
         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:
-    ScheduledFormSubmission(Document* document, PassRefPtrWillBeRawPtr<FormSubmission> submission, bool replacesCurrentItem)
+    ScheduledFormSubmission(Document* document, RawPtr<FormSubmission> submission, bool replacesCurrentItem)
         : ScheduledNavigation(0, document, replacesCurrentItem, true)
         , m_submission(submission)
     {
         ASSERT(m_submission->form());
     }
 
-    RefPtrWillBeMember<FormSubmission> m_submission;
+    Member<FormSubmission> m_submission;
 };
 
 NavigationScheduler::NavigationScheduler(LocalFrame* frame)
     : m_frame(frame)
     , m_navigateTaskFactory(CancellableTaskFactory::create(this, &NavigationScheduler::navigateTask))
 {
 }
 
 NavigationScheduler::~NavigationScheduler()
 {
@@ skipping 77 matching lines @@
     schedule(ScheduledLocationChange::create(originDocument, url, replacesCurrentItem));
 }
 
 void NavigationScheduler::schedulePageBlock(Document* originDocument)
 {
     ASSERT(m_frame->page());
     const KURL& url = m_frame->document()->url();
     schedule(ScheduledPageBlock::create(originDocument, url));
 }
 
-void NavigationScheduler::scheduleFormSubmission(Document* document, PassRefPtrWillBeRawPtr<FormSubmission> submission)
+void NavigationScheduler::scheduleFormSubmission(Document* document, RawPtr<FormSubmission> submission)
 {
     ASSERT(m_frame->page());
     schedule(ScheduledFormSubmission::create(document, submission, mustReplaceCurrentItem(m_frame)));
 }
 
 void NavigationScheduler::scheduleReload()
 {
     if (!shouldScheduleReload())
         return;
     if (m_frame->document()->url().isEmpty())
         return;
     schedule(ScheduledReload::create());
 }
 
 void NavigationScheduler::navigateTask()
 {
     Platform::current()->currentThread()->scheduler()->removePendingNavigation();
 
     if (!m_frame->page())
         return;
     if (m_frame->page()->defersLoading()) {
         InspectorInstrumentation::frameClearedScheduledNavigation(m_frame);
         return;
     }
 
-    RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
+    RawPtr<LocalFrame> protect(m_frame.get());
 
-    OwnPtrWillBeRawPtr<ScheduledNavigation> redirect(m_redirect.release());
+    RawPtr<ScheduledNavigation> redirect(m_redirect.release());
     redirect->fire(m_frame);
     InspectorInstrumentation::frameClearedScheduledNavigation(m_frame);
 }
 
-void NavigationScheduler::schedule(PassOwnPtrWillBeRawPtr<ScheduledNavigation> redirect)
+void NavigationScheduler::schedule(RawPtr<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());
+        RawPtr<LocalFrame> protect(m_frame.get());
         m_frame->loader().stopAllLoaders();
         if (!m_frame->host())
             return;
     }
 
     cancel();
     m_redirect = redirect;
     startTimer();
 }
 
@@ skipping 26 matching lines @@
     m_redirect.clear();
 }
 
 DEFINE_TRACE(NavigationScheduler)
 {
     visitor->trace(m_frame);
     visitor->trace(m_redirect);
 }
 
 } // namespace blink