Remove ContextLifecycleObserver from MediaStream

third_party/WebKit/Source/modules/mediastream/MediaStream.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  * Copyright (C) 2011, 2012 Ericsson AB. 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 78 matching lines @@
   return new MediaStream(context, audioTracks, videoTracks);
 }
 
 MediaStream* MediaStream::create(ExecutionContext* context,
                                  MediaStreamDescriptor* streamDescriptor) {
   return new MediaStream(context, streamDescriptor);
 }
 
 MediaStream::MediaStream(ExecutionContext* context,
                          MediaStreamDescriptor* streamDescriptor)
-    : ContextLifecycleObserver(context),
-      m_stopped(false),
-      m_descriptor(streamDescriptor),
-      m_scheduledEventTimer(this, &MediaStream::scheduledEventTimerFired) {
+    : m_descriptor(streamDescriptor),
+      m_scheduledEventTimer(this, &MediaStream::scheduledEventTimerFired),
+      m_executionContext(context) {
   m_descriptor->setClient(this);
 
   size_t numberOfAudioTracks = m_descriptor->numberOfAudioComponents();
   m_audioTracks.reserveCapacity(numberOfAudioTracks);
   for (size_t i = 0; i < numberOfAudioTracks; i++) {
     MediaStreamTrack* newTrack =
         MediaStreamTrack::create(context, m_descriptor->audioComponent(i));
     newTrack->registerMediaStream(this);
     m_audioTracks.append(newTrack);
   }
 
   size_t numberOfVideoTracks = m_descriptor->numberOfVideoComponents();
   m_videoTracks.reserveCapacity(numberOfVideoTracks);
   for (size_t i = 0; i < numberOfVideoTracks; i++) {
     MediaStreamTrack* newTrack =
         MediaStreamTrack::create(context, m_descriptor->videoComponent(i));
     newTrack->registerMediaStream(this);
     m_videoTracks.append(newTrack);
   }
 
   if (emptyOrOnlyEndedTracks()) {
     m_descriptor->setActive(false);
   }
 }
 
 MediaStream::MediaStream(ExecutionContext* context,
                          const MediaStreamTrackVector& audioTracks,
                          const MediaStreamTrackVector& videoTracks)
-    : ContextLifecycleObserver(context),
-      m_stopped(false),
-      m_scheduledEventTimer(this, &MediaStream::scheduledEventTimerFired) {
+    : m_scheduledEventTimer(this, &MediaStream::scheduledEventTimerFired),
+      m_executionContext(context) {
   MediaStreamComponentVector audioComponents;
   MediaStreamComponentVector videoComponents;
 
   MediaStreamTrackVector::const_iterator iter;
   for (iter = audioTracks.begin(); iter != audioTracks.end(); ++iter) {
     (*iter)->registerMediaStream(this);
     audioComponents.append((*iter)->component());
   }
   for (iter = videoTracks.begin(); iter != videoTracks.end(); ++iter) {
     (*iter)->registerMediaStream(this);
@@ skipping 146 matching lines @@
   for (MediaStreamTrackVector::iterator iter = m_videoTracks.begin();
        iter != m_videoTracks.end(); ++iter) {
     if (!(*iter)->ended())
       return;
   }
 
   streamEnded();
 }
 
 void MediaStream::streamEnded() {
-  if (m_stopped)
+  if (m_executionContext->isContextDestroyed())
     return;
 
   if (active()) {
     m_descriptor->setActive(false);
     scheduleDispatchEvent(Event::create(EventTypeNames::inactive));
   }
 }
 
 bool MediaStream::addEventListenerInternal(
     const AtomicString& eventType,
     EventListener* listener,
     const AddEventListenerOptionsResolved& options) {
   if (eventType == EventTypeNames::active)
-    UseCounter::count(getExecutionContext(), UseCounter::MediaStreamOnActive);
+    UseCounter::count(m_executionContext, UseCounter::MediaStreamOnActive);
   else if (eventType == EventTypeNames::inactive)
-    UseCounter::count(getExecutionContext(), UseCounter::MediaStreamOnInactive);
+    UseCounter::count(m_executionContext, UseCounter::MediaStreamOnInactive);
 
   return EventTargetWithInlineData::addEventListenerInternal(eventType,
                                                              listener, options);
 }
 
-void MediaStream::contextDestroyed() {
-  ContextLifecycleObserver::contextDestroyed();
-  m_stopped = true;
-}
-
 const AtomicString& MediaStream::interfaceName() const {
   return EventTargetNames::MediaStream;
 }
 
-ExecutionContext* MediaStream::getExecutionContext() const {
-  return ContextLifecycleObserver::getExecutionContext();
-}
-
 void MediaStream::addRemoteTrack(MediaStreamComponent* component) {
   DCHECK(component);
-  if (m_stopped)
+  if (m_executionContext->isContextDestroyed())
     return;
 
   MediaStreamTrack* track =
-      MediaStreamTrack::create(getExecutionContext(), component);
+      MediaStreamTrack::create(m_executionContext, component);
   switch (component->source()->type()) {
     case MediaStreamSource::TypeAudio:
       m_audioTracks.append(track);
       break;
     case MediaStreamSource::TypeVideo:
       m_videoTracks.append(track);
       break;
   }
   track->registerMediaStream(this);
   m_descriptor->addComponent(component);
 
   scheduleDispatchEvent(
       MediaStreamTrackEvent::create(EventTypeNames::addtrack, track));
 
   if (!active() && !track->ended()) {
     m_descriptor->setActive(true);
     scheduleDispatchEvent(Event::create(EventTypeNames::active));
   }
 }
 
 void MediaStream::removeRemoteTrack(MediaStreamComponent* component) {
   DCHECK(component);
-  if (m_stopped)
+  if (m_executionContext->isContextDestroyed())
     return;
 
   MediaStreamTrackVector* tracks = 0;
   switch (component->source()->type()) {
     case MediaStreamSource::TypeAudio:
       tracks = &m_audioTracks;
       break;
     case MediaStreamSource::TypeVideo:
       tracks = &m_videoTracks;
       break;
@@ skipping 24 matching lines @@
 }
 
 void MediaStream::scheduleDispatchEvent(Event* event) {
   m_scheduledEvents.append(event);
 
   if (!m_scheduledEventTimer.isActive())
     m_scheduledEventTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void MediaStream::scheduledEventTimerFired(TimerBase*) {
-  if (m_stopped)
+  if (m_executionContext->isContextDestroyed())
     return;
 
   HeapVector<Member<Event>> events;
   events.swap(m_scheduledEvents);
 
   HeapVector<Member<Event>>::iterator it = events.begin();
   for (; it != events.end(); ++it)
     dispatchEvent((*it).release());
 
   events.clear();
 }
 
 URLRegistry& MediaStream::registry() const {
   return MediaStreamRegistry::registry();
 }
 
 DEFINE_TRACE(MediaStream) {
   visitor->trace(m_audioTracks);
   visitor->trace(m_videoTracks);
   visitor->trace(m_descriptor);
   visitor->trace(m_scheduledEvents);
+  visitor->trace(m_executionContext);
   EventTargetWithInlineData::trace(visitor);
-  ContextLifecycleObserver::trace(visitor);
   MediaStreamDescriptorClient::trace(visitor);
 }
 
 MediaStream* toMediaStream(MediaStreamDescriptor* descriptor) {
   return static_cast<MediaStream*>(descriptor->client());
 }
 
 }  // namespace blink