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 23 matching lines @@
 static int textTrackSelectionScore(const TextTrack& track)
 {
     if (track.kind() != TextTrack::captionsKeyword() && track.kind() != TextTrack::subtitlesKeyword())
         return 0;
 
     return textTrackLanguageSelectionScore(track);
 }
 
 AutomaticTrackSelection::AutomaticTrackSelection(const Configuration& configuration)
     : m_configuration(configuration)
+    , m_fallbackCaptionOrSubtitleTrack(nullptr)
 {
 }
 
-void AutomaticTrackSelection::performAutomaticTextTrackSelection(const TrackGroup& group)
+PassRefPtrWillBeRawPtr<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;
+
     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;
+                m_fallbackCaptionOrSubtitleTrack = textTrack;
             }
-
-            if (!defaultTrack && textTrack->isDefault())
+            if (textTrack->isDefault() && !defaultTrack)
                 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);

[philipj_slow, 2015/06/24 09:54:20]

I see that you have discussed this with fs, but I think splitting
captionAndSubtitleTracks into two groups and selecting between them at a higher
level has made the structure and name of things a bit strange right now. It's
odd that performAutomaticTextTrackSelection returns a track to potentially be
enabled, but in the case of chapters it's already been enabled. The role of each
step isn't so clear to me.

It looks like the principal reason for the split was "to handle the case where
user preferred kind is captions and there is a subtitle track with a higher
score" but if the score is higher for subtitles, doesn't that mean that it's
really in a language that the user better understands? What is the intended
model? I thought it would be that language is always the first concern, and then
captions/subtitles picked only if both exist in an equally suitable language.

[fs, 2015/06/24 10:23:26]

FWIW, this is one of the "further improvements" that I hinted at in my comments.
I don't really feel that it's something that necessarily needs be done right
now, even if it's a little "unclean" ATM. Not letting "perfect" be the enemy of
"good" and all that.
I had (maybe naively) hoped that this could be done just by doing something
like:

if (track->kind() == preferredTrackKind)
    score += someBias; // 1?

Possibly with a scale-factor/other adjustment added to make sure this bias
doesn't affect language-based scoring (i.e. is smaller than smallest
language-score.step.)

[philipj_slow, 2015/06/24 10:26:16]

That sounds good if it's possible. srivats@, did you already try something like
that an find some problem with this approach?

+    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> preferredCaptionTrack = nullptr;
+    if (captionTracks.tracks.size())
+        preferredCaptionTrack = performAutomaticTextTrackSelection(captionTracks);
+
+    RefPtrWillBeRawPtr<TextTrack> preferredSubtitleTrack = nullptr;
+    if (subtitleTracks.tracks.size())
+        preferredSubtitleTrack = performAutomaticTextTrackSelection(subtitleTracks);
+
     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) {
+        trackToEnable = m_fallbackCaptionOrSubtitleTrack;
+        if (captionTracks.tracks.size() && !trackToEnable)
+            trackToEnable = captionTracks.tracks[0];
+        else if (subtitleTracks.tracks.size() && !trackToEnable)
+            trackToEnable = subtitleTracks.tracks[0];
+    }
+
+    if (trackToEnable)
+        trackToEnable->setMode(TextTrack::showingKeyword());
+}
+
+PassRefPtrWillBeRawPtr<TextTrack> AutomaticTrackSelection::enableTrackBasedOnUserPreference(
+    PassRefPtrWillBeRawPtr<TextTrack> preferredCaptionTrack, PassRefPtrWillBeRawPtr<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