Non-Local Join for Media Router and Presentation API

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 "base/guid.h"
@@ skipping 85 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 RoutesUpdatedCallback& callback)
-    : MediaRoutesObserver(router), callback_(callback) {
+    MediaRouter* router,
+    const RoutesUpdatedCallback& callback) :
+  UIMediaRoutesObserver(router, MediaSource::Id(), callback) {
+}
+
+MediaRouterUI::UIMediaRoutesObserver::UIMediaRoutesObserver(
+    MediaRouter* router, const MediaSource::Id& source_id,
+    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>& 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 (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);
+  callback_.Run(routes_for_display, joinable_route_ids_for_display);
 }
 
 MediaRouterUI::MediaRouterUI(content::WebUI* web_ui)
     : ConstrainedWebDialogUI(web_ui),
       handler_(new MediaRouterWebUIMessageHandler(this)),
       ui_initialized_(false),
       requesting_route_for_default_source_(false),
       current_route_request_id_(-1),
       route_request_counter_(0),
       initiator_(nullptr),
@@ skipping 70 matching lines @@
   InitCommon(initiator);
   OnDefaultPresentationChanged(create_session_request_->presentation_request());
 }
 
 void MediaRouterUI::InitCommon(content::WebContents* initiator) {
   DCHECK(initiator);
   DCHECK(router_);
 
   TRACE_EVENT_NESTABLE_ASYNC_INSTANT1("media_router", "UI", initiator,
                                       "MediaRouterUI::InitCommon", this);
-  // Register for MediaRoute updates.
+  // Register for MediaRoute updates without a media source.
   routes_observer_.reset(new UIMediaRoutesObserver(

[imcheng, 2015/12/29 00:24:42]

This should go somewhere else now that we set up routes_observer_ in
OnDefaultPresentation{Changed,Removed}. The only case where
OnDefaultPresentationChanged() isn't invoked during Init*() is if the condition
in L209 is false -- so I would move this line to an else block there.

[matt.boetger, 2016/01/05 00:19:48]

Done.

-      router_,
-      base::Bind(&MediaRouterUI::OnRoutesUpdated, base::Unretained(this))));
+        router_,
+        base::Bind(&MediaRouterUI::OnRoutesUpdated, base::Unretained(this))));
 
   // Create |collator_| before |query_result_manager_| so that |collator_| is
   // already set up when we get a callback from |query_result_manager_|.
   UErrorCode error = U_ZERO_ERROR;
   const std::string& locale = g_browser_process->GetApplicationLocale();
   collator_.reset(
       icu::Collator::createInstance(icu::Locale(locale.c_str()), error));
   if (U_FAILURE(error)) {
     DLOG(ERROR) << "Failed to create collator for locale " << locale;
     collator_.reset();
   }
 
   query_result_manager_.reset(new QueryResultManager(router_));
   query_result_manager_->AddObserver(this);
 
   // These modes are always available.
   query_result_manager_->StartSinksQuery(MediaCastMode::DESKTOP_MIRROR,
                                          MediaSourceForDesktop());
   initiator_ = initiator;
   MediaSource mirroring_source(
       MediaSourceForTab(SessionTabHelper::IdForTab(initiator)));
   query_result_manager_->StartSinksQuery(MediaCastMode::TAB_MIRROR,
                                          mirroring_source);
   UpdateCastModes();
 }
 
 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, presentation_request_->GetMediaSource());
+  query_result_manager_->StartSinksQuery(MediaCastMode::DEFAULT, source);
+  // Register for MediaRoute updates.
+  routes_observer_.reset(new UIMediaRoutesObserver(
+      router_, source.id(),
+      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_,
+        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 11 matching lines @@
   ui_initialized_ = true;
 
   // Register for Issue updates.
   if (!issues_observer_)
     issues_observer_.reset(new UIIssuesObserver(router_, this));
   issues_observer_->RegisterObserver();
 }
 
 bool MediaRouterUI::CreateRoute(const MediaSink::Id& sink_id,
                                 MediaCastMode cast_mode) {
+  return CreateOrConnectRoute(sink_id, cast_mode, MediaRoute::Id());
+}
+
+bool MediaRouterUI::CreateOrConnectRoute(const MediaSink::Id& sink_id,
+                                              MediaCastMode cast_mode,
+                                              const MediaRoute::Id& route_id) {
   DCHECK(query_result_manager_.get());
   DCHECK(initiator_);
 
   // Note that there is a rarely-encountered bug, where the MediaCastMode to
   // MediaSource mapping could have been updated, between when the user clicked
   // on the UI to start a create route request, and when this function is
   // called. However, since the user does not have visibility into the
   // MediaSource, and that it occurs very rarely in practice, we leave it as-is
   // for now.
   MediaSource source = query_result_manager_->GetSourceForCastMode(cast_mode);
@@ skipping 49 matching lines @@
           base::Bind(&PresentationServiceDelegateImpl::OnRouteResponse,
                      presentation_service_delegate_, *presentation_request_));
     }
   }
 
   // Start the timer.
   route_creation_timer_.Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kCreateRouteTimeoutSeconds), this,
       &MediaRouterUI::RouteCreationTimeout);
 
-  router_->CreateRoute(source.id(), sink_id, origin, initiator_,
-                       route_response_callbacks);
+  if (route_id.empty()) {
+    router_->CreateRoute(source.id(), sink_id, origin, initiator_,
+                         route_response_callbacks);
+  } else {
+    router_->ConnectRouteByRouteId(source.id(), route_id, origin,
+                                   initiator_, route_response_callbacks);
+  }
   return true;
 }
 
+bool MediaRouterUI::ConnectRemoteRoute(const MediaSink::Id& sink_id,
+                                       const MediaRoute::Id& route_id) {
+  return CreateOrConnectRoute(sink_id, MediaCastMode::DEFAULT, route_id);
+}
+
 void MediaRouterUI::CloseRoute(const MediaRoute::Id& route_id) {
   router_->CloseRoute(route_id);
 }
 
 void MediaRouterUI::AddIssue(const Issue& issue) { router_->AddIssue(issue); }
 
 void MediaRouterUI::ClearIssue(const std::string& issue_id) {
   router_->ClearIssue(issue_id);
 }
 
@@ skipping 24 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);
 }
 
-void MediaRouterUI::OnRoutesUpdated(const std::vector<MediaRoute>& routes) {
+void MediaRouterUI::OnRoutesUpdated(
+    const std::vector<MediaRoute>& routes,
+    const std::vector<MediaRoute::Id>& joinable_route_ids) {
   routes_ = routes;
-  if (ui_initialized_) handler_->UpdateRoutes(routes_);
+  joinable_route_ids_ = joinable_route_ids;
+  if (ui_initialized_) handler_->UpdateRoutes(routes_, joinable_route_ids_);
 }
 
 void MediaRouterUI::OnRouteResponseReceived(const int route_request_id,
                                             const MediaSink::Id& sink_id,
                                             const MediaRoute* route,
                                             const std::string& presentation_id,
                                             const std::string& error) {
   DVLOG(1) << "OnRouteResponseReceived";
   // If we receive a new route that we aren't expecting, do nothing.
   if (route_request_id != current_route_request_id_) return;
@@ skipping 70 matching lines @@
 
 void MediaRouterUI::OnUIInitialDataReceived() {
   if (!start_time_.is_null()) {
     MediaRouterMetrics::RecordMediaRouterDialogLoaded(
         base::Time::Now() - start_time_);
     start_time_ = base::Time();
   }
 }
 
 }  // namespace media_router