Oilpan: have LifetimeNotifier<T> track its observers weakly.

Source/modules/webmidi/MIDIAccessInitializer.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "modules/webmidi/MIDIAccessInitializer.h"
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/frame/Navigator.h"
 #include "modules/webmidi/MIDIAccess.h"
 #include "modules/webmidi/MIDIController.h"
 #include "modules/webmidi/MIDIOptions.h"
 #include "modules/webmidi/MIDIPort.h"
 
 namespace blink {
 
 using PortState = WebMIDIAccessorClient::MIDIPortState;
 
 MIDIAccessInitializer::MIDIAccessInitializer(ScriptState* scriptState, const MIDIOptions& options)
     : ScriptPromiseResolver(scriptState)
     , m_requestSysex(false)
     , m_hasBeenDisposed(false)
     , m_sysexPermissionResolved(false)
 {
 #if ENABLE(OILPAN)
-    // A prefinalizer has already been registered (as a LifecycleObserver);
-    // remove it and register a combined one, as the infrastructure doesn't
+#if ENABLE(ASSERT)
+    // A prefinalizer has already been registered for ScriptPromiseResolver;
+    // remove it and register a combined one as the infrastructure doesn't
     // support multiple prefinalizers for an object.
-    //
-    // FIXME: Oilpan: remove LifecycleObserver's need for a prefinalizer,
-    // and as a consequence, this unregistration step. If the former is independently
-    // removed, the unregisterPreFinalizer() call will assert.
-    ThreadState::current()->unregisterPreFinalizer(*static_cast<LifecycleObserver*>(this));
+    ThreadState::current()->unregisterPreFinalizer(*static_cast<ScriptPromiseResolver*>(this));
+#endif
     ThreadState::current()->registerPreFinalizer(*this);
 #endif
     if (options.hasSysex())
         m_requestSysex = options.sysex();
 }
 
 MIDIAccessInitializer::~MIDIAccessInitializer()
 {
 #if !ENABLE(OILPAN)
     dispose();
 #endif
 }
 
 void MIDIAccessInitializer::contextDestroyed()
 {
     dispose();
+    LifecycleObserver::contextDestroyed();
 }
 
 void MIDIAccessInitializer::dispose()
 {
     if (m_hasBeenDisposed)
         return;
 
     if (!executionContext())
         return;
 
     if (!m_sysexPermissionResolved) {
         Document* document = toDocument(executionContext());
         ASSERT(document);
         if (MIDIController* controller = MIDIController::from(document->frame()))
             controller->cancelSysexPermissionRequest(this);
         m_sysexPermissionResolved = true;
     }
 
     m_hasBeenDisposed = true;
-
-#if ENABLE(OILPAN)
-    // Delegate to LifecycleObserver's prefinalizer.
-    LifecycleObserver::dispose();
+#if ENABLE(OILPAN) && ENABLE(ASSERT)
+    ScriptPromiseResolver::dispose();
 #endif
 }
 
 ScriptPromise MIDIAccessInitializer::start()
 {
     ScriptPromise promise = this->promise();
     m_accessor = MIDIAccessor::create(this);
 
     if (!m_requestSysex) {
         m_accessor->startSession();
@@ skipping 75 matching lines @@
 {
     return executionContext()->securityOrigin();
 }
 
 ExecutionContext* MIDIAccessInitializer::executionContext() const
 {
     return scriptState()->executionContext();
 }
 
 } // namespace blink