Add GetCurrentRoutes() to MediaRouter API, ensure dialog has routes at init

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 <unordered_map>
 #include <utility>
@@ skipping 117 matching lines @@
     const RoutesUpdatedCallback& callback)
     : MediaRoutesObserver(router, source_id), 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;
-  for (const MediaRoute& route : routes) {
-    if (route.for_display()) {
-#ifndef NDEBUG
-      for (const MediaRoute& existing_route : routes_for_display) {
-        if (existing_route.media_sink_id() == route.media_sink_id()) {
-          DVLOG(2) << "Received another route for display with the same sink"
-                   << " id as an existing route. " << route.media_route_id()
-                   << " has the same sink id as "
-                   << existing_route.media_sink_id() << ".";
-        }
-      }
-#endif
-      if (base::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);
+  callback_.Run(routes, joinable_route_ids);
 }
 
 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 119 matching lines @@
   // Desktop mirror mode is always available.
   query_result_manager_->SetSourcesForCastMode(
       MediaCastMode::DESKTOP_MIRROR, {MediaSourceForDesktop()}, origin);
   initiator_ = initiator;
   SessionID::id_type tab_id = SessionTabHelper::IdForTab(initiator);
   if (tab_id != -1) {
     MediaSource mirroring_source(MediaSourceForTab(tab_id));
     query_result_manager_->SetSourcesForCastMode(MediaCastMode::TAB_MIRROR,
                                                  {mirroring_source}, origin);
   }
+
   UpdateCastModes();
+
+  // Get the current list of media routes, so that the WebUI will have routes
+  // information at initialization.
+  OnRoutesUpdated(router_->GetCurrentRoutes(), std::vector<MediaRoute::Id>());
 }
 
 void MediaRouterUI::InitForTest(
     MediaRouter* router,
     content::WebContents* initiator,
     MediaRouterWebUIMessageHandler* handler,
     std::unique_ptr<CreatePresentationConnectionRequest>
         create_session_request) {
   router_ = router;
   handler_ = handler;
@@ skipping 32 matching lines @@
 }
 
 void MediaRouterUI::UpdateCastModes() {
   // Gets updated cast modes from |query_result_manager_| and forwards it to UI.
   cast_modes_ = query_result_manager_->GetSupportedCastModes();
   if (ui_initialized_) {
     handler_->UpdateCastModes(cast_modes_, GetPresentationRequestSourceName());
   }
 }
 
+void MediaRouterUI::UpdateRoutesToCastModesMapping() {
+  std::unordered_map<MediaSource::Id, MediaCastMode> available_source_map;
+  for (const auto& cast_mode : cast_modes_) {
+    for (const auto& source :
+         query_result_manager_->GetSourcesForCastMode(cast_mode)) {
+      available_source_map.insert(std::make_pair(source.id(), cast_mode));
+    }
+  }
+
+  routes_and_cast_modes_.clear();
+  for (const auto& route : routes_) {
+    auto source_entry = available_source_map.find(route.media_source().id());
+    if (source_entry != available_source_map.end()) {
+      routes_and_cast_modes_.insert(
+          std::make_pair(route.media_route_id(), source_entry->second));
+    }
+  }
+}
+
 void MediaRouterUI::Close() {
   ConstrainedWebDialogDelegate* delegate = GetConstrainedDelegate();
   if (delegate) {
     delegate->GetWebDialogDelegate()->OnDialogClosed(std::string());
     delegate->OnDialogCloseFromWebUI();
   }
 }
 
 void MediaRouterUI::UIInitialized() {
   TRACE_EVENT_NESTABLE_ASYNC_END0("media_router", "UI", initiator_);
@@ skipping 158 matching lines @@
   if (ui_initialized_) handler_->UpdateSinks(sinks_);
 }
 
 void MediaRouterUI::SetIssue(const Issue* issue) {
   if (ui_initialized_) handler_->UpdateIssue(issue);
 }
 
 void MediaRouterUI::OnRoutesUpdated(
     const std::vector<MediaRoute>& routes,
     const std::vector<MediaRoute::Id>& joinable_route_ids) {
-  routes_ = routes;
-  joinable_route_ids_ = joinable_route_ids;
+  routes_.clear();
+  joinable_route_ids_.clear();
 
-  std::unordered_map<MediaSource::Id, MediaCastMode> available_source_map;
-  for (const auto& cast_mode : cast_modes_) {
-    for (const auto& source :
-         query_result_manager_->GetSourcesForCastMode(cast_mode)) {
-      available_source_map.insert(std::make_pair(source.id(), cast_mode));
+  for (const MediaRoute& route : routes) {
+    if (route.for_display()) {
+#ifndef NDEBUG
+      for (const MediaRoute& existing_route : routes_) {
+        if (existing_route.media_sink_id() == route.media_sink_id()) {
+          DVLOG(2) << "Received another route for display with the same sink"
+                   << " id as an existing route. " << route.media_route_id()
+                   << " has the same sink id as "
+                   << existing_route.media_sink_id() << ".";
+        }
+      }
+#endif
+      if (base::ContainsValue(joinable_route_ids, route.media_route_id())) {
+        joinable_route_ids_.push_back(route.media_route_id());
+      }
+
+      routes_.push_back(route);
     }
   }
-
-  current_cast_modes_.clear();
-  for (const auto& route : routes) {
-    auto source_entry = available_source_map.find(route.media_source().id());
-    if (source_entry != available_source_map.end()) {
-      current_cast_modes_.insert(
-          std::make_pair(route.media_route_id(), source_entry->second));
-    }
-  }
+  UpdateRoutesToCastModesMapping();
 
   if (ui_initialized_)
-    handler_->UpdateRoutes(routes_, joinable_route_ids_, current_cast_modes_);
+    handler_->UpdateRoutes(routes_, joinable_route_ids_,
+                           routes_and_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 127 matching lines @@
         base::Time::Now() - start_time_);
     start_time_ = base::Time();
   }
 }
 
 void MediaRouterUI::UpdateMaxDialogHeight(int height) {
   handler_->UpdateMaxDialogHeight(height);
 }
 
 }  // namespace media_router