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

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 <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/user_metrics.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/media/router/media_router_metrics.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #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"
 #include "components/prefs/pref_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "content/public/browser/web_ui.h"
 #include "extensions/common/constants.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace media_router {
@@ skipping 20 matching lines @@
 const char kReportInitialState[] = "reportInitialState";
 const char kReportNavigateToView[] = "reportNavigateToView";
 const char kReportRouteCreationOutcome[] = "reportRouteCreationOutcome";
 const char kReportRouteCreation[] = "reportRouteCreation";
 const char kReportSelectedCastMode[] = "reportSelectedCastMode";
 const char kReportSinkCount[] = "reportSinkCount";
 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";
 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(
     const std::vector<MediaSinkWithCastModes>& sinks,
     const AccountInfo& account_info) {
   std::unique_ptr<base::DictionaryValue> sink_list_and_identity(
       new base::DictionaryValue);
   bool show_email = false;
   bool show_domain = false;
   std::string user_domain;
@@ skipping 220 matching lines @@
 void MediaRouterWebUIMessageHandler::ClearIssue() {
   DVLOG(2) << "ClearIssue";
   web_ui()->CallJavascriptFunctionUnsafe(kSetIssue, base::Value());
 }
 
 void MediaRouterWebUIMessageHandler::UpdateMaxDialogHeight(int height) {
   DVLOG(2) << "UpdateMaxDialogHeight";
   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,
       base::Bind(&MediaRouterWebUIMessageHandler::OnRequestInitialData,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       kCreateRoute,
       base::Bind(&MediaRouterWebUIMessageHandler::OnCreateRoute,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
@@ skipping 66 matching lines @@
           &MediaRouterWebUIMessageHandler::OnReportTimeToInitialActionClose,
           base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       kSearchSinksAndCreateRoute,
       base::Bind(&MediaRouterWebUIMessageHandler::OnSearchSinksAndCreateRoute,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       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(
     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",
@@ skipping 14 matching lines @@
   initial_data.Set("castModes", std::move(cast_modes_list));
 
   // If the cast mode last chosen for the current origin is tab mirroring,
   // that should be the cast mode initially selected in the dialog. Otherwise
   // the initial cast mode should be chosen automatically by the dialog.
   bool use_tab_mirroring =
       base::ContainsKey(cast_modes, MediaCastMode::TAB_MIRROR) &&
       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();
 }
 
 void MediaRouterWebUIMessageHandler::OnCreateRoute(
     const base::ListValue* args) {
   DVLOG(1) << "OnCreateRoute";
   const base::DictionaryValue* args_dict = nullptr;
   std::string sink_id;
   int cast_mode_num = -1;
@@ skipping 335 matching lines @@
       static_cast<MediaCastMode>(cast_mode_num));
 }
 
 void MediaRouterWebUIMessageHandler::OnInitialDataReceived(
     const base::ListValue* args) {
   DVLOG(1) << "OnInitialDataReceived";
   media_router_ui_->OnUIInitialDataReceived();
   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) {
   if (action_type == IssueInfo::Action::LEARN_MORE) {
     std::string learn_more_url = GetLearnMoreUrl(args);
     if (learn_more_url.empty())
       return false;
     std::unique_ptr<base::ListValue> open_args(new base::ListValue);
     open_args->AppendString(learn_more_url);
     web_ui()->CallJavascriptFunctionUnsafe(kWindowOpen, *open_args);
@@ skipping 92 matching lines @@
   }
 
   return value;
 }
 
 void MediaRouterWebUIMessageHandler::SetWebUIForTest(content::WebUI* web_ui) {
   set_web_ui(web_ui);
 }
 
 }  // namespace media_router