Support text track selection in video controls

third_party/WebKit/Source/core/html/shadow/MediaControlElements.cpp

Index: third_party/WebKit/Source/core/html/shadow/MediaControlElements.cpp
diff --git a/third_party/WebKit/Source/core/html/shadow/MediaControlElements.cpp b/third_party/WebKit/Source/core/html/shadow/MediaControlElements.cpp
index 5b76bf6d3707991fe1b5bf843422099fec2b5876..22738180d999e3c7b606b89f2431b0998cbf3bd5 100644
--- a/third_party/WebKit/Source/core/html/shadow/MediaControlElements.cpp
+++ b/third_party/WebKit/Source/core/html/shadow/MediaControlElements.cpp
@@ -32,18 +32,26 @@
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/InputTypeNames.h"
 #include "core/dom/ClientRect.h"
+#include "core/dom/Document.h"
+#include "core/dom/Text.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/events/MouseEvent.h"
 #include "core/frame/LocalFrame.h"
+#include "core/html/HTMLLabelElement.h"
+#include "core/html/HTMLSpanElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/TimeRanges.h"
 #include "core/html/shadow/MediaControls.h"
+#include "core/html/track/TextTrackList.h"
 #include "core/input/EventHandler.h"
 #include "core/layout/LayoutSlider.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/LayoutVideo.h"
+#include "platform/EventDispatchForbiddenScope.h"
 #include "platform/Histogram.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "platform/text/PlatformLocale.h"
+#include "public/platform/Platform.h"
 
 namespace blink {
 
@@ -54,6 +62,16 @@ namespace {
 // This is the duration from mediaControls.css
 const double fadeOutDuration = 0.3;
 
+static const QualifiedName& trackIndexAttrName()
+{
+    // Save the track index in an attribute to avoid holding a pointer to the text track element.
+    DEFINE_STATIC_LOCAL(QualifiedName, trackIndexAttr, (nullAtom, "data-track-index", nullAtom));
+    return trackIndexAttr;
+}
+
+// When specified as trackIndex, disable text tracks.
+static const int trackIndexOffValue = -1;
+
 bool isUserInteractionEvent(Event* event)
 {
     const AtomicString& type = event->type();
@@ -353,14 +371,12 @@ void MediaControlToggleClosedCaptionsButtonElement::updateDisplayType()
 {
     bool captionsVisible = mediaElement().closedCaptionsVisible();
     setDisplayType(captionsVisible ? MediaHideClosedCaptionsButton : MediaShowClosedCaptionsButton);
-    setChecked(captionsVisible);
 }
 
 void MediaControlToggleClosedCaptionsButtonElement::defaultEventHandler(Event* event)
 {
     if (event->type() == EventTypeNames::click) {
-        mediaElement().setClosedCaptionsVisible(!mediaElement().closedCaptionsVisible());
-        setChecked(mediaElement().closedCaptionsVisible());
+        mediaControls().toggleTextTrackList();
         updateDisplayType();
         event->setDefaultHandled();
     }
@@ -370,6 +386,147 @@ void MediaControlToggleClosedCaptionsButtonElement::defaultEventHandler(Event* e
 
 // ----------------------------
 
+MediaControlTextTrackListElement::MediaControlTextTrackListElement(MediaControls& mediaControls)
+    : MediaControlDivElement(mediaControls, MediaTextTrackList)
+{
+}
+
+PassRefPtrWillBeRawPtr<MediaControlTextTrackListElement> MediaControlTextTrackListElement::create(MediaControls& mediaControls)
+{
+    RefPtrWillBeRawPtr<MediaControlTextTrackListElement> element =
+        adoptRefWillBeNoop(new MediaControlTextTrackListElement(mediaControls));
+    element->setShadowPseudoId(AtomicString("-internal-media-controls-text-track-list",
+        AtomicString::ConstructFromLiteral));
+    element->setIsWanted(false);
+    return element.release();
+}
+
+void MediaControlTextTrackListElement::defaultEventHandler(Event* event)
+{
+    if (event->type() == EventTypeNames::change) {
+        // Identify which input element was selected and set track to showing
+        Node* target = event->target()->toNode();
+        if (!target || !target->isElementNode())
+            return;
+
+        int trackIndex = toElement(target)->getIntegralAttribute(trackIndexAttrName());
+        disableShowingTextTracks();
+        if (trackIndex != trackIndexOffValue) {
+            showTextTrackAtIndex(trackIndex);
+            mediaElement().disableAutomaticTextTrackSelection();
+        }
+
+        mediaControls().toggleTextTrackList();
+        event->setDefaultHandled();
+    }
+    MediaControlDivElement::defaultEventHandler(event);
+}
+
+void MediaControlTextTrackListElement::displayTextTrackList(bool display)
+{
+    setIsWanted(display);
+}
+
+void MediaControlTextTrackListElement::showTextTrackAtIndex(unsigned indexToEnable)
+{
+    TextTrackList* trackList = mediaElement().textTracks();
+    if (trackList->length() == 0)
+        return;
+    if (indexToEnable >= trackList->length())
+        return;
+    TextTrack* track = trackList->anonymousIndexedGetter(indexToEnable);
+    if (track->canBeRendered())
+        track->setMode(TextTrack::showingKeyword());
+}
+
+void MediaControlTextTrackListElement::disableShowingTextTracks()
+{
+    TextTrackList* trackList = mediaElement().textTracks();
+    for (unsigned i = 0; i < trackList->length(); ++i) {
+        TextTrack* track = trackList->anonymousIndexedGetter(i);
+        if (track->mode() == TextTrack::showingKeyword())
+            track->setMode(TextTrack::disabledKeyword());
+    }
+}
+
+String MediaControlTextTrackListElement::getTextTrackLabel(TextTrack* track)
+{
+    if (!track)
+        return mediaElement().locale().queryString(WebLocalizedString::TextTracksOff);
+
+    String trackLabel = track->label();
+
+    if (trackLabel.isEmpty())
+        trackLabel = track->language();
+
+    if (trackLabel.isEmpty())
+        trackLabel = String(mediaElement().locale().queryString(WebLocalizedString::TextTracksNoLabel));
+
+    return trackLabel;
+}
+
+// TextTrack parameter when passed in as a nullptr, creates the "Off" list item in the track list.
+PassRefPtrWillBeRawPtr<Element> MediaControlTextTrackListElement::createTextTrackListItem(TextTrack* track)
+{
+    Document& document = this->document();
+    int trackIndex = track ? track->trackIndex() : trackIndexOffValue;
+    RefPtrWillBeRawPtr<HTMLLabelElement> trackItem = HTMLLabelElement::create(document, 0);
+    trackItem->setShadowPseudoId(AtomicString("-internal-media-controls-text-track-list-item",
+        AtomicString::ConstructFromLiteral));
+    RefPtrWillBeRawPtr<HTMLInputElement> trackItemInput = HTMLInputElement::create(document, 0, false);
+    trackItemInput->setShadowPseudoId(AtomicString("-internal-media-controls-text-track-list-item-input",
+        AtomicString::ConstructFromLiteral));
+    trackItemInput->setType(InputTypeNames::radio);
+    trackItemInput->setIntegralAttribute(trackIndexAttrName(), trackIndex);
+    if (!mediaElement().closedCaptionsVisible()) {
+        if (!track)
+            trackItemInput->setChecked(true);
+    } else {
+        // If there are multiple text tracks set to showing, they must all have
+        // checkmarks displayed.
+        if (track && track->mode() == TextTrack::showingKeyword())
+            trackItemInput->setChecked(true);
+    }
+    RefPtrWillBeRawPtr<HTMLSpanElement> trackKindMarker = HTMLSpanElement::create(document);
+    if (track && track->kind() == track->captionsKeyword()) {
+        trackKindMarker->setShadowPseudoId(AtomicString("-internal-media-controls-text-track-list-kind-captions",
+            AtomicString::ConstructFromLiteral));
+    } else if (track && track->kind() == track->subtitlesKeyword()) {
+        trackKindMarker->setShadowPseudoId(AtomicString("-internal-media-controls-text-track-list-kind-subtitles",
+            AtomicString::ConstructFromLiteral));
+    }
+    trackItem->appendChild(trackItemInput);
+    trackItem->appendChild(Text::create(document, getTextTrackLabel(track)));
+    trackItem->appendChild(trackKindMarker);
+    return trackItem;
+}
+
+void MediaControlTextTrackListElement::refreshTextTrackListMenu()
+{
+    if (!mediaElement().hasClosedCaptions() || !mediaElement().textTracksAreReady())
+        return;
+
+    removeChildren(OmitSubtreeModifiedEvent);
+
+    // Construct a menu for subtitles and captions
+    EventDispatchForbiddenScope::AllowUserAgentEvents allowEvents;

[fs, 2016/02/24 10:14:57]

What events are you seeing here? It'd really be preferable to have a "plain"
EventDispatchForbiddenScope here.

[srivats, 2016/02/25 21:47:56]

Can't remember why this was needed in the first place. I think I was seeing a
DCHECK fail and I added this a long time ago.
Doesn't look like it's needed anymore.

[fs, 2016/02/25 22:06:48]

Ok, I'd suggest adding a "EventDispatchForbiddenScope assertNoEventDispatch;"
instead then (before the removeChildren even.)

[srivats, 2016/02/25 22:28:36]

Adding that causes an assertion failure in Node::dispatchSubtreeModifiedEvent()
when I try to setAttribute on tracksSection element in this method.
Wouldn't assertNoEventDispatch prevent all events?

[fs, 2016/02/26 09:09:12]

No, it will do nothing more than assert. It generally a good thing
(==preferable) to avoid generating events in these cases. If we can't avoid
that, then you should re-add the AllowUserAgentEvents "scope" and document what
it allows and why it is safe (in this presumably safe because this is a closed
shadow root and there should be event listeners attached.)

+    RefPtrWillBeRawPtr<HTMLDivElement> tracksSection = HTMLDivElement::create(this->document());
+    tracksSection->setAttribute(roleAttr, radiogroupAttr.localName());
+    // Pass in a nullptr to createTextTrackListItem to create the "Off" track item.
+    tracksSection->appendChild(createTextTrackListItem(nullptr));
+
+    TextTrackList* trackList = mediaElement().textTracks();
+    for (unsigned i = 0; i < trackList->length(); i++) {
+        TextTrack* track = trackList->anonymousIndexedGetter(i);
+        if (!track->canBeRendered())
+            continue;
+        tracksSection->appendChild(createTextTrackListItem(track));
+    }
+    appendChild(tracksSection);
+}
+
+// ----------------------------
+
 MediaControlTimelineElement::MediaControlTimelineElement(MediaControls& mediaControls)
     : MediaControlInputElement(mediaControls, MediaSlider)
 {