Oilpan: Prepare to make ExecutionContext GarbageCollectedMixin.

Source/core/dom/ExecutionContext.h

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2012 Google Inc. 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 20 matching lines @@
 #include "core/dom/ActiveDOMObject.h"
 #include "core/dom/ExecutionContextClient.h"
 #include "core/dom/SandboxFlags.h"
 #include "core/dom/SecurityContext.h"
 #include "core/events/ErrorEvent.h"
 #include "core/fetch/CrossOriginAccessControl.h"
 #include "core/frame/ConsoleTypes.h"
 #include "core/frame/DOMTimer.h"
 #include "platform/LifecycleContext.h"
 #include "platform/Supplementable.h"
+#include "platform/heap/Handle.h"
 #include "platform/weborigin/KURL.h"
 #include "wtf/Functional.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 
 namespace WTF {
 class OrdinalNumber;
 }
 
 namespace WebCore {
 
 class ContextLifecycleNotifier;
 class DOMWindow;
 class EventListener;
 class EventQueue;
 class EventTarget;
 class ExecutionContextTask;
 class ScriptState;
 class PublicURLManager;
 class SecurityOrigin;
 class ScriptCallStack;
 
-class ExecutionContext : public LifecycleContext<ExecutionContext>, public Supplementable<ExecutionContext> {
+class ExecutionContext
+    : public WillBeGarbageCollectedMixin
+    , public LifecycleContext<ExecutionContext>
+    , public Supplementable<ExecutionContext> {
 public:
     ExecutionContext();
     virtual ~ExecutionContext();
 
     // Delegating to ExecutionContextClient
     void setClient(ExecutionContextClient* client) { m_client = client; }
     bool isDocument() const { return m_client && m_client->isDocument(); }
     bool isWorkerGlobalScope() const { return m_client && m_client->isWorkerGlobalScope(); }
     bool isJSExecutionForbidden() { return m_client && m_client->isJSExecutionForbidden(); }
     SecurityOrigin* securityOrigin() const;
@@ skipping 26 matching lines @@
     virtual void suspendScheduledTasks();
     virtual void resumeScheduledTasks();
     virtual bool tasksNeedSuspension() { return false; }
 
     bool activeDOMObjectsAreSuspended() const { return m_activeDOMObjectsAreSuspended; }
     bool activeDOMObjectsAreStopped() const { return m_activeDOMObjectsAreStopped; }
     bool isIteratingOverObservers() const;
 
     // Called after the construction of an ActiveDOMObject to synchronize suspend state.
     void suspendActiveDOMObjectIfNeeded(ActiveDOMObject*);
-
+#if !ENABLE(OILPAN)
     void ref() { refExecutionContext(); }
     void deref() { derefExecutionContext(); }
+#endif
 
     // Gets the next id in a circular sequence from 1 to 2^31-1.
     int circularSequentialID();
 
     void didChangeTimerAlignmentInterval();
 
     SandboxFlags sandboxFlags() const { return m_sandboxFlags; }
     bool isSandboxed(SandboxFlags mask) const { return m_sandboxFlags & mask; }
     void enforceSandboxFlags(SandboxFlags mask);
 
     PassOwnPtr<LifecycleNotifier<ExecutionContext> > createLifecycleNotifier();
 
     virtual EventQueue* eventQueue() const = 0;
 
 protected:
 
     ContextLifecycleNotifier& lifecycleNotifier();
 
 private:
     friend class DOMTimer; // For installNewTimeout() and removeTimeoutByID() below.
 
     bool dispatchErrorEvent(PassRefPtrWillBeRawPtr<ErrorEvent>, AccessControlStatus);
 
+#if !ENABLE(OILPAN)
     virtual void refExecutionContext() = 0;
     virtual void derefExecutionContext() = 0;
+#endif
     // LifecycleContext implementation.
 
     // Implementation details for DOMTimer. No other classes should call these functions.
     int installNewTimeout(PassOwnPtr<ScheduledAction>, int timeout, bool singleShot);
     void removeTimeoutByID(int timeoutID); // This makes underlying DOMTimer instance destructed.
 
     ExecutionContextClient* m_client;

[haraken, 2014/06/06 05:54:53]

This raw pointer looks safe, but it would be great if you can make
ExecutionContextClient a GC-mixin. Then you can remove
ExecutionContext::setClient() from Document's destructor and
WorkerGlobalScope::dispose(). A follow-up is fine.

[tkent, 2014/06/06 06:52:48]

At this moment, ExecutionContextClient is always ExecutionContext itself.  So
tracing ExecutionContextClient is not attractive.

     SandboxFlags m_sandboxFlags;
 
     int m_circularSequentialID;
     typedef HashMap<int, OwnPtr<DOMTimer> > TimeoutMap;
     TimeoutMap m_timeouts;
 
     bool m_inDispatchErrorEvent;
     class PendingException;
     OwnPtr<Vector<OwnPtr<PendingException> > > m_pendingExceptions;
 
     bool m_activeDOMObjectsAreSuspended;
     bool m_activeDOMObjectsAreStopped;
 
     OwnPtr<PublicURLManager> m_publicURLManager;
 
     // The location of this member is important; to make sure contextDestroyed() notification on
     // ExecutionContext's members (notably m_timeouts) is called before they are destructed,
     // m_lifecycleNotifer should be placed *after* such members.
     OwnPtr<ContextLifecycleNotifier> m_lifecycleNotifier;
 };
 
 } // namespace WebCore
 
 #endif // ExecutionContext_h