WebVTT: Support 'auto' text position

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 18 matching lines @@
 
 #ifndef VTTCue_h
 #define VTTCue_h
 
 #include "core/html/track/TextTrackCue.h"
 #include "platform/heap/Handle.h"
 
 namespace blink {
 
 class Document;
+class DoubleOrString;
 class ExecutionContext;
 class VTTCue;
 class VTTScanner;
 
 class VTTCueBox final : public HTMLDivElement {
 public:
     static PassRefPtrWillBeRawPtr<VTTCueBox> create(Document& document, VTTCue* cue)
     {
         return adoptRefWillBeNoop(new VTTCueBox(document, cue));
     }
@@ skipping 23 matching lines @@
 
     const String& vertical() const;
     void setVertical(const String&);
 
     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&);
+    void position(DoubleOrString&) const;
+    void setPosition(const DoubleOrString&, ExceptionState&);
 
     int size() const { return m_cueSize; }
     void setSize(int, ExceptionState&);
 
     const String& align() const;
     void setAlign(const String&);
 
     const String& text() const { return m_text; }
     void setText(const String&);
 
@@ skipping 57 matching lines @@
     PassRefPtrWillBeRawPtr<VTTCueBox> getDisplayTree(const IntSize& videoSize);
 
     virtual void cueDidChange() override;
 
     void createVTTNodeTree();
     void copyVTTNodeToDOMTree(ContainerNode* vttNode, ContainerNode* root);
 
     std::pair<double, double> getPositionCoordinates() const;
 
     void calculateDisplayParameters();
+    int calculateComputedTextPosition() const;
+    bool textPositionIsAuto() const;
 
     enum CueSetting {
         None,
         Vertical,
         Line,
         Position,
         Size,
         Align,
         RegionId
     };
     CueSetting settingName(VTTScanner&);
 
     String m_text;
     int m_linePosition;
     int m_computedLinePosition;
-    int m_textPosition;
+    float m_textPosition;

[philipj_slow, 2015/01/15 09:08:57]

Can you add a test that sets position to a value that can't be represented as
float and test which value is read back? I guess sneaky double->float is already
exposed to the Web a lot via CSSOM?

[fs, 2015/01/15 10:07:16]

Are you saying that you want me to convert this to double, or just a test that
verifies that round-tripping doesn't work? (99.100001 would be an example -
which also kind of illustrates the sillyness IMHO... that doesn't round-trip
exactly for doubles either though of course)

[philipj_slow, 2015/01/19 14:44:26]

I don't know what I want, in
https://www.w3.org/Bugs/Public/show_bug.cgi?id=19836#c8 I was worried about the
size and now I'm worried about the difference between float and double being
observable...

What do you think? double wherever obvserable and float for layout would be OK,
but it's quite pedantic and assume that CSSOM has the exact same "problem". I'll
sit on the fence and let you decide!

[fs, 2015/01/19 15:09:05]

I've gone with floats for now and added a test as "documentation" - will land
that separately (as requested elsewhere). I think it would be impossible to
avoid detection (you can always, say, add another 0 after the decimal point),
and wasting 12-16 bytes (~5% of VTTCue) on precision...
I'm considering splitting out display-state from VTTCue and allocate that
on-demand - maybe then the growth could be hidden in the reduction.

     int m_cueSize;
     WritingDirection m_writingDirection;
     CueAlignment m_cueAlignment;
     String m_regionId;
 
     RefPtrWillBeMember<DocumentFragment> m_vttNodeTree;
     RefPtrWillBeMember<HTMLDivElement> m_cueBackgroundBox;
     RefPtrWillBeMember<VTTCueBox> m_displayTree;
 
     CSSValueID m_displayDirection;
     int m_displaySize;
     std::pair<float, float> m_displayPosition;
 
     bool m_snapToLines : 1;
     bool m_displayTreeShouldChange : 1;
     bool m_notifyRegion : 1;
 };
 
 // VTTCue is currently the only TextTrackCue subclass.
 DEFINE_TYPE_CASTS(VTTCue, TextTrackCue, cue, true, true);
 
 } // namespace blink
 
 #endif // VTTCue_h