Revert "Extract ContextLifecycleNotifier from ScriptExecutionContext."

Source/core/dom/ScriptExecutionContext.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/SecurityContext.h"
 #include "core/page/ConsoleTypes.h"
 #include "core/platform/Supplementable.h"
 #include "weborigin/KURL.h"
 #include "wtf/HashSet.h"
 
 namespace WebCore {
 
 class CachedScript;
-class ContextLifecycleNotifier;
 class DatabaseContext;
 class DOMTimer;
 class EventListener;
 class EventQueue;
 class EventTarget;
 class MessagePort;
 class PublicURLManager;
 class ScriptCallStack;
 class ScriptState;
 
@@ skipping 20 matching lines @@
 
     void addConsoleMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, ScriptState* = 0, unsigned long requestIdentifier = 0);
     virtual void addConsoleMessage(MessageSource, MessageLevel, const String& message, unsigned long requestIdentifier = 0) = 0;
 
     virtual const SecurityOrigin* topOrigin() const = 0;
 
     PublicURLManager& publicURLManager();
 
     // Active objects are not garbage collected even if inaccessible, e.g. because their activity may result in callbacks being invoked.
     bool canSuspendActiveDOMObjects();
-    bool hasPendingActivity();
-
     // Active objects can be asked to suspend even if canSuspendActiveDOMObjects() returns 'false' -
     // step-by-step JS debugging is one example.
     virtual void suspendActiveDOMObjects(ActiveDOMObject::ReasonForSuspension);
     virtual void resumeActiveDOMObjects();
     virtual void stopActiveDOMObjects();
 
     bool activeDOMObjectsAreSuspended() const { return m_activeDOMObjectsAreSuspended; }
     bool activeDOMObjectsAreStopped() const { return m_activeDOMObjectsAreStopped; }
 
+    // Called from the constructor and destructors of ActiveDOMObject.
+    void didCreateActiveDOMObject(ActiveDOMObject*);
+    void willDestroyActiveDOMObject(ActiveDOMObject*);
+
     // Called after the construction of an ActiveDOMObject to synchronize suspend state.
     void suspendActiveDOMObjectIfNeeded(ActiveDOMObject*);
 
-    // Called from the constructor and destructors of ContextDestructionObserver
-    void wasObservedBy(ContextDestructionObserver*, ContextDestructionObserver::Type as);
-    void wasUnobservedBy(ContextDestructionObserver*, ContextDestructionObserver::Type as);
+    typedef HashSet<ActiveDOMObject*> ActiveDOMObjectsSet;
+    const ActiveDOMObjectsSet& activeDOMObjects() const { return m_activeDOMObjects; }
+
+    void didCreateDestructionObserver(ContextDestructionObserver*);
+    void willDestroyDestructionObserver(ContextDestructionObserver*);
 
     // MessagePort is conceptually a kind of ActiveDOMObject, but it needs to be tracked separately for message dispatch.
     void processMessagePortMessagesSoon();
     void dispatchMessagePortEvents();
     void createdMessagePort(MessagePort*);
     void destroyedMessagePort(MessagePort*);
     const HashSet<MessagePort*>& messagePorts() const { return m_messagePorts; }
 
     void ref() { refScriptExecutionContext(); }
     void deref() { derefScriptExecutionContext(); }
@@ skipping 40 matching lines @@
             : m_source(source)
             , m_level(level)
             , m_message(message.isolatedCopy())
         {
         }
         MessageSource m_source;
         MessageLevel m_level;
         String m_message;
     };
 
-    ContextLifecycleNotifier* lifecycleNotifier();
-
 private:
     virtual const KURL& virtualURL() const = 0;
     virtual KURL virtualCompleteURL(const String&) const = 0;
 
     virtual void addMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, PassRefPtr<ScriptCallStack>, ScriptState* = 0, unsigned long requestIdentifier = 0) = 0;
     virtual EventTarget* errorEventTarget() = 0;
     virtual void logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, PassRefPtr<ScriptCallStack>) = 0;
     bool dispatchErrorEvent(const String& errorMessage, int lineNumber, const String& sourceURL, CachedScript*);
 
     void closeMessagePorts();
 
     virtual void refScriptExecutionContext() = 0;
     virtual void derefScriptExecutionContext() = 0;
-    virtual PassOwnPtr<ContextLifecycleNotifier> createLifecycleNotifier();
 
-    OwnPtr<ContextLifecycleNotifier> m_lifecycleNotifier;
     HashSet<MessagePort*> m_messagePorts;
+    HashSet<ContextDestructionObserver*> m_destructionObservers;
+    ActiveDOMObjectsSet m_activeDOMObjects;
+    bool m_iteratingActiveDOMObjects;
+    bool m_inDestructor;
 
     int m_circularSequentialID;
     typedef HashMap<int, DOMTimer*> TimeoutMap;
     TimeoutMap m_timeouts;
 
     bool m_inDispatchErrorEvent;
     class PendingException;
     OwnPtr<Vector<OwnPtr<PendingException> > > m_pendingExceptions;
 
     bool m_activeDOMObjectsAreSuspended;
     ActiveDOMObject::ReasonForSuspension m_reasonForSuspendingActiveDOMObjects;
     bool m_activeDOMObjectsAreStopped;
 
     OwnPtr<PublicURLManager> m_publicURLManager;
 
     RefPtr<DatabaseContext> m_databaseContext;
 };
 
 } // namespace WebCore
 
 #endif // ScriptExecutionContext_h