[Media Router WebUI] Move replace route responsibility to extension

chrome/browser/resources/media_router/elements/route_details/route_details.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 shows information from media that is currently cast
 // to a device.
 Polymer({
   is: 'route-details',
 
   properties: {
     /**
      * The text for the current casting activity status.
      * @private {string|undefined}
      */
     activityStatus_: {
       type: String,
     },
 
     /**
+     * Whether the external container will accept change-route-source-click
+     * events.
+     * @private {boolean}
+     */
+    changeRouteSourceAvailable_: {
+      type: Boolean,
+      computed: 'computeChangeRouteSourceAvailable_(route, sink,' +
+                    'isAnySinkCurrentlyLaunching, shownCastModeValue)',
+    },
+
+    /**
      * Whether a sink is currently launching in the container.
      * @type {boolean}
      */
     isAnySinkCurrentlyLaunching: {
       type: Boolean,
       value: false,
     },
 
     /**
-     * Whether the external container will accept replace-route-click events.
-     * @private {boolean}
-     */
-    replaceRouteAvailable_: {
-      type: Boolean,
-      computed: 'computeReplaceRouteAvailable_(route, sink,' +
-                    'isAnySinkCurrentlyLaunching, shownCastModeValue)',
-    },
-
-    /**
      * The route to show.
      * @type {?media_router.Route|undefined}
      */
     route: {
       type: Object,
       observer: 'maybeLoadCustomController_',
     },
 
     /**
      * The cast mode shown to the user. Initially set to auto mode. (See
@@ skipping 35 matching lines @@
    * the current route is clicked.
    *
    * @private
    */
   closeRoute_: function() {
     this.fire('close-route', {route: this.route});
   },
 
   /**
    * @param {?media_router.Route|undefined} route
-   * @param {boolean} replaceRouteAvailable
+   * @param {boolean} changeRouteSourceAvailable
    * @return {boolean} Whether to show the button that allows casting to the
    *     current route or the current route's sink.
    */
-  computeCastButtonHidden_: function(route, replaceRouteAvailable) {
-    return !((route && route.canJoin) || replaceRouteAvailable);
+  computeCastButtonHidden_: function(route, changeRouteSourceAvailable) {
+    return !((route && route.canJoin) || changeRouteSourceAvailable);
   },
 
   /**
    * @param {?media_router.Route|undefined} route The current route for the
    *     route details view.
    * @param {?media_router.Sink|undefined} sink Sink associated with |route|.
    * @param {boolean} isAnySinkCurrentlyLaunching Whether a sink is launching
    *     now.
    * @param {number} shownCastModeValue Currently selected cast mode value or
    *     AUTO if no value has been explicitly selected.
-   * @return {boolean} Whether the replace route function should be available
-   *     when displaying |currentRoute| in the route details view. Replace route
-   *     should not be available when the source that would be cast from when
-   *     creating a new route would be the same as the route's current source.
+   * @return {boolean} Whether the change route source function should be
+   *     available when displaying |currentRoute| in the route details view.
+   *     Changing the route source should not be available when the currently
+   *     selected source that would be cast is the same as the route's current
+   *     source.
    * @private
    */
-  computeReplaceRouteAvailable_: function(
+  computeChangeRouteSourceAvailable_: function(
       route, sink, isAnySinkCurrentlyLaunching, shownCastModeValue) {
     if (isAnySinkCurrentlyLaunching || !route || !sink) {
       return false;
     }
     if (!route.currentCastMode) {
       return true;
     }
-    var selectedCastMode = shownCastModeValue;
-    if (selectedCastMode == media_router.CastModeType.AUTO) {
-      selectedCastMode = sink.castModes & -sink.castModes;
-    }
-    return ((selectedCastMode & sink.castModes) != 0) &&
+    var selectedCastMode =
+        this.computeSelectedCastMode_(shownCastModeValue, sink);
+    return (selectedCastMode != 0) &&
         (selectedCastMode != route.currentCastMode);
   },
 
   /**
+   * @param {number} castMode User selected cast mode or AUTO.
+   * @param {?media_router.Sink} sink Sink to which we will cast.
+   * @return {number} The selected cast mode when |castMode| is selected in the
+   *     dialog and casting to |sink|.
+   */
+  computeSelectedCastMode_: function(castMode, sink) {
+    if (!sink) {

[imcheng, 2016/07/27 20:30:37]

Is this case possible since sink has to be non-null for the option to show up in
the UI? What does returning 0 mean?

[btolsch, 2016/07/27 22:16:41]

0 means there is no cast mode selected/available to be selected and it affects
whether the replace route button can be used.  The sink can be null if there is
only one local route, so the dialog opens to route details, but the current cast
modes don't support the sink for that route.

I only expect this to happen for DIAL.  For example, cast a youtube video to a
DIAL tv, then go to a new tab and open the MR dialog.  The DIAL sink won't be in
the sink list at all because it isn't available for any of the mirroring urn's
(which will be the only observed sources).

[imcheng, 2016/08/01 17:36:31]

So firing the change-route-source-click event with selectedCastMode = 0 is not a
valid call. So maybe we should add a check for the returned value of
computeSelectedCastMode_ before firing the event in L161.

[btolsch, 2016/08/02 19:23:39]

It's actually already impossible to fire the event with selectedCastMode == 0
because of the cast button's hidden property binding to
changeRouteSourceAvailable_.  I added a comment explaining this logic here
though.

+      return 0;
+    }
+    if (castMode == media_router.CastModeType.AUTO) {
+      return sink.castModes & -sink.castModes;
+    }
+    return castMode & sink.castModes;
+  },
+
+  /**
    * Fires a join-route-click event if the current route is joinable, otherwise
-   * it fires a replace-route-click event, which stops the current route and
-   * immediately launches a new route to the same sink. This is called when the
-   * button to start casting to the current route is clicked.
+   * it fires a change-route-source-click event, which changes the source of the
+   * current route. This may cause the current route to be closed and a new
+   * route to be started. This is called when the button to start casting to the
+   * current route is clicked.
    *
    * @private
    */
   startCastingToRoute_: function() {
     if (this.route.canJoin) {
       this.fire('join-route-click', {route: this.route});
     } else {
-      this.fire('replace-route-click', {route: this.route});
+      this.fire('change-route-source-click', {
+        route: this.route,
+        selectedCastMode:
+            this.computeSelectedCastMode_(this.shownCastModeValue, this.sink)
+      });
     }
   },
 
   /**
    * Loads the custom controller if |route.customControllerPath| exists.
    * Falls back to the default route details view otherwise, or if load fails.
    * Updates |activityStatus_| for the default view.
    *
    * @private
    */
@@ skipping 20 matching lines @@
     extensionview.load(this.route.customControllerPath)
     .then(function() {
       // Load was successful; show the custom controller.
       that.isCustomControllerHidden_ = false;
     }, function() {
       // Load was unsuccessful; fall back to default view.
       that.isCustomControllerHidden_ = true;
     });
   },
 });