Remove OwnPtr from Blink.

third_party/WebKit/Source/core/dom/Document.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
@@ skipping 37 matching lines @@
 #include "core/frame/HostsUsingFeatures.h"
 #include "core/html/parser/ParserSynchronizationPolicy.h"
 #include "core/page/PageVisibilityState.h"
 #include "platform/Length.h"
 #include "platform/Timer.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/ReferrerPolicy.h"
 #include "public/platform/WebFocusType.h"
 #include "public/platform/WebInsecureRequestPolicy.h"
 #include "wtf/HashSet.h"
-#include "wtf/OwnPtr.h"
-#include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
+#include <memory>
 
 namespace blink {
 
 class AnimationClock;
 class AnimationTimeline;
 class AXObjectCache;
 class Attr;
 class CDATASection;
 class CSSStyleDeclaration;
 class CSSStyleSheet;
@@ skipping 594 matching lines @@
     void didMergeTextNodes(Text& oldNode, unsigned offset);
     void didSplitTextNode(Text& oldNode);
 
     void clearDOMWindow() { m_domWindow = nullptr; }
     LocalDOMWindow* domWindow() const { return m_domWindow; }
 
     // Helper functions for forwarding LocalDOMWindow event related tasks to the LocalDOMWindow if it exists.
     void setWindowAttributeEventListener(const AtomicString& eventType, EventListener*);
     EventListener* getWindowAttributeEventListener(const AtomicString& eventType);
 
-    static void registerEventFactory(PassOwnPtr<EventFactoryBase>);
+    static void registerEventFactory(std::unique_ptr<EventFactoryBase>);
     static Event* createEvent(ExecutionContext*, const String& eventType, ExceptionState&);
 
     // keep track of what types of event listeners are registered, so we don't
     // dispatch events unnecessarily
     enum ListenerType {
         DOMSUBTREEMODIFIED_LISTENER          = 1,
         DOMNODEINSERTED_LISTENER             = 1 << 1,
         DOMNODEREMOVED_LISTENER              = 1 << 2,
         DOMNODEREMOVEDFROMDOCUMENT_LISTENER  = 1 << 3,
         DOMNODEINSERTEDINTODOCUMENT_LISTENER = 1 << 4,
@@ skipping 120 matching lines @@
     Document& topDocument() const;
     Document* contextDocument();
 
     ScriptRunner* scriptRunner() { return m_scriptRunner.get(); }
 
     Element* currentScript() const { return !m_currentScriptStack.isEmpty() ? m_currentScriptStack.last().get() : nullptr; }
     void currentScriptForBinding(HTMLScriptElementOrSVGScriptElement&) const;
     void pushCurrentScript(Element*);
     void popCurrentScript();
 
-    void setTransformSource(PassOwnPtr<TransformSource>);
+    void setTransformSource(std::unique_ptr<TransformSource>);
     TransformSource* transformSource() const { return m_transformSource.get(); }
 
     void incDOMTreeVersion() { DCHECK(m_lifecycle.stateAllowsTreeMutations()); m_domTreeVersion = ++s_globalTreeVersion; }
     uint64_t domTreeVersion() const { return m_domTreeVersion; }
 
     uint64_t styleVersion() const { return m_styleVersion; }
 
     enum PendingSheetLayout { NoLayoutWithPendingSheets, DidLayoutWithPendingSheets, IgnoreLayoutWithPendingSheets };
 
     bool didLayoutWithPendingStylesheets() const { return m_pendingSheetLayout == DidLayoutWithPendingSheets; }
@@ skipping 116 matching lines @@
     const DocumentTiming& timing() const { return m_documentTiming; }
 
     int requestAnimationFrame(FrameRequestCallback*);
     void cancelAnimationFrame(int id);
     void serviceScriptedAnimations(double monotonicAnimationStartTime);
 
     int requestIdleCallback(IdleRequestCallback*, const IdleRequestOptions&);
     void cancelIdleCallback(int id);
 
     EventTarget* errorEventTarget() final;
-    void logExceptionToConsole(const String& errorMessage, PassOwnPtr<SourceLocation>) final;
+    void logExceptionToConsole(const String& errorMessage, std::unique_ptr<SourceLocation>) final;
 
     void initDNSPrefetch();
 
     bool isInDocumentWrite() const { return m_writeRecursionDepth > 0; }
 
     TextAutosizer* textAutosizer();
 
     Element* createElement(const AtomicString& localName, const AtomicString& typeExtension, ExceptionState&);
     Element* createElementNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, const AtomicString& typeExtension, ExceptionState&);
     ScriptValue registerElement(ScriptState*, const AtomicString& name, const ElementRegistrationOptions&, ExceptionState&, V0CustomElement::NameSet validNames = V0CustomElement::StandardNames);
@@ skipping 207 matching lines @@
 
     void clearFocusedElementSoon();
     void clearFocusedElementTimerFired(Timer<Document>*);
 
     bool haveScriptBlockingStylesheetsLoaded() const;
     bool haveRenderBlockingStylesheetsLoaded() const;
     void styleResolverMayHaveChanged();
 
     void setHoverNode(Node*);
 
-    using EventFactorySet = HashSet<OwnPtr<EventFactoryBase>>;
+    using EventFactorySet = HashSet<std::unique_ptr<EventFactoryBase>>;
     static EventFactorySet& eventFactories();
 
     void setNthIndexCache(NthIndexCache* nthIndexCache) { DCHECK(!m_nthIndexCache || !nthIndexCache); m_nthIndexCache = nthIndexCache; }
 
     const OriginAccessEntry& accessEntryFromURL();
 
     DocumentLifecycle m_lifecycle;
 
     bool m_hasNodesWithPlaceholderStyle;
     bool m_evaluateMediaQueriesOnStyleRecalc;
@@ skipping 12 matching lines @@
     Member<ContextFeatures> m_contextFeatures;
 
     bool m_wellFormed;
 
     // Document URLs.
     KURL m_url; // Document.URL: The URL from which this document was retrieved.
     KURL m_baseURL; // Node.baseURI: The URL to use when resolving relative URLs.
     KURL m_baseURLOverride; // An alternative base URL that takes precedence over m_baseURL (but not m_baseElementURL).
     KURL m_baseElementURL; // The URL set by the <base> element.
     KURL m_cookieURL; // The URL to use for cookie access.
-    OwnPtr<OriginAccessEntry> m_accessEntryFromURL;
+    std::unique_ptr<OriginAccessEntry> m_accessEntryFromURL;
 
     AtomicString m_baseTarget;
 
     // Mime-type of the document in case it was cloned or created by XHR.
     AtomicString m_mimeType;
 
     Member<DocumentType> m_docType;
     Member<DOMImplementation> m_implementation;
 
     Member<CSSStyleSheet> m_elemSheet;
 
     bool m_printing;
     bool m_wasPrinting;
     bool m_paginatedForScreen;
 
     CompatibilityMode m_compatibilityMode;
     bool m_compatibilityModeLocked; // This is cheaper than making setCompatibilityMode virtual.
 
-    OwnPtr<CancellableTaskFactory> m_executeScriptsWaitingForResourcesTask;
+    std::unique_ptr<CancellableTaskFactory> m_executeScriptsWaitingForResourcesTask;
 
     bool m_hasAutofocused;
     Timer<Document> m_clearFocusedElementTimer;
     Member<Element> m_autofocusElement;
     Member<Element> m_focusedElement;
     Member<Range> m_sequentialFocusNavigationStartingPoint;
     Member<Node> m_hoverNode;
     Member<Element> m_activeHoverElement;
     Member<Element> m_documentElement;
     UserActionElementSet m_userActionElements;
@@ skipping 46 matching lines @@
     Member<Element> m_cssTarget;
 
     LoadEventProgress m_loadEventProgress;
 
     double m_startTime;
 
     Member<ScriptRunner> m_scriptRunner;
 
     HeapVector<Member<Element>> m_currentScriptStack;
 
-    OwnPtr<TransformSource> m_transformSource;
+    std::unique_ptr<TransformSource> m_transformSource;
 
     String m_xmlEncoding;
     String m_xmlVersion;
     unsigned m_xmlStandalone : 2;
     unsigned m_hasXMLDeclaration : 1;
 
     AtomicString m_contentLanguage;
 
     DocumentEncodingData m_encodingData;
 
     bool m_designMode;
     bool m_isRunningExecCommand;
 
     HeapHashSet<WeakMember<const LiveNodeListBase>> m_listsInvalidatedAtDocument;
     // Oilpan keeps track of all registered NodeLists.
     // TODO(Oilpan): improve - only need to know if a NodeList
     // is currently alive or not for the different types.
     HeapHashSet<WeakMember<const LiveNodeListBase>> m_nodeLists[numNodeListInvalidationTypes];
 
     Member<SVGDocumentExtensions> m_svgExtensions;
 
     Vector<AnnotatedRegionValue> m_annotatedRegions;
     bool m_hasAnnotatedRegions;
     bool m_annotatedRegionsDirty;
 
-    OwnPtr<SelectorQueryCache> m_selectorQueryCache;
+    std::unique_ptr<SelectorQueryCache> m_selectorQueryCache;
 
     // It is safe to keep a raw, untraced pointer to this stack-allocated
     // cache object: it is set upon the cache object being allocated on
     // the stack and cleared upon leaving its allocated scope. Hence it
     // is acceptable not to trace it -- should a conservative GC occur,
     // the cache object's references will be traced by a stack walk.
     GC_PLUGIN_IGNORE("461878")
     NthIndexCache* m_nthIndexCache = nullptr;
 
     bool m_useSecureKeyboardEntryWhenActive;
@@ skipping 23 matching lines @@
 
     ReferrerPolicy m_referrerPolicy;
 
     DocumentTiming m_documentTiming;
     Member<MediaQueryMatcher> m_mediaQueryMatcher;
     bool m_writeRecursionIsTooDeep;
     unsigned m_writeRecursionDepth;
 
     Member<ScriptedAnimationController> m_scriptedAnimationController;
     Member<ScriptedIdleTaskController> m_scriptedIdleTaskController;
-    OwnPtr<MainThreadTaskRunner> m_taskRunner;
+    std::unique_ptr<MainThreadTaskRunner> m_taskRunner;
     Member<TextAutosizer> m_textAutosizer;
 
     Member<V0CustomElementRegistrationContext> m_registrationContext;
     Member<V0CustomElementMicrotaskRunQueue> m_customElementMicrotaskRunQueue;
 
     void elementDataCacheClearTimerFired(Timer<Document>*);
     Timer<Document> m_elementDataCacheClearTimer;
 
     Member<ElementDataCache> m_elementDataCache;
 
-    using LocaleIdentifierToLocaleMap = HashMap<AtomicString, OwnPtr<Locale>>;
+    using LocaleIdentifierToLocaleMap = HashMap<AtomicString, std::unique_ptr<Locale>>;
     LocaleIdentifierToLocaleMap m_localeCache;
 
     Member<AnimationTimeline> m_timeline;
     Member<CompositorPendingAnimations> m_compositorPendingAnimations;
 
     Member<Document> m_templateDocument;
     Member<Document> m_templateDocumentHost;
 
     Timer<Document> m_didAssociateFormControlsTimer;
     HeapHashSet<Member<Element>> m_associatedFormControls;
@@ skipping 63 matching lines @@
 DEFINE_TYPE_CASTS(TreeScope, Document, document, true, true);
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 CORE_EXPORT void showLiveDocumentInstances();
 #endif
 
 #endif // Document_h