[Media Router] Assign each route a current cast mode if possible

chrome/browser/ui/webui/media_router/media_router_ui.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_ui.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 105 matching lines @@
   void OnIssueUpdated(const Issue* issue) override { ui_->SetIssue(issue); }
 
  private:
   // Reference back to the owning MediaRouterUI instance.
   MediaRouterUI* ui_;
 
   DISALLOW_COPY_AND_ASSIGN(UIIssuesObserver);
 };
 
 MediaRouterUI::UIMediaRoutesObserver::UIMediaRoutesObserver(
-    MediaRouter* router, const MediaSource::Id& source_id,
+    MediaRouter* router,
+    const MediaSource::Id& source_id,
+    const SourceCastModeMapCallback& source_cast_mode_callback,
     const RoutesUpdatedCallback& callback)
-    : MediaRoutesObserver(router, source_id), callback_(callback) {
+    : MediaRoutesObserver(router, source_id),
+      source_cast_mode_callback_(source_cast_mode_callback),
+      callback_(callback) {
   DCHECK(!callback_.is_null());
 }
 
 MediaRouterUI::UIMediaRoutesObserver::~UIMediaRoutesObserver() {}
 
 void MediaRouterUI::UIMediaRoutesObserver::OnRoutesUpdated(
     const std::vector<MediaRoute>& routes,
     const std::vector<MediaRoute::Id>& joinable_route_ids) {
   std::vector<MediaRoute> routes_for_display;
   std::vector<MediaRoute::Id> joinable_route_ids_for_display;
@@ skipping 10 matching lines @@
       }
 #endif
       if (ContainsValue(joinable_route_ids, route.media_route_id())) {
         joinable_route_ids_for_display.push_back(route.media_route_id());
       }
 
       routes_for_display.push_back(route);
     }
   }
 
-  callback_.Run(routes_for_display, joinable_route_ids_for_display);
+  auto available_source_map(source_cast_mode_callback_.Run());

[imcheng, 2016/06/06 20:48:19]

I was wondering if we can move the computation of |current_cast_modes| to
MediaRouterUI. That way we don't have to call back to MRUI to get
|available_source_map| and there's no need for |source_cast_mode_callback_|.

[btolsch, 2016/06/06 23:46:52]

That's where I originally put it but it would be much more difficult to test
there.  It seems like I might have to add a routes observer to InitForTest?

[imcheng, 2016/06/07 17:25:42]

Or you could just modify an existing test that invokes
|MediaRouterUI::OnRoutesUpdated()| and then assert on |current_cast_modes_|?

[btolsch, 2016/06/07 19:45:34]

Done. Modified new tests to invoke MediaRouterUI::OnRoutesUpdated and use
existing source observers.

+  std::unordered_map<MediaRoute::Id, MediaCastMode> current_cast_modes;
+  for (const auto& route : routes_for_display) {
+    auto source_entry = available_source_map.find(route.media_source().id());
+    if (source_entry != end(available_source_map)) {

[imcheng, 2016/06/06 20:48:19]

nit: prefer available_source_map.end().

[btolsch, 2016/06/06 23:46:53]

Done.

+      current_cast_modes.insert(
+          std::make_pair(route.media_route_id(), source_entry->second));
+    }
+  }
+
+  callback_.Run(routes_for_display, joinable_route_ids_for_display,
+                current_cast_modes);
 }
 
 MediaRouterUI::MediaRouterUI(content::WebUI* web_ui)
     : ConstrainedWebDialogUI(web_ui),
       handler_(new MediaRouterWebUIMessageHandler(this)),
       ui_initialized_(false),
       current_route_request_id_(-1),
       route_request_counter_(0),
       initiator_(nullptr),
       router_(nullptr),
@@ skipping 47 matching lines @@
   DCHECK(!query_result_manager_.get());
 
   presentation_service_delegate_ = delegate;
   presentation_service_delegate_->AddDefaultPresentationRequestObserver(this);
   InitCommon(presentation_service_delegate_->web_contents());
   if (presentation_service_delegate_->HasDefaultPresentationRequest()) {
     OnDefaultPresentationChanged(
         presentation_service_delegate_->GetDefaultPresentationRequest());
   } else {
     // Register for MediaRoute updates without a media source.
-    routes_observer_.reset(new UIMediaRoutesObserver(router_, MediaSource::Id(),
-          base::Bind(&MediaRouterUI::OnRoutesUpdated, base::Unretained(this))));
+    routes_observer_.reset(new UIMediaRoutesObserver(
+        router_, MediaSource::Id(),
+        base::Bind(&MediaRouterUI::GetAvailableSourceMap,
+                   base::Unretained(this)),
+        base::Bind(&MediaRouterUI::OnRoutesUpdated, base::Unretained(this))));
   }
 }
 
 void MediaRouterUI::InitWithPresentationSessionRequest(
     content::WebContents* initiator,
     const base::WeakPtr<PresentationServiceDelegateImpl>& delegate,
     std::unique_ptr<CreatePresentationConnectionRequest>
         create_session_request) {
   DCHECK(initiator);
   DCHECK(create_session_request);
@@ skipping 56 matching lines @@
 void MediaRouterUI::OnDefaultPresentationChanged(
     const PresentationRequest& presentation_request) {
   MediaSource source = presentation_request.GetMediaSource();
   presentation_request_.reset(new PresentationRequest(presentation_request));
   query_result_manager_->StartSinksQuery(
       MediaCastMode::DEFAULT, source,
       presentation_request_->frame_url().GetOrigin());
   // Register for MediaRoute updates.
   routes_observer_.reset(new UIMediaRoutesObserver(
       router_, source.id(),
+      base::Bind(&MediaRouterUI::GetAvailableSourceMap, base::Unretained(this)),
       base::Bind(&MediaRouterUI::OnRoutesUpdated, base::Unretained(this))));
 
   UpdateCastModes();
 }
 
 void MediaRouterUI::OnDefaultPresentationRemoved() {
   presentation_request_.reset();
   query_result_manager_->StopSinksQuery(MediaCastMode::DEFAULT);
   // Register for MediaRoute updates without a media source.
   routes_observer_.reset(new UIMediaRoutesObserver(
-        router_, MediaSource::Id(),
-        base::Bind(&MediaRouterUI::OnRoutesUpdated, base::Unretained(this))));
+      router_, MediaSource::Id(),
+      base::Bind(&MediaRouterUI::GetAvailableSourceMap, base::Unretained(this)),
+      base::Bind(&MediaRouterUI::OnRoutesUpdated, base::Unretained(this))));
   UpdateCastModes();
 }
 
 void MediaRouterUI::UpdateCastModes() {
   // Gets updated cast modes from |query_result_manager_| and forwards it to UI.
   query_result_manager_->GetSupportedCastModes(&cast_modes_);
   if (ui_initialized_) {
     handler_->UpdateCastModes(cast_modes_, GetPresentationRequestSourceName());
   }
 }
@@ skipping 178 matching lines @@
         return sink1.sink.id() < sink2.sink.id();
       });
 
   if (ui_initialized_) handler_->UpdateSinks(sinks_);
 }
 
 void MediaRouterUI::SetIssue(const Issue* issue) {
   if (ui_initialized_) handler_->UpdateIssue(issue);
 }
 
+std::unordered_map<MediaSource::Id, MediaCastMode>
+MediaRouterUI::GetAvailableSourceMap() {
+  std::unordered_map<MediaSource::Id, MediaCastMode> available_source_map;
+  for (const auto& cast_mode : cast_modes_) {
+    available_source_map.insert(std::make_pair(
+        query_result_manager_->GetSourceForCastMode(cast_mode).id(),
+        cast_mode));
+  }
+  return available_source_map;
+}
+
 void MediaRouterUI::OnRoutesUpdated(
     const std::vector<MediaRoute>& routes,
-    const std::vector<MediaRoute::Id>& joinable_route_ids) {
+    const std::vector<MediaRoute::Id>& joinable_route_ids,
+    const std::unordered_map<MediaRoute::Id, MediaCastMode>&
+        current_cast_modes) {
   routes_ = routes;
   joinable_route_ids_ = joinable_route_ids;
-  if (ui_initialized_) handler_->UpdateRoutes(routes_, joinable_route_ids_);
+  current_cast_modes_ = current_cast_modes;
+
+  if (ui_initialized_)
+    handler_->UpdateRoutes(routes_, joinable_route_ids_, current_cast_modes_);
 }
 
 void MediaRouterUI::OnRouteResponseReceived(
     int route_request_id,
     const MediaSink::Id& sink_id,
     MediaCastMode cast_mode,
     const base::string16& presentation_request_source_name,
     const RouteRequestResult& result) {
   DVLOG(1) << "OnRouteResponseReceived";
   // If we receive a new route that we aren't expecting, do nothing.
@@ skipping 123 matching lines @@
         base::Time::Now() - start_time_);
     start_time_ = base::Time();
   }
 }
 
 void MediaRouterUI::UpdateMaxDialogHeight(int height) {
   handler_->UpdateMaxDialogHeight(height);
 }
 
 }  // namespace media_router