Move VTT functionality from TextTrackCue.* to VTTCue.*

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

 /*
  * Copyright (c) 2013, Opera Software ASA. 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 17 matching lines @@
  */
 
 #ifndef VTTCue_h
 #define VTTCue_h
 
 #include "bindings/v8/ScriptWrappable.h"
 #include "core/html/track/TextTrackCue.h"
 
 namespace WebCore {
 
+class Document;
+class ExecutionContext;
+class VTTCue;
+
+// ----------------------------
+
+class VTTCueBox FINAL : public TextTrackCueBox {
+public:
+    static PassRefPtr<VTTCueBox> create(Document& document, VTTCue* cue)
+    {
+        return adoptRef(new VTTCueBox(document, cue));
+    }
+
+    VTTCue* getCue() const { return m_cue; }
+    void applyCSSProperties(const IntSize& videoSize);
+
+protected:
+    VTTCueBox(Document&, VTTCue*);
+
+    virtual RenderObject* createRenderer(RenderStyle*) OVERRIDE;
+
+    VTTCue* m_cue;
+};
+
+// ----------------------------
+
 class VTTCue FINAL : public TextTrackCue, public ScriptWrappable {
 public:
-    static PassRefPtr<VTTCue> create(Document&, double startTime, double endTime, const String& text);
+    static PassRefPtr<VTTCue> create(Document& document, double startTime, double endTime, const String& text)
+    {
+        return adoptRef(new VTTCue(document, startTime, endTime, text));
+    }
+
+    virtual ~VTTCue();
+
+    virtual bool isVTTCue() const OVERRIDE { return true; }
+
+    const String& vertical() const;
+    void setVertical(const String&, ExceptionState&);
+
+    bool snapToLines() const { return m_snapToLines; }
+    void setSnapToLines(bool);
+
+    int line() const { return m_linePosition; }
+    void setLine(int, ExceptionState&);
+
+    int position() const { return m_textPosition; }
+    void setPosition(int, ExceptionState&);
+
+    int size() const { return m_cueSize; }
+    void setSize(int, ExceptionState&);
+
+    const String& align() const;
+    void setAlign(const String&, ExceptionState&);
+
+    const String& text() const { return m_text; }
+    void setText(const String&);
+
+    void parseSettings(const String&);
+
+    PassRefPtr<DocumentFragment> getCueAsHTML();
+    PassRefPtr<DocumentFragment> createCueRenderingTree();
+
+    const String& regionId() const { return m_regionId; }
+    void setRegionId(const String&);
+    virtual void notifyRegionWhenRemovingDisplayTree(bool) OVERRIDE;
+
+    virtual bool hasDisplayTree() const OVERRIDE { return m_displayTree; }
+    virtual PassRefPtr<TextTrackCueBox> getDisplayTree(const IntSize& videoSize) OVERRIDE;
+    virtual PassRefPtr<HTMLDivElement> element() const OVERRIDE { return m_cueBackgroundBox; }
+
+    virtual void updateDisplayTree(double) OVERRIDE;
+    virtual void removeDisplayTree() OVERRIDE;
+    void markFutureAndPastNodes(ContainerNode*, double, double);
+
+    int calculateComputedLinePosition();
+
+    std::pair<double, double> getCSSPosition() const;
+
+    CSSValueID getCSSAlignment() const;
+    int getCSSSize() const;
+    CSSValueID getCSSWritingDirection() const;
+    CSSValueID getCSSWritingMode() const;
+
+    enum WritingDirection {
+        Horizontal = 0,
+        VerticalGrowingLeft,
+        VerticalGrowingRight,
+        NumberOfWritingDirections
+    };
+    WritingDirection getWritingDirection() const { return m_writingDirection; }
+
+    enum CueAlignment {
+        Start = 0,
+        Middle,
+        End,
+        Left,
+        Right,
+        NumberOfAlignments
+    };
+    CueAlignment getAlignment() const { return m_cueAlignment; }
+
+    virtual ExecutionContext* executionContext() const OVERRIDE;
 
 private:
     VTTCue(Document&, double startTime, double endTime, const String& text);
+
+    Document& document() const;
+
+    PassRefPtr<VTTCueBox> displayTreeInternal();
+
+    virtual void cueDidChange() OVERRIDE;
+
+    void createVTTNodeTree();
+    void copyVTTNodeToDOMTree(ContainerNode* VTTNode, ContainerNode* root);
+
+    std::pair<double, double> getPositionCoordinates() const;
+
+    void determineTextDirection();
+    void calculateDisplayParameters();
+
+    enum CueSetting {
+        None,
+        Vertical,
+        Line,
+        Position,
+        Size,
+        Align,
+        RegionId
+    };
+    CueSetting settingName(const String&);
+
+    String m_text;
+    int m_linePosition;
+    int m_computedLinePosition;
+    int m_textPosition;
+    int m_cueSize;
+    WritingDirection m_writingDirection;
+
+    CueAlignment m_cueAlignment;
+
+    RefPtr<DocumentFragment> m_webVTTNodeTree;
+    bool m_snapToLines;
+
+    RefPtr<HTMLDivElement> m_cueBackgroundBox;
+
+    bool m_displayTreeShouldChange;
+    RefPtr<VTTCueBox> m_displayTree;
+
+    CSSValueID m_displayDirection;
+
+    int m_displaySize;
+
+    std::pair<float, float> m_displayPosition;
+    String m_regionId;
+    bool m_notifyRegion;
 };
 
 inline VTTCue* toVTTCue(TextTrackCue* cue)
 {
     // VTTCue is currently the only TextTrackCue subclass.
     return static_cast<VTTCue*>(cue);
 }
 
 } // namespace WebCore
 
 #endif