[Media Router] Custom Controls 3 - add plumbing through MRUI and MRWebUIMessageHandler

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

Index: chrome/browser/ui/webui/media_router/media_router_webui_message_handler.cc
diff --git a/chrome/browser/ui/webui/media_router/media_router_webui_message_handler.cc b/chrome/browser/ui/webui/media_router/media_router_webui_message_handler.cc
index 1e22dd81652226a9da6b7aee4cf05b898a4ac8c9..62731d077c6153956d07c8a82a1af00267919445 100644
--- a/chrome/browser/ui/webui/media_router/media_router_webui_message_handler.cc
+++ b/chrome/browser/ui/webui/media_router/media_router_webui_message_handler.cc
@@ -21,7 +21,7 @@
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/webui/media_router/media_cast_mode.h"
 #include "chrome/browser/ui/webui/media_router/media_router_ui.h"
-#include "chrome/common/media_router/issue.h"
+#include "chrome/common/chrome_features.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/browser_sync/profile_sync_service.h"
@@ -62,11 +62,20 @@ const char kReportTimeToClickSink[] = "reportTimeToClickSink";
 const char kReportTimeToInitialActionClose[] = "reportTimeToInitialActionClose";
 const char kSearchSinksAndCreateRoute[] = "searchSinksAndCreateRoute";
 const char kOnInitialDataReceived[] = "onInitialDataReceived";
+const char kOnRouteDetailsClosed[] = "onRouteDetailsClosed";

[mark a. foltz, 2017/04/26 21:01:19]

onMediaControllerAvailable

[takumif, 2017/04/27 03:04:18]

Done.

+const char kOnRouteDetailsOpened[] = "onRouteDetailsOpened";

[mark a. foltz, 2017/04/26 21:01:18]

OnMediaControllerClosed

[takumif, 2017/04/27 03:04:18]

Done.

+const char kPauseRoute[] = "pauseRoute";

[mark a. foltz, 2017/04/26 21:01:19]

Prefer pauseCurrentMedia, playCurrentMedia, etc.

[takumif, 2017/04/27 03:04:17]

Done.

+const char kPlayRoute[] = "playRoute";
+const char kSeekRoute[] = "seekRoute";
+const char kSetRouteMute[] = "setRouteMute";
+const char kSetRouteVolume[] = "setRouteVolume";
 
 // JS function names.
 const char kSetInitialData[] = "media_router.ui.setInitialData";
 const char kOnCreateRouteResponseReceived[] =
     "media_router.ui.onCreateRouteResponseReceived";
+const char kOnRouteControllerInvalidated[] =
+    "media_router.ui.onRouteControllerInvalidated";
 const char kReceiveSearchResult[] = "media_router.ui.receiveSearchResult";
 const char kSetFirstRunFlowData[] = "media_router.ui.setFirstRunFlowData";
 const char kSetIssue[] = "media_router.ui.setIssue";
@@ -74,6 +83,7 @@ const char kSetSinkListAndIdentity[] = "media_router.ui.setSinkListAndIdentity";
 const char kSetRouteList[] = "media_router.ui.setRouteList";
 const char kSetCastModeList[] = "media_router.ui.setCastModeList";
 const char kUpdateMaxHeight[] = "media_router.ui.updateMaxHeight";
+const char kUpdateRouteStatus[] = "media_router.ui.updateRouteStatus";
 const char kWindowOpen[] = "window.open";
 
 std::unique_ptr<base::DictionaryValue> SinksAndIdentityToValue(
@@ -314,6 +324,28 @@ void MediaRouterWebUIMessageHandler::UpdateMaxDialogHeight(int height) {
   web_ui()->CallJavascriptFunctionUnsafe(kUpdateMaxHeight, base::Value(height));
 }
 
+void MediaRouterWebUIMessageHandler::UpdateMediaRouteStatus(
+    const MediaStatus& status) {
+  base::DictionaryValue status_value;
+  status_value.SetString("title", status.title);
+  status_value.SetString("description", status.description);
+  status_value.SetBoolean("canPlayPause", status.can_play_pause);
+  status_value.SetBoolean("canMute", status.can_mute);
+  status_value.SetBoolean("canSetVolume", status.can_set_volume);
+  status_value.SetBoolean("canSeek", status.can_seek);
+  status_value.SetBoolean("isPaused", status.is_paused);
+  status_value.SetBoolean("isMuted", status.is_muted);
+  status_value.SetInteger("duration", status.duration.InSeconds());
+  status_value.SetInteger("currentTime", status.current_time.InSeconds());
+  status_value.SetDouble("volume", status.volume);
+  web_ui()->CallJavascriptFunctionUnsafe(kUpdateRouteStatus,
+                                         std::move(status_value));

[mark a. foltz, 2017/04/26 21:01:19]

imcheng@: What did we conclude about migrating WebUI<->Browser messaging to
Mojo?  Feasible in the long term?

[imcheng, 2017/04/26 21:48:39]

We can migrate to Mojo, but just weren't sure how the work will be affected by
the migration to native UI. Most likely we will keep the browser side
MessageHandler logic and the mojom hopefully mostly intact, but the JS-based UI
implementation will have to be rewritten for sure. IMO it's worthwhile to do as
long as most of our work won't be thrown away when it comes to migration.

+}
+
+void MediaRouterWebUIMessageHandler::OnRouteControllerInvalidated() {
+  web_ui()->CallJavascriptFunctionUnsafe(kOnRouteControllerInvalidated);
+}
+
 void MediaRouterWebUIMessageHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       kRequestInitialData,
@@ -400,6 +432,30 @@ void MediaRouterWebUIMessageHandler::RegisterMessages() {
       kOnInitialDataReceived,
       base::Bind(&MediaRouterWebUIMessageHandler::OnInitialDataReceived,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kOnRouteDetailsClosed,
+      base::Bind(&MediaRouterWebUIMessageHandler::OnRouteDetailsClosed,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kOnRouteDetailsOpened,
+      base::Bind(&MediaRouterWebUIMessageHandler::OnRouteDetailsOpened,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kPauseRoute, base::Bind(&MediaRouterWebUIMessageHandler::OnPauseRoute,
+                              base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kPlayRoute, base::Bind(&MediaRouterWebUIMessageHandler::OnPlayRoute,
+                             base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kSeekRoute, base::Bind(&MediaRouterWebUIMessageHandler::OnSeekRoute,
+                             base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kSetRouteMute, base::Bind(&MediaRouterWebUIMessageHandler::OnSetRouteMute,
+                                base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kSetRouteVolume,
+      base::Bind(&MediaRouterWebUIMessageHandler::OnSetRouteVolume,
+                 base::Unretained(this)));
 }
 
 void MediaRouterWebUIMessageHandler::OnRequestInitialData(
@@ -434,6 +490,10 @@ void MediaRouterWebUIMessageHandler::OnRequestInitialData(
       media_router_ui_->UserSelectedTabMirroringForCurrentOrigin();
   initial_data.SetBoolean("useTabMirroring", use_tab_mirroring);
 
+  initial_data.SetBoolean(
+      "useNewRouteControls",
+      base::FeatureList::IsEnabled(features::kMediaRouterUIRouteController));
+
   web_ui()->CallJavascriptFunctionUnsafe(kSetInitialData, initial_data);
   media_router_ui_->UIInitialized();
 }
@@ -789,6 +849,66 @@ void MediaRouterWebUIMessageHandler::OnInitialDataReceived(
   MaybeUpdateFirstRunFlowData();
 }
 
+void MediaRouterWebUIMessageHandler::OnRouteDetailsClosed(
+    const base::ListValue* args) {
+  media_router_ui_->OnUIDetailsViewClosed();
+}
+
+void MediaRouterWebUIMessageHandler::OnRouteDetailsOpened(
+    const base::ListValue* args) {
+  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 media route ID";
+    return;
+  }
+  media_router_ui_->OnUIDetailsViewOpened(route_id);
+}
+
+void MediaRouterWebUIMessageHandler::OnPauseRoute(const base::ListValue* args) {
+  media_router_ui_->PauseRoute();
+}
+
+void MediaRouterWebUIMessageHandler::OnPlayRoute(const base::ListValue* args) {
+  media_router_ui_->PlayRoute();
+}
+
+void MediaRouterWebUIMessageHandler::OnSeekRoute(const base::ListValue* args) {
+  const base::DictionaryValue* args_dict = nullptr;
+  int time;
+  if (!args->GetDictionary(0, &args_dict) ||
+      !args_dict->GetInteger("time", &time)) {
+    DVLOG(1) << "Unable to extract time";
+    return;
+  }
+  media_router_ui_->SeekRoute(base::TimeDelta::FromSeconds(time));
+}
+
+void MediaRouterWebUIMessageHandler::OnSetRouteMute(
+    const base::ListValue* args) {
+  const base::DictionaryValue* args_dict = nullptr;
+  bool mute;
+  if (!args->GetDictionary(0, &args_dict) ||
+      !args_dict->GetBoolean("mute", &mute)) {
+    DVLOG(1) << "Unable to extract mute";
+    return;
+  }
+  media_router_ui_->SetRouteMute(mute);
+}
+
+void MediaRouterWebUIMessageHandler::OnSetRouteVolume(
+    const base::ListValue* args) {
+  const base::DictionaryValue* args_dict = nullptr;
+  double volume;
+  if (!args->GetDictionary(0, &args_dict) ||
+      !args_dict->GetDouble("volume", &volume)) {
+    DVLOG(1) << "Unable to extract volume";
+    return;
+  }
+  media_router_ui_->SetRouteVolume(volume);
+}
+
 bool MediaRouterWebUIMessageHandler::ActOnIssueType(
     IssueInfo::Action action_type,
     const base::DictionaryValue* args) {