Oilpan: move DOMWindow object to the oilpan heap.

Source/core/frame/DOMWindow.h

 /*
  * Copyright (C) 2006, 2007, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 73 matching lines @@
 
     typedef Vector<RefPtr<MessagePort>, 1> MessagePortArray;
 
 enum PageshowEventPersistence {
     PageshowEventNotPersisted = 0,
     PageshowEventPersisted = 1
 };
 
     enum SetLocationLocking { LockHistoryBasedOnGestureState, LockHistoryAndBackForwardList };
 
-    class DOMWindow FINAL : public RefCounted<DOMWindow>, public ScriptWrappable, public EventTargetWithInlineData, public FrameDestructionObserver, public Supplementable<DOMWindow>, public LifecycleContext<DOMWindow> {
-        REFCOUNTED_EVENT_TARGET(DOMWindow);
+    class DOMWindow FINAL : public RefCountedWillBeRefCountedGarbageCollected<DOMWindow>, public ScriptWrappable, public EventTargetWithInlineData, public FrameDestructionObserver, public Supplementable<DOMWindow>, public LifecycleContext<DOMWindow> {

[haraken, 2014/03/26 01:13:32]

Don't you need to use WillBeHeapSupplementable<DOMWindow>? Is it safe to do that
in a separate CL?

[sof, 2014/03/26 06:36:46]

I would prefer to do it later; as long as the supplements don't touch their
DOMWindow when destructing it ought to be fine (and if they were already, that'd
be a problem already, GCed DOMWindow or not). I'll verify.

[sof, 2014/03/26 07:44:27]

The one interesting case is DOMWindowPagePopup::~DOMWindowPagePopup(), which
clears out a pointer on the GCed object it keeps. Currently as a Persistent, so
there's no problem for the time being, but once it becomes a heap supplement,
there's something to address there.

[haraken, 2014/03/26 08:07:16]

Makes sense. Agreed with the point that it's safe to handle this in a separate
CL.

+        DEFINE_EVENT_TARGET_REFCOUNTING(RefCountedWillBeRefCountedGarbageCollected<DOMWindow>);
     public:
         static PassRefPtr<Document> createDocument(const String& mimeType, const DocumentInit&, bool forceXHTML);
-        static PassRefPtr<DOMWindow> create(LocalFrame& frame) { return adoptRef(new DOMWindow(frame)); }
+        static PassRefPtrWillBeRawPtr<DOMWindow> create(LocalFrame& frame)
+        {
+            return adoptRefWillBeRefCountedGarbageCollected(new DOMWindow(frame));
+        }
         virtual ~DOMWindow();
 
         PassRefPtr<Document> installNewDocument(const String& mimeType, const DocumentInit&, bool forceXHTML = false);
 
         virtual const AtomicString& interfaceName() const OVERRIDE;
         virtual ExecutionContext* executionContext() const OVERRIDE;
 
         virtual DOMWindow* toDOMWindow() OVERRIDE;
 
         void registerProperty(DOMWindowProperty*);
@@ skipping 32 matching lines @@
         DOMSelection* getSelection();
 
         Element* frameElement() const;
 
         void focus(ExecutionContext* = 0);
         void blur();
         void close(ExecutionContext* = 0);
         void print();
         void stop();
 
-        PassRefPtr<DOMWindow> open(const String& urlString, const AtomicString& frameName, const String& windowFeaturesString,
+        PassRefPtrWillBeRawPtr<DOMWindow> open(const String& urlString, const AtomicString& frameName, const String& windowFeaturesString,
             DOMWindow* callingWindow, DOMWindow* enteredWindow);
 
         typedef void (*PrepareDialogFunction)(DOMWindow*, void* context);
         void showModalDialog(const String& urlString, const String& dialogFeaturesString,
             DOMWindow* callingWindow, DOMWindow* enteredWindow, PrepareDialogFunction, void* functionContext);
 
         void alert(const String& message);
         bool confirm(const String& message);
         String prompt(const String& message, const String& defaultValue);
 
@@ skipping 153 matching lines @@
         void enqueuePageshowEvent(PageshowEventPersistence);
         void enqueueHashchangeEvent(const String& oldURL, const String& newURL);
         void enqueuePopstateEvent(PassRefPtr<SerializedScriptValue>);
         void dispatchWindowLoadEvent();
         void documentWasClosed();
         void statePopped(PassRefPtr<SerializedScriptValue>);
 
         // FIXME: This shouldn't be public once DOMWindow becomes ExecutionContext.
         void clearEventQueue();
 
+        void trace(Visitor*);
+
     protected:
         DOMWindowLifecycleNotifier& lifecycleNotifier();
 
     private:
         explicit DOMWindow(LocalFrame&);
 
         Page* page();
 
         virtual void frameDestroyed() OVERRIDE;
         virtual void willDetachFrameHost() OVERRIDE;
 
         void clearDocument();
         void resetDOMWindowProperties();
         void willDestroyDocumentInFrame();
 
         RefPtr<Document> m_document;
 
         bool m_shouldPrintWhenFinishedLoading;
 
         HashSet<DOMWindowProperty*> m_properties;
 
-        mutable RefPtrWillBePersistent<Screen> m_screen;
-        mutable RefPtrWillBePersistent<History> m_history;
-        mutable RefPtr<BarProp> m_locationbar;
-        mutable RefPtr<BarProp> m_menubar;
-        mutable RefPtr<BarProp> m_personalbar;
-        mutable RefPtr<BarProp> m_scrollbars;
-        mutable RefPtr<BarProp> m_statusbar;
-        mutable RefPtr<BarProp> m_toolbar;
-        mutable RefPtrWillBePersistent<Console> m_console;
-        mutable RefPtrWillBePersistent<Navigator> m_navigator;
-        mutable RefPtrWillBePersistent<Location> m_location;
+        mutable RefPtrWillBeMember<Screen> m_screen;
+        mutable RefPtrWillBeMember<History> m_history;
+        mutable RefPtrWillBeMember<BarProp> m_locationbar;
+        mutable RefPtrWillBeMember<BarProp> m_menubar;
+        mutable RefPtrWillBeMember<BarProp> m_personalbar;
+        mutable RefPtrWillBeMember<BarProp> m_scrollbars;
+        mutable RefPtrWillBeMember<BarProp> m_statusbar;
+        mutable RefPtrWillBeMember<BarProp> m_toolbar;
+        mutable RefPtrWillBeMember<Console> m_console;
+        mutable RefPtrWillBeMember<Navigator> m_navigator;
+        mutable RefPtrWillBeMember<Location> m_location;
         mutable RefPtr<StyleMedia> m_media;
 
         String m_status;
         String m_defaultStatus;
 
-        mutable RefPtrWillBePersistent<Storage> m_sessionStorage;
-        mutable RefPtrWillBePersistent<Storage> m_localStorage;
-        mutable RefPtrWillBePersistent<ApplicationCache> m_applicationCache;
+        mutable RefPtrWillBeMember<Storage> m_sessionStorage;
+        mutable RefPtrWillBeMember<Storage> m_localStorage;
+        mutable RefPtrWillBeMember<ApplicationCache> m_applicationCache;
 
-        mutable RefPtrWillBePersistent<Performance> m_performance;
+        mutable RefPtrWillBeMember<Performance> m_performance;
 
         mutable RefPtr<DOMWindowCSS> m_css;
 
         RefPtr<DOMWindowEventQueue> m_eventQueue;
         RefPtr<SerializedScriptValue> m_pendingStateObject;
     };
 
     inline String DOMWindow::status() const
     {
         return m_status;
     }
 
     inline String DOMWindow::defaultStatus() const
     {
         return m_defaultStatus;
     }
 
 } // namespace WebCore
 
 #endif // DOMWindow_h