[Media Router] Force DEFAULT cast mode when starting presentations from content.

chrome/browser/resources/media_router/elements/media_router_container/media_router_container.js

 // 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.
 
 // This Polymer element contains the entire media router interface. It handles
 // hiding and showing specific components.
 Polymer({
   is: 'media-router-container',
 
   properties: {
@@ skipping 512 matching lines @@
 
   /**
    * Checks that the currently selected cast mode is still in the
    * updated list of available cast modes. If not, then update the selected
    * cast mode to the first available cast mode on the list.
    */
   checkCurrentCastMode_: function() {
     if (!this.castModeList.length)
       return;
 
+    // If there is a forced mode make sure it is shown.
+    if (this.findForcedCastMode_()) {
+      this.rebuildSinksToShow_();
+    }
+
     // If we are currently showing auto mode, then nothing needs to be done.
     // Otherwise, if the cast mode currently shown no longer exists (regardless
     // of whether it was selected by user), then switch back to auto cast mode.
     if (this.shownCastModeValue_ != media_router.CastModeType.AUTO &&
         !this.findCastModeByType_(this.shownCastModeValue_)) {
       this.setShownCastMode_(media_router.AUTO_CAST_MODE);
       this.rebuildSinksToShow_();
     }
   },
 
@@ skipping 61 matching lines @@
    * @param {number} distance Number of pixels that will be traveled.
    * @private
    */
   computeAnimationDuration_: function(distance) {
     // The duration of the animation can be found by abs(distance)/speed, where
     // speed is fixed at 1000 pixels per second, or 1 pixel per millisecond.
     return Math.abs(distance);
   },
 
   /**
-   * If |allSinks| supports only a single cast mode, returns that cast mode.
-   * Otherwise, returns AUTO_MODE. Only called if |userHasSelectedCastMode_| is
-   * |false|.
+   * If there is a forced cast mode, returns that cast mode.  If |allSinks|
+   * supports only a single cast mode, returns that cast mode.  Otherwise,
+   * returns AUTO_MODE. Only called if |userHasSelectedCastMode_| is |false|.
+   *
    * @return {!media_router.CastMode} The single cast mode supported by
    *                                  |allSinks|, or AUTO_MODE.
    */
   computeCastMode_: function() {
+    /** @const */ var forcedMode = this.findForcedCastMode_();
+    if (forcedMode)
+      return forcedMode;
+
     var allCastModes = this.allSinks.reduce(function(castModesSoFar, sink) {
       return castModesSoFar | sink.castModes;
     }, 0);
 
     // This checks whether |castModes| does not consist of exactly 1 cast mode.
     if (!allCastModes || allCastModes & (allCastModes - 1))
       return media_router.AUTO_CAST_MODE;
 
     var castMode = this.findCastModeByType_(allCastModes);
     if (castMode)
@@ skipping 511 matching lines @@
    * @return {media_router.CastMode|undefined} CastMode object with the given
    *     type in castModeList, or undefined if not found.
    */
   findCastModeByType_: function(castModeType) {
     return this.castModeList.find(function(element, index, array) {
       return element.type == castModeType;
     });
   },
 
   /**
+   * Helper function to return a forced CastMode, if any.
+   *
+   * @return {media_router.CastMode|undefined} CastMode object with
+   *     isForced = true, or undefined if not found.
+   */
+  findForcedCastMode_: function() {
+    return this.castModeList &&
+        this.castModeList.find(element => element.isForced);
+  },
+
+  /**
    * @param {?Element} element Element to compute padding for.
    * @return {!Array<number>} Array containing the element's bottom padding
    *     value and the element's top padding value, in that order.
    * @private
    */
   getElementVerticalPadding_: function(element) {
     var style = window.getComputedStyle(element);
     return [parseInt(style.getPropertyValue('padding-bottom'), 10) || 0,
             parseInt(style.getPropertyValue('padding-top'), 10) || 0];
   },
@@ skipping 809 matching lines @@
       var pendingPseudoSink = this.pseudoSinkSearchState_.getPseudoSink();
       // Here we will treat the pseudo sink that launched the search as a real
       // sink until one is returned by search. This way it isn't possible to
       // ever reach a UI state where there is no spinner being shown in the sink
       // list but |currentLaunchingSinkId_| is non-empty (thereby preventing any
       // other sink from launching).
       if (pendingPseudoSink.id == this.currentLaunchingSinkId_) {
         updatedSinkList.unshift(pendingPseudoSink);
       }
     }
-    if (this.userHasSelectedCastMode_) {
-      // If user explicitly selected a cast mode, then we show only sinks that
-      // are compatible with current cast mode or sinks that are active.
+    // If user did not select a cast mode, then:
+    // - If there is a forced cast mode, it is shown.
+    // - If all sinks support only a single cast mode, then the cast mode is
+    //   switched to that mode.
+    // - Otherwise, the cast mode becomes AUTO mode.
+    if (!this.userHasSelectedCastMode_)
+      this.setShownCastMode_(this.computeCastMode_());
+
+    // Non-AUTO modes may show a subset of sinks based on compatibility with the
+    // shown value.
+    if (this.shownCastModeValue_ != media_router.CastModeType.AUTO) {
       updatedSinkList = updatedSinkList.filter(function(element) {
         return (element.castModes & this.shownCastModeValue_) ||
-               this.sinkToRouteMap_[element.id];
+              this.sinkToRouteMap_[element.id];
       }, this);
-    } else {
-      // If user did not select a cast mode, then:
-      // - If all sinks support only a single cast mode, then the cast mode is
-      //   switched to that mode.
-      // - Otherwise, the cast mode becomes auto mode.
-      // Either way, all sinks will be shown.
-      this.setShownCastMode_(this.computeCastMode_());
     }
 
     // When there's an updated list of sinks, append any new sinks to the end
     // of the existing list. This prevents sinks randomly jumping around the
     // dialog, which can surprise users / lead to inadvertently casting to the
     // wrong sink.
     if (this.sinksToShow_) {
       for (var i = this.sinksToShow_.length - 1; i >= 0; i--) {
         var index = updatedSinkList.findIndex(function(updatedSink) {
             return this.sinksToShow_[i].id == updatedSink.id; }.bind(this));
@@ skipping 361 matching lines @@
   /**
    * Update the max dialog height and update the positioning of the elements.
    *
    * @param {number} height The max height of the Media Router dialog.
    */
   updateMaxDialogHeight: function(height) {
     this.dialogHeight_ = height;
     this.updateElementPositioning_();
   },
 });