Shows a launch spinner next to a sink once it is selected to create a route. The launch spinner sur…

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/strings/stringprintf.h"
 #include "chrome/browser/ui/webui/media_router/media_router_ui.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 kCloseDialog[] = "closeDialog";
 
 // JS function names.
 const char kSetInitialData[] = "media_router.ui.setInitialData";
-const char kAddRoute[] = "media_router.ui.addRoute";
+const char kOnCreateRouteResponseReceived[] =
+    "media_router.ui.onCreateRouteResponseReceived";
 const char kSetIssue[] = "media_router.ui.setIssue";
 const char kSetSinkList[] = "media_router.ui.setSinkList";
 const char kSetRouteList[] = "media_router.ui.setRouteList";
 const char kSetCastModeList[] = "media_router.ui.setCastModeList";
 const char kWindowOpen[] = "window.open";
 
 scoped_ptr<base::ListValue> SinksToValue(
-    const std::vector<MediaSinkWithCastModes>& sinks) {
+    const std::vector<MediaSinkWithCastModes>& sinks,
+    const std::set<MediaSink::Id>& sink_ids_in_launch) {
   scoped_ptr<base::ListValue> value(new base::ListValue);
 
   for (const MediaSinkWithCastModes& sink_with_cast_modes : sinks) {
     scoped_ptr<base::DictionaryValue> sink_val(new base::DictionaryValue);
 
     const MediaSink& sink = sink_with_cast_modes.sink;
     sink_val->SetString("id", sink.id());
     sink_val->SetString("name", sink.name());
+    sink_val->SetBoolean("isLaunching", sink_ids_in_launch.find(sink.id()) !=
+                                            sink_ids_in_launch.end());
 
     scoped_ptr<base::ListValue> cast_modes_val(new base::ListValue);
     for (MediaCastMode cast_mode : sink_with_cast_modes.cast_modes)
       cast_modes_val->AppendInteger(cast_mode);
     sink_val->Set("castModes", cast_modes_val.Pass());
 
     value->Append(sink_val.release());
   }
 
   return value.Pass();
@@ skipping 88 matching lines @@
 MediaRouterWebUIMessageHandler::MediaRouterWebUIMessageHandler()
     : dialog_closing_(false) {
 }
 
 MediaRouterWebUIMessageHandler::~MediaRouterWebUIMessageHandler() {
 }
 
 void MediaRouterWebUIMessageHandler::UpdateSinks(
     const std::vector<MediaSinkWithCastModes>& sinks) {
   DVLOG(2) << "UpdateSinks";
-  scoped_ptr<base::ListValue> sinks_val(SinksToValue(sinks));
+  scoped_ptr<base::ListValue> sinks_val(
+      SinksToValue(sinks, GetMediaRouterUI()->GetSinkIdsInLaunch()));
   web_ui()->CallJavascriptFunction(kSetSinkList, *sinks_val);
 }
 
 void MediaRouterWebUIMessageHandler::UpdateRoutes(
     const std::vector<MediaRoute>& routes) {
   DVLOG(2) << "UpdateRoutes";
   scoped_ptr<base::ListValue> routes_val(RoutesToValue(routes));
   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::AddRoute(const MediaRoute& route) {
-  DVLOG(2) << "AddRoute";
-  scoped_ptr<base::DictionaryValue> route_value(RouteToValue(route));
-  web_ui()->CallJavascriptFunction(kAddRoute, *route_value);
+void MediaRouterWebUIMessageHandler::OnCreateRouteResponseReceived(
+    const MediaSink::Id& sink_id,
+    const MediaRoute* route) {
+  DVLOG(2) << "OnCreateRouteResponseReceived";
+  scoped_ptr<base::StringValue> sink_id_value(new base::StringValue(sink_id));

[Kevin M, 2015/08/08 00:35:57]

I don't think scoped_ptr + heap allocation are needed here (or elsewhere in this
file?)

You can just declare a base::StringValue on the stack.

[haibinlu, 2015/08/08 01:25:39]

Done.

+  if (route) {
+    scoped_ptr<base::DictionaryValue> route_value(RouteToValue(*route));
+    web_ui()->CallJavascriptFunction(kOnCreateRouteResponseReceived,
+                                     *sink_id_value, *route_value);
+  } else {
+    web_ui()->CallJavascriptFunction(kOnCreateRouteResponseReceived,
+                                     *sink_id_value,
+                                     *base::Value::CreateNullValue());
+  }
 }
 
 void MediaRouterWebUIMessageHandler::UpdateIssue(const Issue* issue) {
   DVLOG(2) << "UpdateIssue";
   if (issue) {
     scoped_ptr<base::DictionaryValue> issue_val(IssueToValue(*issue));
     web_ui()->CallJavascriptFunction(kSetIssue, *issue_val);
   } else {
     // Clears the issue in the WebUI.
     web_ui()->CallJavascriptFunction(kSetIssue);
@@ skipping 27 matching lines @@
     const base::ListValue* args) {
   DVLOG(1) << "OnRequestInitialData";
   MediaRouterUI* media_router_ui = GetMediaRouterUI();
 
   base::DictionaryValue initial_data;
 
   initial_data.SetString("headerText", media_router_ui->GetInitialHeaderText());
   initial_data.SetString("headerTextTooltip",
       media_router_ui->GetInitialHeaderTextTooltip());
 
-  scoped_ptr<base::ListValue> sinks(SinksToValue(media_router_ui->sinks()));
+  scoped_ptr<base::ListValue> sinks(SinksToValue(
+      media_router_ui->sinks(), media_router_ui->GetSinkIdsInLaunch()));

[Kevin M, 2015/08/08 00:35:57]

I think it might be cleaner to have media_router_ui->sinks() contain the "is
launching" bool than to require that this layer do some additional assembly work
with another set.

[haibinlu, 2015/08/08 01:25:39]

If we add inLaunching in the sink object, it is better to let extension set it,
and this will be pass-through.  Let us discuss next Monday.

   initial_data.Set("sinks", sinks.release());
 
   scoped_ptr<base::ListValue> routes(RoutesToValue(media_router_ui->routes()));
   initial_data.Set("routes", routes.release());
 
   scoped_ptr<base::ListValue> cast_modes(CastModesToValue(
       media_router_ui->cast_modes(),
       // TODO(imcheng): Use media_router_ui->source_host() once DEFAULT mode
       // is upstreamed.
       std::string()));
@@ skipping 115 matching lines @@
 }
 
 MediaRouterUI* MediaRouterWebUIMessageHandler::GetMediaRouterUI() {
   MediaRouterUI* media_router_ui =
       static_cast<MediaRouterUI*>(web_ui()->GetController());
   DCHECK(media_router_ui);
   return media_router_ui;
 }
 
 }  // namespace media_router