Remove OwnPtr from Blink.

third_party/WebKit/Source/core/loader/EmptyClients.h

 /*
  * Copyright (C) 2006 Eric Seidel (eric@webkit.org)
  * Copyright (C) 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  * Copyright (C) 2012 Samsung Electronics. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 30 matching lines @@
 #include "platform/geometry/FloatPoint.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/heap/Handle.h"
 #include "platform/network/ResourceError.h"
 #include "platform/text/TextCheckerClient.h"
 #include "public/platform/WebFocusType.h"
 #include "public/platform/WebFrameScheduler.h"
 #include "public/platform/WebScreenInfo.h"
 #include "wtf/Forward.h"
+#include <memory>
 #include <v8.h>
 
 /*
  This file holds empty Client stubs for use by WebCore.
  Viewless element needs to create a dummy Page->LocalFrame->FrameView tree for use in parsing or executing JavaScript.
  This tree depends heavily on Clients (usually provided by WebKit classes).
 
  This file was first created for SVGImage as it had no way to access the current Page (nor should it,
  since Images are not tied to a page).
  See http://bugs.webkit.org/show_bug.cgi?id=5971 for the original discussion about this file.
@@ skipping 108 matching lines @@
     void didAssociateFormControls(const HeapVector<Member<Element>>&, LocalFrame*) override {}
 
     void annotatedRegionsChanged() override {}
     String acceptLanguages() override;
 
     CompositorProxyClient* createCompositorProxyClient(LocalFrame*) override { return nullptr; }
 
     void registerPopupOpeningObserver(PopupOpeningObserver*) override {}
     void unregisterPopupOpeningObserver(PopupOpeningObserver*) override {}
 
-    PassOwnPtr<WebFrameScheduler> createFrameScheduler(BlameContext*) override;
+    std::unique_ptr<WebFrameScheduler> createFrameScheduler(BlameContext*) override;
 };
 
 class CORE_EXPORT EmptyFrameLoaderClient : public FrameLoaderClient {
     WTF_MAKE_NONCOPYABLE(EmptyFrameLoaderClient);
 public:
     static EmptyFrameLoaderClient* create() { return new EmptyFrameLoaderClient; }
     ~EmptyFrameLoaderClient() override {}
 
     bool hasWebView() const override { return true; } // mainly for assertions
 
@@ skipping 54 matching lines @@
     void didDisplayInsecureContent() override {}
     void didRunInsecureContent(SecurityOrigin*, const KURL&) override {}
     void didDetectXSS(const KURL&, bool) override {}
     void didDispatchPingLoader(const KURL&) override {}
     void didDisplayContentWithCertificateErrors(const KURL&, const CString&) override {}
     void didRunContentWithCertificateErrors(const KURL&, const CString&) override {}
     void selectorMatchChanged(const Vector<String>&, const Vector<String>&) override {}
     LocalFrame* createFrame(const FrameLoadRequest&, const AtomicString&, HTMLFrameOwnerElement*) override;
     Widget* createPlugin(HTMLPlugInElement*, const KURL&, const Vector<String>&, const Vector<String>&, const String&, bool, DetachedPluginPolicy) override;
     bool canCreatePluginWithoutRenderer(const String& mimeType) const override { return false; }
-    PassOwnPtr<WebMediaPlayer> createWebMediaPlayer(HTMLMediaElement&, const WebMediaPlayerSource&, WebMediaPlayerClient*) override;
-    PassOwnPtr<WebMediaSession> createWebMediaSession() override;
+    std::unique_ptr<WebMediaPlayer> createWebMediaPlayer(HTMLMediaElement&, const WebMediaPlayerSource&, WebMediaPlayerClient*) override;
+    std::unique_ptr<WebMediaSession> createWebMediaSession() override;
 
     ObjectContentType getObjectContentType(const KURL&, const String&, bool) override { return ObjectContentType(); }
 
     void didCreateNewDocument() override {}
     void dispatchDidClearWindowObjectInMainWorld() override {}
     void documentElementAvailable() override {}
     void runScriptsAtDocumentElementAvailable() override {}
     void runScriptsAtDocumentReady(bool) override {}
 
     void didCreateScriptContext(v8::Local<v8::Context>, int extensionGroup, int worldId) override {}
     void willReleaseScriptContext(v8::Local<v8::Context>, int worldId) override {}
     bool allowScriptExtension(const String& extensionName, int extensionGroup, int worldId) override { return false; }
 
     WebCookieJar* cookieJar() const override { return 0; }
 
-    PassOwnPtr<WebServiceWorkerProvider> createServiceWorkerProvider() override;
+    std::unique_ptr<WebServiceWorkerProvider> createServiceWorkerProvider() override;
     bool isControlledByServiceWorker(DocumentLoader&) override { return false; }
     int64_t serviceWorkerID(DocumentLoader&) override { return -1; }
-    PassOwnPtr<WebApplicationCacheHost> createApplicationCacheHost(WebApplicationCacheHostClient*) override;
+    std::unique_ptr<WebApplicationCacheHost> createApplicationCacheHost(WebApplicationCacheHostClient*) override;
 
 protected:
     EmptyFrameLoaderClient() {}
 };
 
 class CORE_EXPORT EmptyTextCheckerClient : public TextCheckerClient {
     DISALLOW_NEW();
 public:
     ~EmptyTextCheckerClient() { }
 
@@ skipping 43 matching lines @@
     ~EmptyContextMenuClient() override {}
     bool showContextMenu(const ContextMenu*, bool) override { return false; }
     void clearContextMenu() override {}
 };
 
 CORE_EXPORT void fillWithEmptyClients(Page::PageClients&);
 
 } // namespace blink
 
 #endif // EmptyClients_h