Non-Local Join for Media Router and Presentation API

chrome/browser/ui/webui/media_router/media_router_webui_message_handler.cc

 // 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 "chrome/browser/ui/webui/media_router/media_router_webui_message_handler.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/issue.h"
 #include "chrome/browser/ui/webui/media_router/media_router_ui.h"
 #include "chrome/grit/generated_resources.h"
 #include "extensions/common/constants.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace media_router {
 
 namespace {
 
 const char kHelpPageUrlPrefix[] =
     "https://support.google.com/chromecast/answer/%d";
 
 // Message names.
 const char kRequestInitialData[] = "requestInitialData";
 const char kCreateRoute[] = "requestRoute";
 const char kActOnIssue[] = "actOnIssue";
 const char kCloseRoute[] = "closeRoute";
+const char kJoinRoute[] = "joinRoute";
 const char kCloseDialog[] = "closeDialog";
 const char kReportSinkCount[] = "reportSinkCount";
 const char kOnInitialDataReceived[] = "onInitialDataReceived";
 
 // JS function names.
 const char kSetInitialData[] = "media_router.ui.setInitialData";
 const char kNotifyRouteCreationTimeout[] =
     "media_router.ui.onNotifyRouteCreationTimeout";
 const char kOnCreateRouteResponseReceived[] =
     "media_router.ui.onCreateRouteResponseReceived";
@@ skipping 22 matching lines @@
       cast_mode_bits |= cast_mode;
 
     sink_val->SetInteger("castModes", cast_mode_bits);
     value->Append(sink_val.release());
   }
 
   return value.Pass();
 }
 
 scoped_ptr<base::DictionaryValue> RouteToValue(
-    const MediaRoute& route, const std::string& extension_id) {
+    const MediaRoute& route, bool canJoin, const std::string& extension_id) {
   scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue);
   dictionary->SetString("id", route.media_route_id());
   dictionary->SetString("sinkId", route.media_sink_id());
   dictionary->SetString("description", route.description());
   dictionary->SetBoolean("isLocal", route.is_local());
+  dictionary->SetBoolean("canJoin", canJoin);
 
   const std::string& custom_path = route.custom_controller_path();
   if (!custom_path.empty()) {
     std::string full_custom_controller_path = base::StringPrintf("%s://%s/%s",
         extensions::kExtensionScheme, extension_id.c_str(),
             custom_path.c_str());
     DCHECK(GURL(full_custom_controller_path).is_valid());
     dictionary->SetString("customControllerPath",
                           full_custom_controller_path);
   }
 
   return dictionary.Pass();
 }
 
 scoped_ptr<base::ListValue> RoutesToValue(
-    const std::vector<MediaRoute>& routes, const std::string& extension_id) {
+    const std::vector<MediaRoute>& routes,
+    const std::vector<MediaRoute::Id>& joinable_route_ids,
+    const std::string& extension_id) {
   scoped_ptr<base::ListValue> value(new base::ListValue);
 
   for (const MediaRoute& route : routes) {
+    bool canJoin = ContainsValue(joinable_route_ids, route.media_route_id());
     scoped_ptr<base::DictionaryValue> route_val(RouteToValue(route,
-        extension_id));
+        canJoin, extension_id));
     value->Append(route_val.release());
   }
 
   return value.Pass();
 }
 
 scoped_ptr<base::ListValue> CastModesToValue(const CastModeSet& cast_modes,
                                              const std::string& source_host) {
   scoped_ptr<base::ListValue> value(new base::ListValue);
 
@@ skipping 64 matching lines @@
 }
 
 void MediaRouterWebUIMessageHandler::UpdateSinks(
     const std::vector<MediaSinkWithCastModes>& sinks) {
   DVLOG(2) << "UpdateSinks";
   scoped_ptr<base::ListValue> sinks_val(SinksToValue(sinks));
   web_ui()->CallJavascriptFunction(kSetSinkList, *sinks_val);
 }
 
 void MediaRouterWebUIMessageHandler::UpdateRoutes(
-    const std::vector<MediaRoute>& routes) {
-  DVLOG(2) << "UpdateRoutes";
+    const std::vector<MediaRoute>& routes,
+    const std::vector<MediaRoute::Id>& joinable_route_ids) {
   scoped_ptr<base::ListValue> routes_val(RoutesToValue(routes,
+      joinable_route_ids,
       media_router_ui_->GetRouteProviderExtensionId()));
   web_ui()->CallJavascriptFunction(kSetRouteList, *routes_val);
 }
 
 void MediaRouterWebUIMessageHandler::UpdateCastModes(
     const CastModeSet& cast_modes,
     const std::string& source_host) {
   DVLOG(2) << "UpdateCastModes";
   scoped_ptr<base::ListValue> cast_modes_val(
       CastModesToValue(cast_modes, source_host));
   web_ui()->CallJavascriptFunction(kSetCastModeList, *cast_modes_val);
 }
 
 void MediaRouterWebUIMessageHandler::OnCreateRouteResponseReceived(
     const MediaSink::Id& sink_id,
     const MediaRoute* route) {
   DVLOG(2) << "OnCreateRouteResponseReceived";
   if (route) {
-    scoped_ptr<base::DictionaryValue> route_value(RouteToValue(*route,
+    scoped_ptr<base::DictionaryValue> route_value(RouteToValue(*route, false,
         media_router_ui_->GetRouteProviderExtensionId()));
     web_ui()->CallJavascriptFunction(kOnCreateRouteResponseReceived,
                                      base::StringValue(sink_id), *route_value);
     UMA_HISTOGRAM_BOOLEAN("MediaRouter.Ui.Action.StartLocalSessionSuccessful",
                           true);
   } else {
     web_ui()->CallJavascriptFunction(kOnCreateRouteResponseReceived,
                                      base::StringValue(sink_id),
                                      *base::Value::CreateNullValue());
     UMA_HISTOGRAM_BOOLEAN("MediaRouter.Ui.Action.StartLocalSessionSuccessful",
@@ skipping 28 matching lines @@
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       kActOnIssue,
       base::Bind(&MediaRouterWebUIMessageHandler::OnActOnIssue,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       kCloseRoute,
       base::Bind(&MediaRouterWebUIMessageHandler::OnCloseRoute,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
+      kJoinRoute,
+      base::Bind(&MediaRouterWebUIMessageHandler::OnJoinRoute,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
       kCloseDialog,
       base::Bind(&MediaRouterWebUIMessageHandler::OnCloseDialog,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       kReportSinkCount,
       base::Bind(&MediaRouterWebUIMessageHandler::OnReportSinkCount,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       kOnInitialDataReceived,
       base::Bind(&MediaRouterWebUIMessageHandler::OnInitialDataReceived,
                  base::Unretained(this)));
 }
 
 void MediaRouterWebUIMessageHandler::OnRequestInitialData(
     const base::ListValue* args) {
   DVLOG(1) << "OnRequestInitialData";
   media_router_ui_->OnUIInitiallyLoaded();
   base::DictionaryValue initial_data;
 
   // "No Cast devices found?" Chromecast help center page.
   initial_data.SetString("deviceMissingUrl",
       base::StringPrintf(kHelpPageUrlPrefix, 3249268));
 
   scoped_ptr<base::ListValue> sinks(SinksToValue(media_router_ui_->sinks()));
   initial_data.Set("sinks", sinks.release());
 
   scoped_ptr<base::ListValue> routes(RoutesToValue(media_router_ui_->routes(),
+      media_router_ui_->joinable_route_ids(),
       media_router_ui_->GetRouteProviderExtensionId()));
   initial_data.Set("routes", routes.release());
 
   const std::set<MediaCastMode> cast_modes = media_router_ui_->cast_modes();
   scoped_ptr<base::ListValue> cast_modes_list(
       CastModesToValue(cast_modes,
                        media_router_ui_->GetPresentationRequestSourceName()));
   initial_data.Set("castModes", cast_modes_list.release());
 
   web_ui()->CallJavascriptFunction(kSetInitialData, initial_data);
@@ skipping 67 matching lines @@
     DVLOG(1) << "Invalid action type: " << action_type_num;
     return;
   }
   IssueAction::Type action_type =
       static_cast<IssueAction::Type>(action_type_num);
   if (ActOnIssueType(action_type, args_dict))
     DVLOG(1) << "ActOnIssueType failed for Issue ID " << issue_id;
   media_router_ui_->ClearIssue(issue_id);
 }
 
-void MediaRouterWebUIMessageHandler::OnCloseRoute(
-    const base::ListValue* args) {
+void MediaRouterWebUIMessageHandler::OnJoinRoute(const base::ListValue* args) {
+  DVLOG(1) << "OnJoinRoute";
+  const base::DictionaryValue* args_dict = nullptr;
+  std::string route_id;
+  std::string sink_id;
+  if (!args->GetDictionary(0, &args_dict) ||
+      !args_dict->GetString("sinkId", &sink_id) ||
+      !args_dict->GetString("routeId", &route_id)) {
+    DVLOG(1) << "Unable to extract args.";
+    return;
+  }
+
+  if (sink_id.empty()) {
+    DVLOG(1) << "Media Route UI did not respond with a "
+             << "valid sink ID. Aborting.";
+    return;
+  }
+
+  if (route_id.empty()) {
+    DVLOG(1) << "Media Route UI did not respond with a "
+             << "valid route ID. Aborting.";
+    return;
+  }
+
+  MediaRouterUI* media_router_ui =
+      static_cast<MediaRouterUI*>(web_ui()->GetController());
+  if (media_router_ui->HasPendingRouteRequest()) {
+    DVLOG(1) << "UI already has pending route request. Ignoring.";
+    Issue issue(
+        l10n_util::GetStringUTF8(IDS_MEDIA_ROUTER_ISSUE_PENDING_ROUTE),
+        std::string(), IssueAction(IssueAction::TYPE_DISMISS),
+        std::vector<IssueAction>(), std::string(), Issue::NOTIFICATION,
+        false, std::string());
+    media_router_ui_->AddIssue(issue);
+    return;
+  }
+
+  DVLOG(2) << __FUNCTION__ << ": sink id: " << sink_id
+           << ", route id: " << route_id;
+
+  if (!media_router_ui_->ConnectRemoteRoute(sink_id, route_id)) {

[imcheng, 2015/12/29 00:24:42]

on naming: Is there logic in the WebUI that restricts joining to remote routes?
i.e., can I start a route on tab 1, then join via the dialog in tab 2?

[matt.boetger, 2016/01/05 00:19:48]

No, there is currently nothing preventing a provider from telling us a local
route is joinable and then us showing it.  I was defaulting to allow the
providers to manage this.  I can put a check in media_router_bindings to make
sure they only non-local (remote) routes are returned in the joinable_route_ids
array.

[imcheng, 2016/01/05 02:12:47]

Well I think it's reasonable to allow join to local route. In that case we don't
need to call the function ConnectRemoteRoute.

[matt.boetger, 2016/01/06 22:49:07]

Done.

+    // TODO(boetger): Need to add an issue if failed to initiate a JoinRoute
+    // request.
+    DVLOG(1) << "Error initiating route join request.";
+  }
+}
+
+void MediaRouterWebUIMessageHandler::OnCloseRoute(const base::ListValue* args) {
   DVLOG(1) << "OnCloseRoute";
   const base::DictionaryValue* args_dict = nullptr;
   std::string route_id;
   if (!args->GetDictionary(0, &args_dict) ||
       !args_dict->GetString("routeId", &route_id)) {
     DVLOG(1) << "Unable to extract args.";
     return;
   }
   media_router_ui_->CloseRoute(route_id);
 }
@@ skipping 36 matching lines @@
     open_args->AppendString(learn_more_url);
     web_ui()->CallJavascriptFunction(kWindowOpen, *open_args);
     return true;
   } else {
     // Do nothing; no other issue action types require any other action.
     return true;
   }
 }
 
 }  // namespace media_router