Hook up Android closed captions 'enabled' setting to Blink

Source/core/html/track/AutomaticTrackSelection.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/html/track/AutomaticTrackSelection.h"
 
 #include "core/html/track/TextTrack.h"
 #include "core/html/track/TextTrackList.h"
 #include "platform/Language.h"
 
 namespace blink {
 
 class TrackGroup {
     STACK_ALLOCATED();
 public:
     enum GroupKind {
-        CaptionsAndSubtitles,
+        Captions,
+        Subtitles,
         Description,
         Chapter,
         Metadata
     };
 
     explicit TrackGroup(GroupKind kind)
         : visibleTrack(nullptr)
         , defaultTrack(nullptr)
         , kind(kind)
         , hasSrcLang(false)
@@ skipping 24 matching lines @@
 {
     if (track.kind() != TextTrack::captionsKeyword() && track.kind() != TextTrack::subtitlesKeyword())
         return 0;
 
     return textTrackLanguageSelectionScore(track);
 }
 
 AutomaticTrackSelection::AutomaticTrackSelection(const Configuration& configuration)
     : m_configuration(configuration)
 {
+    fallbackCaptionOrSubtitleTrack = nullptr;

[fs, 2015/06/23 09:23:58]

Do this in the initializer list instead.

[srivats, 2015/06/24 01:40:19]

Done.

 }
 
-void AutomaticTrackSelection::performAutomaticTextTrackSelection(const TrackGroup& group)
+RefPtrWillBeRawPtr<TextTrack> AutomaticTrackSelection::performAutomaticTextTrackSelection(const TrackGroup& group)
 {
     ASSERT(group.tracks.size());
 
     // First, find the track in the group that should be enabled (if any).
     WillBeHeapVector<RefPtrWillBeMember<TextTrack>> currentlyEnabledTracks;
-    RefPtrWillBeRawPtr<TextTrack> trackToEnable = nullptr;
+    RefPtrWillBeRawPtr<TextTrack> preferredTrack = nullptr;
     RefPtrWillBeRawPtr<TextTrack> defaultTrack = nullptr;
-    RefPtrWillBeRawPtr<TextTrack> fallbackTrack = nullptr;
+
     int highestTrackScore = 0;
+    int highestDefaultTrackScore = 0;
+
     for (size_t i = 0; i < group.tracks.size(); ++i) {
         RefPtrWillBeRawPtr<TextTrack> textTrack = group.tracks[i];
 
         if (m_configuration.disableCurrentlyEnabledTracks && textTrack->mode() == TextTrack::showingKeyword())
             currentlyEnabledTracks.append(textTrack);
 
         int trackScore = textTrackSelectionScore(*textTrack);
         if (trackScore) {
-            // * If the text track kind is { [subtitles or captions] [descriptions] } and the user has indicated an interest in having a
+            // * If the text track kind is subtitles or captions and the user has indicated an interest in having a
             // track with this text track kind, text track language, and text track label enabled, and there is no
             // other text track in the media element's list of text tracks with a text track kind of either subtitles
             // or captions whose text track mode is showing
-            // ...
-            // * If the text track kind is chapters and the text track language is one that the user agent has reason
-            // to believe is appropriate for the user, and there is no other text track in the media element's list of
-            // text tracks with a text track kind of chapters whose text track mode is showing
             //    Let the text track mode be showing.
+
             if (trackScore > highestTrackScore) {
+                preferredTrack = textTrack;
                 highestTrackScore = trackScore;
-                trackToEnable = textTrack;
+                fallbackCaptionOrSubtitleTrack = textTrack;
             }
-
-            if (!defaultTrack && textTrack->isDefault())
+            // Keep track of the highest scoring default track
+            if (trackScore > highestDefaultTrackScore && textTrack->isDefault()) {

[fs, 2015/06/23 09:23:58]

I don't think there's a need to track score for 'default' tracks - the old way
of doing it is probably fine.

I think the spec [1] says that all 'default' tracks should be enabled, but we
can probably keep the "first 'default'" behavior for now.

(I also think that's been done already in the "gather" phase of perform().)

[1] https://html.spec.whatwg.org/#perform-automatic-text-track-selection

[srivats, 2015/06/24 01:40:19]

Done.

+                highestDefaultTrackScore = trackScore;
                 defaultTrack = textTrack;
-            if (!defaultTrack && !fallbackTrack)
-                fallbackTrack = textTrack;
+            }
         } else if (!group.visibleTrack && !defaultTrack && textTrack->isDefault()) {
             // * If the track element has a default attribute specified, and there is no other text track in the media
             // element's list of text tracks whose text track mode is showing or showing by default
             //    Let the text track mode be showing by default.
             defaultTrack = textTrack;
         }
     }
 
-    if (!trackToEnable && defaultTrack)
-        trackToEnable = defaultTrack;
-
-    // If no track matches the user's preferred language and non was marked 'default', enable the first track
-    // because the user has explicitly stated a preference for this kind of track.
-    if (!fallbackTrack && m_configuration.forceEnableSubtitleOrCaptionTrack && group.kind == TrackGroup::CaptionsAndSubtitles)
-        fallbackTrack = group.tracks[0];
-
-    if (!trackToEnable && fallbackTrack)
-        trackToEnable = fallbackTrack;
+    if (!preferredTrack && defaultTrack)
+        preferredTrack = defaultTrack;
 
     if (currentlyEnabledTracks.size()) {
         for (size_t i = 0; i < currentlyEnabledTracks.size(); ++i) {
             RefPtrWillBeRawPtr<TextTrack> textTrack = currentlyEnabledTracks[i];
-            if (textTrack != trackToEnable)
-                textTrack->setMode(TextTrack::disabledKeyword());
+            textTrack->setMode(TextTrack::disabledKeyword());
         }
     }
 
-    if (trackToEnable)
-        trackToEnable->setMode(TextTrack::showingKeyword());
+    // Set the default track to showing if group kind is not subtitles or captions.
+    if (defaultTrack && group.kind != TrackGroup::Captions && group.kind != TrackGroup::Subtitles)
+        defaultTrack->setMode(TextTrack::showingKeyword());
+
+    if (m_configuration.textTrackKindUserPreference == TextTrackKindUserPreference::Default)
+        return defaultTrack;
+
+    return preferredTrack;
 }
 
 void AutomaticTrackSelection::enableDefaultMetadataTextTracks(const TrackGroup& group)
 {
     ASSERT(group.tracks.size());
 
     // https://html.spec.whatwg.org/multipage/embedded-content.html#honor-user-preferences-for-automatic-text-track-selection
 
     // 4. If there are any text tracks in the media element's list of text
     // tracks whose text track kind is metadata that correspond to track
     // elements with a default attribute set whose text track mode is set to
     // disabled, then set the text track mode of all such tracks to hidden
     for (auto& textTrack : group.tracks) {
         if (textTrack->mode() != TextTrack::disabledKeyword())
             continue;
         if (!textTrack->isDefault())
             continue;
         textTrack->setMode(TextTrack::hiddenKeyword());
     }
 }
 
 void AutomaticTrackSelection::perform(TextTrackList& textTracks)
 {
-    TrackGroup captionAndSubtitleTracks(TrackGroup::CaptionsAndSubtitles);
+    TrackGroup captionTracks(TrackGroup::Captions);
+    TrackGroup subtitleTracks(TrackGroup::Subtitles);
     TrackGroup descriptionTracks(TrackGroup::Description);
     TrackGroup chapterTracks(TrackGroup::Chapter);
     TrackGroup metadataTracks(TrackGroup::Metadata);
 
     for (size_t i = 0; i < textTracks.length(); ++i) {
         RefPtrWillBeRawPtr<TextTrack> textTrack = textTracks.item(i);
         if (!textTrack)
             continue;
 
         String kind = textTrack->kind();
         TrackGroup* currentGroup;
-        if (kind == TextTrack::subtitlesKeyword() || kind == TextTrack::captionsKeyword()) {
-            currentGroup = &captionAndSubtitleTracks;
+        if (kind == TextTrack::captionsKeyword()) {
+            currentGroup = &captionTracks;
+        } else if (kind == TextTrack::subtitlesKeyword()) {
+            currentGroup = &subtitleTracks;
         } else if (kind == TextTrack::descriptionsKeyword()) {
             currentGroup = &descriptionTracks;
         } else if (kind == TextTrack::chaptersKeyword()) {
             currentGroup = &chapterTracks;
         } else {
             ASSERT(kind == TextTrack::metadataKeyword());
             currentGroup = &metadataTracks;
         }
 
         if (!currentGroup->visibleTrack && textTrack->mode() == TextTrack::showingKeyword())
             currentGroup->visibleTrack = textTrack;
         if (!currentGroup->defaultTrack && textTrack->isDefault())
             currentGroup->defaultTrack = textTrack;
 
         // Do not add this track to the group if it has already been automatically configured
         // as we only want to perform selection once per track so that adding another track
         // after the initial configuration doesn't reconfigure every track - only those that
         // should be changed by the new addition. For example all metadata tracks are
         // disabled by default, and we don't want a track that has been enabled by script
         // to be disabled automatically when a new metadata track is added later.
         if (textTrack->hasBeenConfigured())
             continue;
 
         if (textTrack->language().length())
             currentGroup->hasSrcLang = true;
         currentGroup->tracks.append(textTrack);
     }
 
-    if (captionAndSubtitleTracks.tracks.size())
-        performAutomaticTextTrackSelection(captionAndSubtitleTracks);
+    RefPtrWillBeRawPtr<TextTrack> preferredSubtitleTrack = nullptr;

[fs, 2015/06/23 09:23:58]

Move this down to just before the "if (subtitleTracks..."

[srivats, 2015/06/24 01:40:19]

Done.

+    RefPtrWillBeRawPtr<TextTrack> preferredCaptionTrack = nullptr;
+    if (captionTracks.tracks.size()) {
+        preferredCaptionTrack = performAutomaticTextTrackSelection(captionTracks);
+        if (!fallbackCaptionOrSubtitleTrack)

[fs, 2015/06/23 09:23:58]

Looks like we could do this when actually needed - i.e. together with the
forceEnableSubtitleOrCaptionTrack check below - it appears selecting the
"fallback to the fallback" needn't be done at this point in time.

[srivats, 2015/06/24 01:40:19]

Done.

+            fallbackCaptionOrSubtitleTrack = captionTracks.tracks[0];
+    }
+    if (subtitleTracks.tracks.size()) {
+        preferredSubtitleTrack = performAutomaticTextTrackSelection(subtitleTracks);
+        if (!fallbackCaptionOrSubtitleTrack)
+            fallbackCaptionOrSubtitleTrack = subtitleTracks.tracks[0];
+    }
     if (descriptionTracks.tracks.size())
         performAutomaticTextTrackSelection(descriptionTracks);
     if (chapterTracks.tracks.size())
         performAutomaticTextTrackSelection(chapterTracks);
     if (metadataTracks.tracks.size())
         enableDefaultMetadataTextTracks(metadataTracks);
+
+    RefPtrWillBeRawPtr<TextTrack> trackToEnable =
+        enableTrackBasedOnUserPreference(preferredCaptionTrack, preferredSubtitleTrack);
+    if (m_configuration.forceEnableSubtitleOrCaptionTrack && !trackToEnable && fallbackCaptionOrSubtitleTrack)
+        trackToEnable = fallbackCaptionOrSubtitleTrack;
+
+    if (trackToEnable)
+        trackToEnable->setMode(TextTrack::showingKeyword());
+}
+
+RefPtrWillBeRawPtr<TextTrack> AutomaticTrackSelection::enableTrackBasedOnUserPreference(
+    RefPtrWillBeRawPtr<TextTrack> preferredCaptionTrack, RefPtrWillBeRawPtr<TextTrack> preferredSubtitleTrack)
+{
+    RefPtrWillBeRawPtr<TextTrack> trackToEnable = nullptr;
+    switch (m_configuration.textTrackKindUserPreference) {
+    case TextTrackKindUserPreference::Subtitles:
+        if (preferredSubtitleTrack)
+            trackToEnable = preferredSubtitleTrack;
+        break;
+    case TextTrackKindUserPreference::Default:
+    case TextTrackKindUserPreference::Captions:
+        // When the user prefers captions, display a caption track if present in user's preferred language.
+        // If no captions track exists in the user's preferred language or a subtitle track
+        // exists in a language with a higher score, display the subtitle track.
+        int captionTrackScore = 0;
+        int subtitleTrackScore = 0;
+        if (preferredCaptionTrack)
+            captionTrackScore = textTrackSelectionScore(*preferredCaptionTrack);
+        if (preferredSubtitleTrack)
+            subtitleTrackScore = textTrackSelectionScore(*preferredSubtitleTrack);
+        if (captionTrackScore >= subtitleTrackScore && preferredCaptionTrack)
+            trackToEnable = preferredCaptionTrack;
+        else if (preferredSubtitleTrack)
+            trackToEnable = preferredSubtitleTrack;
+        break;
+    }
+    return trackToEnable;
 }
 
 } // namespace blink