[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..3617de060138c9768ea2a736051b3d7d155381d1 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";
+const char kOnRouteDetailsOpened[] = "onRouteDetailsOpened";
+const char kPauseRoute[] = "pauseRoute";
+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,29 @@ 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));
+}
+
+void MediaRouterWebUIMessageHandler::OnRouteControllerInvalidated() {
+  web_ui()->CallJavascriptFunctionUnsafe(kOnRouteControllerInvalidated,

[imcheng, 2017/04/22 00:22:51]

Would this be called as a result of abnormal termination of connection with the
MR extension? Not needed in this patch, but consider adding an issue to notify
the user here. 

[imcheng, 2017/04/22 00:22:51]

Can you call the 1-arg version of CallJavascriptFunctionUnsafe here?

[takumif, 2017/04/24 20:59:23]

Acknowledged.

[takumif, 2017/04/24 20:59:23]

Done.

+                                         base::Value());
+}
+
 void MediaRouterWebUIMessageHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       kRequestInitialData,
@@ -400,6 +433,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 +491,10 @@ void MediaRouterWebUIMessageHandler::OnRequestInitialData(
       media_router_ui_->UserSelectedTabMirroringForCurrentOrigin();
   initial_data.SetBoolean("useTabMirroring", use_tab_mirroring);
 
+  initial_data.SetBoolean(
+      "useNewRouteControls",
+      base::FeatureList::IsEnabled(features::kMediaRouterNewRouteController));
+
   web_ui()->CallJavascriptFunctionUnsafe(kSetInitialData, initial_data);
   media_router_ui_->UIInitialized();
 }
@@ -789,6 +850,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) {