Oilpan: add transition types to track interface objects.

Source/core/html/track/vtt/VTTParser.h

 /*
  * Copyright (C) 2011 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 21 matching lines @@
 #define VTTParser_h
 
 #include "HTMLNames.h"
 #include "RuntimeEnabledFeatures.h"
 #include "core/dom/DocumentFragment.h"
 #include "core/html/parser/TextResourceDecoder.h"
 #include "core/html/track/vtt/BufferedLineReader.h"
 #include "core/html/track/vtt/VTTCue.h"
 #include "core/html/track/vtt/VTTRegion.h"
 #include "core/html/track/vtt/VTTTokenizer.h"
+#include "platform/heap/Handle.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace WebCore {
 
 class Document;
 class VTTScanner;
 
 class VTTParserClient {
 public:
     virtual ~VTTParserClient() { }
 
     virtual void newCuesParsed() = 0;
     virtual void newRegionsParsed() = 0;
     virtual void fileFailedToParse() = 0;
 };
 
-class VTTParser FINAL {
+class VTTParser FINAL : public NoBaseWillBeGarbageCollectedFinalized<VTTParser> {
 public:
     enum ParseState {
         Initial,
         Header,
         Id,
         TimingsAndSettings,
         CueText,
         BadCue
     };
 
-    static PassOwnPtr<VTTParser> create(VTTParserClient* client, Document& document)
+    static PassOwnPtrWillBeRawPtr<VTTParser> create(VTTParserClient* client, Document& document)
     {
-        return adoptPtr(new VTTParser(client, document));
+        return adoptPtrWillBeNoop(new VTTParser(client, document));
     }
 
     static inline bool isRecognizedTag(const AtomicString& tagName)
     {
         return tagName == HTMLNames::iTag
             || tagName == HTMLNames::bTag
             || tagName == HTMLNames::uTag
             || tagName == HTMLNames::rubyTag
             || tagName == HTMLNames::rtTag;
     }
@@ skipping 15 matching lines @@
     static bool parseFloatPercentageValuePair(VTTScanner&, char, FloatPoint&);
 
     // Create the DocumentFragment representation of the WebVTT cue text.
     static PassRefPtr<DocumentFragment> createDocumentFragmentFromCueText(Document&, const String&);
 
     // Input data to the parser to parse.
     void parseBytes(const char* data, unsigned length);
     void flush();
 
     // Transfers ownership of last parsed cues to caller.
-    void getNewCues(Vector<RefPtr<VTTCue> >&);
-    void getNewRegions(Vector<RefPtr<VTTRegion> >&);
+    void getNewCues(WillBeHeapVector<RefPtrWillBeMember<VTTCue> >&);
+    void getNewRegions(WillBeHeapVector<RefPtrWillBeMember<VTTRegion> >&);
+
+    void trace(Visitor*);
 
 private:
     VTTParser(VTTParserClient*, Document&);
 
     Document* m_document;

[haraken, 2014/04/21 01:30:54]

Let me confirm: The VTTParser object can outlive the document (because both the
VTTParser object and the document are on-heap), but it's not possible that
methods of the VTTParser object are called after the document dies (because the
VTTParser object is owned by the client object, and the client object doesn't
outlive the document). Thus using a raw pointer for m_document is safe. Is my
understanding correct?

Nit: I'd change Document* to Document&.

[sof, 2014/04/21 15:23:42]

The client object is owned by a media element (by way of a text track and a text
track list). The media element will not outlive its document. 

     ParseState m_state;
 
     void parse();
     void flushPendingCue();
     bool hasRequiredFileIdentifier(const String& line);
     ParseState collectCueId(const String&);
     ParseState collectTimingsAndSettings(const String&);
     ParseState collectCueText(const String&);
     ParseState recoverCue(const String&);
     ParseState ignoreBadCue(const String&);
 
     void createNewCue();
     void resetCueValues();
 
     void collectMetadataHeader(const String&);
     void createNewRegion(const String& headerValue);
 
     static bool collectTimeStamp(VTTScanner& input, double& timeStamp);
 
     BufferedLineReader m_lineReader;
     OwnPtr<TextResourceDecoder> m_decoder;
     AtomicString m_currentId;
     double m_currentStartTime;
     double m_currentEndTime;
     StringBuilder m_currentContent;
     String m_currentSettings;
 
     VTTParserClient* m_client;

[haraken, 2014/04/21 01:30:54]

Let me confirm: The VTTParser object can outlive the client object (because the
VTTParser object is on-heap but the client object is off-heap), but it's not
possible that methods of the VTTParser object are called after the client object
dies (because the VTTParser object is owned by the client). Thus using a raw
pointer for m_client is safe here. Right?

[sof, 2014/04/21 15:23:42]

That is correct; TextTrackLoader is the only client, and it keeps a persistent
reference to VTTParser. Hence, it is simply not possible for the VTTParser to be
accessed after the loader (==client) goes away.

Actually, we can do better and avoid this persistent reference -- I had
overlooked that LoadableTextTrack (TextTrackLoader's only owner) is also a GCed
object, so we can move the loader to the heap also. Updated patch to do so.

 
-    Vector<RefPtr<VTTCue> > m_cuelist;
+    WillBeHeapVector<RefPtrWillBeMember<VTTCue> > m_cueList;
 
-    Vector<RefPtr<VTTRegion> > m_regionList;
+    WillBeHeapVector<RefPtrWillBeMember<VTTRegion> > m_regionList;
 };
 
 } // namespace WebCore
 
 #endif