Oilpan: add transition types to track interface objects.

Source/core/html/track/TextTrackList.cpp

 /*
  * Copyright (C) 2011, 2012 Apple 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 30 matching lines @@
     , m_asyncEventQueue(GenericEventQueue::create(this))
 {
     ScriptWrappable::init(this);
 }
 
 TextTrackList::~TextTrackList()
 {
     ASSERT(!m_owner);
 
     m_asyncEventQueue->close();
+}
 
+void TextTrackList::dispose()

[Mads Ager (chromium), 2014/04/22 10:33:25]

Do we need this with oilpan at all? Can't all the pointers be strong pointers
here? In that case you never have to clear them and this can stay in the
destructor and be #ifdef'd out in the oilpan build.

[haraken, 2014/04/22 10:40:03]

This dispose() is needed to explicitly call InbandTextTrack::setTrackList. See
https://codereview.chromium.org/244493002/diff/20001/Source/core/html/track/T...

[sof, 2014/04/22 10:43:43]

Yes, the only reason for explicitly clearing.

[Mads Ager (chromium), 2014/04/22 10:55:04]

I'm still not sure I understand why we cannot simplify. :)

We will have to do it differently since this dispose is called from a
destructor, right? In this version of the code you are calling through a
Persistent so this will work. However, that Persistent should be a Member and at
that point all of this can be dead at the same time.

These objects are exposed to JavaScript, right? In that case, the destruction of
these are already determined by when we get a garbage collection and in that
sense we will not introduce anything new, these calls of setTrackList(0) are
delayed until GC on the JS side anyway.

If we use strong pointers in all directions, we know that the TextTrack dies
together with its text track list (unless it has been explicitly removed). In
both cases (explicit removal and when the TextTrack itself dies) it can notify
the client?

+{
+    m_owner = 0;
     for (unsigned i = 0; i < length(); ++i) {
         item(i)->setTrackList(0);
     }
 }
 
 unsigned TextTrackList::length() const
 {
     return m_addTrackTracks.size() + m_elementTracks.size() + m_inbandTracks.size();
 }
 
@@ skipping 84 matching lines @@
         if (track->id() == id)
             return track;
     }
 
     // When no tracks match the given argument, the method must return null.
     return 0;
 }
 
 void TextTrackList::invalidateTrackIndexesAfterTrack(TextTrack* track)
 {
-    Vector<RefPtr<TextTrack> >* tracks = 0;
+    WillBeHeapVector<RefPtrWillBeMember<TextTrack> >* tracks = 0;
 
     if (track->trackType() == TextTrack::TrackElement) {
         tracks = &m_elementTracks;
         for (size_t i = 0; i < m_addTrackTracks.size(); ++i)
             m_addTrackTracks[i]->invalidateTrackIndex();
         for (size_t i = 0; i < m_inbandTracks.size(); ++i)
             m_inbandTracks[i]->invalidateTrackIndex();
     } else if (track->trackType() == TextTrack::AddTrack) {
         tracks = &m_addTrackTracks;
         for (size_t i = 0; i < m_inbandTracks.size(); ++i)
             m_inbandTracks[i]->invalidateTrackIndex();
     } else if (track->trackType() == TextTrack::InBand)
         tracks = &m_inbandTracks;
     else
         ASSERT_NOT_REACHED();
 
     size_t index = tracks->find(track);
     if (index == kNotFound)
         return;
 
     for (size_t i = index; i < tracks->size(); ++i)
         tracks->at(index)->invalidateTrackIndex();
 }
 
-void TextTrackList::append(PassRefPtr<TextTrack> prpTrack)
+void TextTrackList::append(PassRefPtrWillBeRawPtr<TextTrack> prpTrack)
 {
-    RefPtr<TextTrack> track = prpTrack;
+    RefPtrWillBeRawPtr<TextTrack> track = prpTrack;
 
     if (track->trackType() == TextTrack::AddTrack)
         m_addTrackTracks.append(track);
     else if (track->trackType() == TextTrack::TrackElement) {
         // Insert tracks added for <track> element in tree order.
         size_t index = static_cast<LoadableTextTrack*>(track.get())->trackElementIndex();
         m_elementTracks.insert(index, track);
     } else if (track->trackType() == TextTrack::InBand) {
         // Insert tracks added for in-band in the media file order.
         size_t index = static_cast<InbandTextTrack*>(track.get())->inbandTrackIndex();
         m_inbandTracks.insert(index, track);
     } else
         ASSERT_NOT_REACHED();
 
     invalidateTrackIndexesAfterTrack(track.get());
 
     ASSERT(!track->trackList());
     track->setTrackList(this);
 
     scheduleAddTrackEvent(track.release());
 }
 
 void TextTrackList::remove(TextTrack* track)
 {
-    Vector<RefPtr<TextTrack> >* tracks = 0;
+    WillBeHeapVector<RefPtrWillBeMember<TextTrack> >* tracks = 0;
 
     if (track->trackType() == TextTrack::TrackElement) {
         tracks = &m_elementTracks;
     } else if (track->trackType() == TextTrack::AddTrack) {
         tracks = &m_addTrackTracks;
     } else if (track->trackType() == TextTrack::InBand) {
         tracks = &m_inbandTracks;
     } else {
         ASSERT_NOT_REACHED();
     }
@@ skipping 15 matching lines @@
 void TextTrackList::removeAllInbandTracks()
 {
     for (unsigned i = 0; i < m_inbandTracks.size(); ++i) {
         m_inbandTracks[i]->setTrackList(0);
     }
     m_inbandTracks.clear();
 }
 
 bool TextTrackList::contains(TextTrack* track) const
 {
-    const Vector<RefPtr<TextTrack> >* tracks = 0;
+    const WillBeHeapVector<RefPtrWillBeMember<TextTrack> >* tracks = 0;
 
     if (track->trackType() == TextTrack::TrackElement)
         tracks = &m_elementTracks;
     else if (track->trackType() == TextTrack::AddTrack)
         tracks = &m_addTrackTracks;
     else if (track->trackType() == TextTrack::InBand)
         tracks = &m_inbandTracks;
     else
         ASSERT_NOT_REACHED();
 
     return tracks->find(track) != kNotFound;
 }
 
 const AtomicString& TextTrackList::interfaceName() const
 {
     return EventTargetNames::TextTrackList;
 }
 
 ExecutionContext* TextTrackList::executionContext() const
 {
     ASSERT(m_owner);
     return m_owner->executionContext();
 }
 
-void TextTrackList::clearOwner()
-{
-    m_owner = 0;
-}
-
-void TextTrackList::scheduleTrackEvent(const AtomicString& eventName, PassRefPtr<TextTrack> track)
+void TextTrackList::scheduleTrackEvent(const AtomicString& eventName, PassRefPtrWillBeRawPtr<TextTrack> track)
 {
     TrackEventInit initializer;
     initializer.track = track;
     initializer.bubbles = false;
     initializer.cancelable = false;
 
     m_asyncEventQueue->enqueueEvent(TrackEvent::create(eventName, initializer));
 }
 
-void TextTrackList::scheduleAddTrackEvent(PassRefPtr<TextTrack> track)
+void TextTrackList::scheduleAddTrackEvent(PassRefPtrWillBeRawPtr<TextTrack> track)
 {
     // 4.8.10.12.3 Sourcing out-of-band text tracks
     // 4.8.10.12.4 Text track API
     // ... then queue a task to fire an event with the name addtrack, that does not
     // bubble and is not cancelable, and that uses the TrackEvent interface, with
     // the track attribute initialized to the text track's TextTrack object, at
     // the media element's textTracks attribute's TextTrackList object.
     scheduleTrackEvent(EventTypeNames::addtrack, track);
 }
 
 void TextTrackList::scheduleChangeEvent()
 {
     // 4.8.10.12.1 Text track model
     // Whenever a text track that is in a media element's list of text tracks
     // has its text track mode change value, the user agent must run the
     // following steps for the media element:
     // ...
     // Fire a simple event named change at the media element's textTracks
     // attribute's TextTrackList object.
 
     EventInit initializer;
     initializer.bubbles = false;
     initializer.cancelable = false;
 
     m_asyncEventQueue->enqueueEvent(Event::create(EventTypeNames::change, initializer));
 }
 
-void TextTrackList::scheduleRemoveTrackEvent(PassRefPtr<TextTrack> track)
+void TextTrackList::scheduleRemoveTrackEvent(PassRefPtrWillBeRawPtr<TextTrack> track)
 {
     // 4.8.10.12.3 Sourcing out-of-band text tracks
     // When a track element's parent element changes and the old parent was a
     // media element, then the user agent must remove the track element's
     // corresponding text track from the media element's list of text tracks,
     // and then queue a task to fire a trusted event with the name removetrack,
     // that does not bubble and is not cancelable, and that uses the TrackEvent
     // interface, with the track attribute initialized to the text track's
     // TextTrack object, at the media element's textTracks attribute's
     // TextTrackList object.
     scheduleTrackEvent(EventTypeNames::removetrack, track);
 }
 
 HTMLMediaElement* TextTrackList::owner() const
 {
     return m_owner;
 }
+
+void TextTrackList::trace(Visitor* visitor)
+{
+    visitor->trace(m_addTrackTracks);
+    visitor->trace(m_elementTracks);
+    visitor->trace(m_inbandTracks);
+}