Support text track selection in video controls

Source/core/html/shadow/MediaControlElements.cpp

 /*
  * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2012 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 15 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/html/shadow/MediaControlElements.h"
 
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/InputTypeNames.h"
 #include "core/dom/DOMTokenList.h"
+#include "core/dom/Document.h"
+#include "core/dom/Element.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/HTMLVideoElement.h"
 #include "core/html/MediaController.h"
 #include "core/html/TimeRanges.h"
 #include "core/html/shadow/MediaControls.h"
+#include "core/html/track/TextTrackList.h"
 #include "core/layout/LayoutSlider.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/LayoutVideo.h"
 #include "core/page/EventHandler.h"
+#include "platform/EventDispatchForbiddenScope.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "platform/text/PlatformLocale.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 // This is the duration from mediaControls.css
 static const double fadeOutDuration = 0.3;
 
+// track index attribute specifies trackIndex for text track list elements
+static const char trackIndexAttr[] = "x-webkit-track-index";
+
+// when specified as trackIndex, disable text tracks
+static const int trackIndexOffValue = -1;
+
 static bool isUserInteractionEvent(Event* event)
 {
     const AtomicString& type = event->type();
     return type == EventTypeNames::mousedown
         || type == EventTypeNames::mouseup
         || type == EventTypeNames::click
         || type == EventTypeNames::dblclick
         || event->isKeyboardEvent()
         || event->isTouchEvent();
 }
@@ skipping 268 matching lines @@
     button->setType(InputTypeNames::button);
     button->setShadowPseudoId(AtomicString("-webkit-media-controls-toggle-closed-captions-button", AtomicString::ConstructFromLiteral));
     button->hide();
     return button.release();
 }
 
 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();
     }
 
     HTMLInputElement::defaultEventHandler(event);
 }
 
 // ----------------------------
 
+MediaControlTextTrackListContainerElement::MediaControlTextTrackListContainerElement(MediaControls& mediaControls)
+    : MediaControlDivElement(mediaControls, MediaTextTrackListContainer)
+{
+}
+
+PassRefPtrWillBeRawPtr<MediaControlTextTrackListContainerElement>
+    MediaControlTextTrackListContainerElement::create(MediaControls& mediaControls)
+{
+    RefPtrWillBeRawPtr<MediaControlTextTrackListContainerElement> element =
+        adoptRefWillBeNoop(new MediaControlTextTrackListContainerElement(mediaControls));
+    element->setShadowPseudoId(AtomicString("-webkit-media-controls-text-track-list-container",
+        AtomicString::ConstructFromLiteral));
+    element->hide();
+    return element.release();
+}
+
+// ----------------------------
+
+MediaControlTextTrackListElement::MediaControlTextTrackListElement(MediaControls& mediaControls)
+    : MediaControlDivElement(mediaControls, MediaTextTrackList)
+{
+}
+
+PassRefPtrWillBeRawPtr<MediaControlTextTrackListElement> MediaControlTextTrackListElement::create(MediaControls& mediaControls)
+{
+    RefPtrWillBeRawPtr<MediaControlTextTrackListElement> element =
+        adoptRefWillBeNoop(new MediaControlTextTrackListElement(mediaControls));
+    element->setShadowPseudoId(AtomicString("-webkit-media-controls-text-track-list",
+        AtomicString::ConstructFromLiteral));
+    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;
+
+        bool validIndex;
+        int trackIndex = toElement(target)->getAttribute(trackIndexAttr).toInt(&validIndex);
+        if (!validIndex)
+            return;
+        if (trackIndex != trackIndexOffValue) {
+            showTextTrackAtIndex(trackIndex);
+            mediaElement().setClosedCaptionsVisible(true);
+        } else {
+            mediaElement().setClosedCaptionsVisible(false);
+        }
+
+        mediaControls().toggleTextTrackList();
+        event->setDefaultHandled();
+    }
+    HTMLDivElement::defaultEventHandler(event);
+}
+
+void MediaControlTextTrackListElement::showTextTrackAtIndex(unsigned index)
+{
+    TextTrackList* trackList = mediaElement().textTracks();
+    for (unsigned i = 0; i < trackList->length(); ++i) {
+        TextTrack* track = trackList->item(i);
+        if (track->mode() == TextTrack::showingKeyword())
+            track->setMode(TextTrack::disabledKeyword());
+    }
+
+    if (index < trackList->length()) {
+        trackList->item(index)->setMode(TextTrack::showingKeyword());
+        mediaElement().setAutomaticTextTrackSelection(false);
+    }
+}
+
+String MediaControlTextTrackListElement::getTextTrackLabel(TextTrack* track)
+{
+    String trackLabel = track->label();
+
+    if (trackLabel.isEmpty())
+        trackLabel = track->language();
+
+    if (trackLabel.isEmpty())
+        trackLabel = String(mediaElement().locale().queryString(WebLocalizedString::TextTracksNoLabel));
+
+    // When the track kind is captions, add a captions marker to distinguish between captions and subtitles.
+    if (track->kind() == track->captionsKeyword())
+        trackLabel.append(mediaElement().locale().queryString(WebLocalizedString::TextTracksCaptionsMarker));
+    return trackLabel;
+}
+
+RefPtrWillBeRawPtr<Element> MediaControlTextTrackListElement::createTextTrackListItem(const String& trackDisplayText, int trackIndex, bool isShowing)
+{
+    Document& document = this->document();
+    RefPtrWillBeRawPtr<Element> trackItem = document.createElement(labelTag, false);
+    trackItem->setShadowPseudoId(AtomicString("-webkit-media-controls-text-track-list-item",
+        AtomicString::ConstructFromLiteral));
+    RefPtrWillBeRawPtr<Element> trackItemInput = document.createElement(inputTag, false);
+    trackItemInput->setShadowPseudoId(AtomicString("-webkit-media-controls-text-track-list-item-input",
+        AtomicString::ConstructFromLiteral));
+    trackItemInput->setAttribute(typeAttr, InputTypeNames::radio);
+    trackItemInput->setAttribute(nameAttr, AtomicString("tracks", AtomicString::ConstructFromLiteral));
+    trackItemInput->setAttribute(trackIndexAttr, AtomicString::number(trackIndex), ASSERT_NO_EXCEPTION);
+    if (!mediaElement().closedCaptionsVisible()) {
+        if (trackIndex == trackIndexOffValue)
+            toHTMLInputElement(trackItemInput)->setChecked(true);
+    } else {
+        if (trackIndex >= 0 && isShowing)
+            toHTMLInputElement(trackItemInput)->setChecked(true);
+    }
+    trackItem->appendChild(trackItemInput);
+    trackItem->appendChild(document.createTextNode(trackDisplayText));
+    return trackItem;
+}
+
+void MediaControlTextTrackListElement::refreshTextTrackListMenu()
+{
+    DEFINE_STATIC_LOCAL(const AtomicString, tracksSectionId, ("tracks-header", AtomicString::ConstructFromLiteral));
+    if (!mediaElement().hasClosedCaptions() || !mediaElement().textTracksAreReady())
+        return;
+
+    removeChildren();
+
+    // Construct a menu for subtitles and captions
+    EventDispatchForbiddenScope::AllowUserAgentEvents allowEvents;
+    Document& document = this->document();
+    RefPtrWillBeRawPtr<Element> tracksHeader = document.createElement(h3Tag, false);
+    tracksHeader->setShadowPseudoId(AtomicString("-webkit-media-controls-text-track-list-header",
+        AtomicString::ConstructFromLiteral));
+    RefPtrWillBeRawPtr<Element> tracksSection = document.createElement(divTag, false);
+
+    tracksHeader->appendChild(document.createTextNode(mediaElement().locale().queryString(WebLocalizedString::TextTracksSubtitlesCC)));
+    tracksHeader->setAttribute(idAttr, tracksSectionId);
+    tracksSection->setAttribute(roleAttr, radiogroupAttr.localName());
+    tracksSection->setAttribute(aria_labeledbyAttr, tracksSectionId);
+
+    String textTracksOffLabel = mediaElement().locale().queryString(WebLocalizedString::TextTracksOff);
+    tracksSection->appendChild(createTextTrackListItem(textTracksOffLabel, trackIndexOffValue, false));
+
+    TextTrackList* trackList = mediaElement().textTracks();
+    for (unsigned i = 0; i < trackList->length(); i++) {
+        TextTrack* track = trackList->item(i);
+        RefPtrWillBeRawPtr<Element> trackItem =
+            createTextTrackListItem(getTextTrackLabel(track), i, track->mode() == TextTrack::showingKeyword());
+        tracksSection->appendChild(trackItem);
+    }
+    appendChild(tracksHeader);
+    appendChild(tracksSection);
+}
+
+// ----------------------------
+
 MediaControlTimelineElement::MediaControlTimelineElement(MediaControls& mediaControls)
     : MediaControlInputElement(mediaControls, MediaSlider)
 {
 }
 
 PassRefPtrWillBeRawPtr<MediaControlTimelineElement> MediaControlTimelineElement::create(MediaControls& mediaControls)
 {
     RefPtrWillBeRawPtr<MediaControlTimelineElement> timeline = adoptRefWillBeNoop(new MediaControlTimelineElement(mediaControls));
     timeline->ensureClosedShadowRoot();
     timeline->setType(InputTypeNames::range);
@@ skipping 234 matching lines @@
 }
 
 PassRefPtrWillBeRawPtr<MediaControlCurrentTimeDisplayElement> MediaControlCurrentTimeDisplayElement::create(MediaControls& mediaControls)
 {
     RefPtrWillBeRawPtr<MediaControlCurrentTimeDisplayElement> element = adoptRefWillBeNoop(new MediaControlCurrentTimeDisplayElement(mediaControls));
     element->setShadowPseudoId(AtomicString("-webkit-media-controls-current-time-display", AtomicString::ConstructFromLiteral));
     return element.release();
 }
 
 } // namespace blink