Remove OwnPtr from Blink.

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 37 matching lines @@
 #include "core/loader/FrameLoaderStateMachine.h"
 #include "core/page/Page.h"
 #include "platform/Histogram.h"
 #include "platform/SharedBuffer.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/scheduler/CancellableTaskFactory.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCachePolicy.h"
 #include "public/platform/WebScheduler.h"
 #include "wtf/CurrentTime.h"
+#include "wtf/PtrUtil.h"
+#include <memory>
 
 namespace blink {
 
 namespace {
 
 // Add new scheduled navigation types before ScheduledLastEntry
 enum ScheduledNavigationType {
     ScheduledReload,
     ScheduledFormSubmission,
     ScheduledURLNavigation,
@@ skipping 45 matching lines @@
     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 replacesCurrentItem() const { return m_replacesCurrentItem; }
     bool isLocationChange() const { return m_isLocationChange; }
-    PassOwnPtr<UserGestureIndicator> createUserGestureIndicator()
+    std::unique_ptr<UserGestureIndicator> createUserGestureIndicator()
     {
         if (m_wasUserGesture &&  m_userGestureToken)
-            return adoptPtr(new UserGestureIndicator(m_userGestureToken));
-        return adoptPtr(new UserGestureIndicator(DefinitelyNotProcessingUserGesture));
+            return wrapUnique(new UserGestureIndicator(m_userGestureToken));
+        return wrapUnique(new UserGestureIndicator(DefinitelyNotProcessingUserGesture));
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_originDocument);
     }
 
 protected:
     void clearUserGesture() { m_wasUserGesture = false; }
 
@@ skipping 12 matching lines @@
         : ScheduledNavigation(delay, originDocument, replacesCurrentItem, isLocationChange)
         , m_url(url)
         , m_shouldCheckMainWorldContentSecurityPolicy(CheckContentSecurityPolicy)
     {
         if (ContentSecurityPolicy::shouldBypassMainWorld(originDocument))
             m_shouldCheckMainWorldContentSecurityPolicy = DoNotCheckContentSecurityPolicy;
     }
 
     void fire(LocalFrame* frame) override
     {
-        OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
+        std::unique_ptr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         FrameLoadRequest request(originDocument(), m_url, "_self", m_shouldCheckMainWorldContentSecurityPolicy);
         request.setReplacesCurrentItem(replacesCurrentItem());
         request.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
 
         ScheduledNavigationType type = isLocationChange() ? ScheduledNavigationType::ScheduledLocationChange : ScheduledNavigationType::ScheduledURLNavigation;
         maybeLogScheduledNavigationClobber(type, frame, request, gestureIndicator.get());
         frame->loader().load(request);
     }
 
     String url() const { return m_url; }
 
 private:
     String m_url;
     ContentSecurityPolicyDisposition m_shouldCheckMainWorldContentSecurityPolicy;
 };
 
 class ScheduledRedirect final : public ScheduledURLNavigation {
 public:
     static 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();
+        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, request, gestureIndicator.get());
         frame->loader().load(request);
     }
 
 private:
@@ skipping 18 matching lines @@
 
 class ScheduledReload final : public ScheduledNavigation {
 public:
     static ScheduledReload* create()
     {
         return new ScheduledReload;
     }
 
     void fire(LocalFrame* frame) override
     {
-        OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
+        std::unique_ptr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         ResourceRequest resourceRequest = frame->loader().resourceRequestForReload(FrameLoadTypeReload, KURL(), ClientRedirectPolicy::ClientRedirect);
         if (resourceRequest.isNull())
             return;
         FrameLoadRequest request = FrameLoadRequest(nullptr, resourceRequest);
         request.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
         maybeLogScheduledNavigationClobber(ScheduledNavigationType::ScheduledReload, frame, request, gestureIndicator.get());
         frame->loader().load(request, FrameLoadTypeReload);
     }
 
 private:
     ScheduledReload()
         : ScheduledNavigation(0.0, nullptr, true, true)
     {
     }
 };
 
 class ScheduledPageBlock final : public ScheduledURLNavigation {
 public:
     static ScheduledPageBlock* create(Document* originDocument, const String& url)
     {
         return new ScheduledPageBlock(originDocument, url);
     }
 
     void fire(LocalFrame* frame) override
     {
-        OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
+        std::unique_ptr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         SubstituteData substituteData(SharedBuffer::create(), "text/plain", "UTF-8", KURL(), ForceSynchronousLoad);
         FrameLoadRequest request(originDocument(), url(), substituteData);
         request.setReplacesCurrentItem(true);
         request.setClientRedirect(ClientRedirectPolicy::ClientRedirect);
         maybeLogScheduledNavigationClobber(ScheduledNavigationType::ScheduledPageBlock, frame, request, gestureIndicator.get());
         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 ScheduledFormSubmission* create(Document* document, FormSubmission* submission, bool replacesCurrentItem)
     {
         return new ScheduledFormSubmission(document, submission, replacesCurrentItem);
     }
 
     void fire(LocalFrame* frame) override
     {
-        OwnPtr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
+        std::unique_ptr<UserGestureIndicator> gestureIndicator = createUserGestureIndicator();
         FrameLoadRequest frameRequest(originDocument());
         m_submission->populateFrameLoadRequest(frameRequest);
         frameRequest.setReplacesCurrentItem(replacesCurrentItem());
         frameRequest.setTriggeringEvent(m_submission->event());
         frameRequest.setForm(m_submission->form());
         maybeLogScheduledNavigationClobber(ScheduledNavigationType::ScheduledFormSubmission, frame, frameRequest, gestureIndicator.get());
         frame->loader().load(frameRequest);
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
@@ skipping 206 matching lines @@
     m_redirect.clear();
 }
 
 DEFINE_TRACE(NavigationScheduler)
 {
     visitor->trace(m_frame);
     visitor->trace(m_redirect);
 }
 
 } // namespace blink