[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 kOnMediaControllerAvailable[] = "onMediaControllerAvailable";
+const char kOnMediaControllerClosed[] = "onMediaControllerClosed";
+const char kPauseCurrentMedia[] = "pauseCurrentMedia";
+const char kPlayCurrentMedia[] = "playCurrentMedia";
+const char kSeekCurrentMedia[] = "seekCurrentMedia";
+const char kSetCurrentMediaMute[] = "setCurrentMediaMute";
+const char kSetCurrentMediaVolume[] = "setCurrentMediaVolume";
 
 // 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) {
+  current_media_status_ = base::make_optional<MediaStatus>(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);
+}
+
 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(
+      kOnMediaControllerAvailable,
+      base::Bind(&MediaRouterWebUIMessageHandler::OnMediaControllerAvailable,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kOnMediaControllerClosed,
+      base::Bind(&MediaRouterWebUIMessageHandler::OnMediaControllerClosed,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kPauseCurrentMedia,
+      base::Bind(&MediaRouterWebUIMessageHandler::OnPauseCurrentMedia,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kPlayCurrentMedia,
+      base::Bind(&MediaRouterWebUIMessageHandler::OnPlayCurrentMedia,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kSeekCurrentMedia,
+      base::Bind(&MediaRouterWebUIMessageHandler::OnSeekCurrentMedia,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kSetCurrentMediaMute,
+      base::Bind(&MediaRouterWebUIMessageHandler::OnSetCurrentMediaMute,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kSetCurrentMediaVolume,
+      base::Bind(&MediaRouterWebUIMessageHandler::OnSetCurrentMediaVolume,
+                 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::OnMediaControllerAvailable(
+    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_->OnMediaControllerUIAvailable(route_id);
+}
+
+void MediaRouterWebUIMessageHandler::OnMediaControllerClosed(
+    const base::ListValue* args) {
+  current_media_status_.reset();
+  media_router_ui_->OnMediaControllerUIClosed();
+}
+
+void MediaRouterWebUIMessageHandler::OnPauseCurrentMedia(
+    const base::ListValue* args) {
+  const MediaRouteController* route_controller =
+      media_router_ui_->GetMediaRouteController();
+  if (route_controller)
+    route_controller->Pause();
+}
+
+void MediaRouterWebUIMessageHandler::OnPlayCurrentMedia(
+    const base::ListValue* args) {
+  const MediaRouteController* route_controller =
+      media_router_ui_->GetMediaRouteController();
+  if (route_controller)
+    route_controller->Play();
+}
+
+void MediaRouterWebUIMessageHandler::OnSeekCurrentMedia(
+    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;
+  }
+  base::TimeDelta time_delta = base::TimeDelta::FromSeconds(time);
+  const MediaRouteController* route_controller =
+      media_router_ui_->GetMediaRouteController();
+  if (route_controller && current_media_status_ &&
+      time_delta >= base::TimeDelta() &&
+      time_delta <= current_media_status_->duration) {

[imcheng, 2017/05/02 19:16:10]

Is this validation necessary or can it be done in the controller implementation?
(So we can get rid of current_media_status_)

[takumif, 2017/05/02 21:37:37]

Yes, we could do the validation in the extension, but I'm more inclined to catch
invalid inputs as soon as possible, rather than relying on the controller
implementation. I feel uncomfortable using the mojo controller interface with
potentially invalid arguments.

+    route_controller->Seek(time_delta);
+  }
+}
+
+void MediaRouterWebUIMessageHandler::OnSetCurrentMediaMute(
+    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;
+  }
+  const MediaRouteController* route_controller =
+      media_router_ui_->GetMediaRouteController();
+  if (route_controller)
+    route_controller->SetMute(mute);
+}
+
+void MediaRouterWebUIMessageHandler::OnSetCurrentMediaVolume(
+    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;
+  }
+  const MediaRouteController* route_controller =
+      media_router_ui_->GetMediaRouteController();
+  if (route_controller && volume >= 0 && volume <= 1)
+    route_controller->SetVolume(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