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 <string>
 
 #include "base/guid.h"
 #include "base/strings/string_util.h"
@@ skipping 72 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,
+    MediaRouter* router, const MediaSource::Id source_id,
     const RoutesUpdatedCallback& callback)
-    : MediaRoutesObserver(router), callback_(callback) {
+    : MediaRoutesObserver(router, source_id), callback_(callback) {
   DCHECK(!callback_.is_null());
 }
 
 MediaRouterUI::UIMediaRoutesObserver::~UIMediaRoutesObserver() {}
 
 void MediaRouterUI::UIMediaRoutesObserver::OnRoutesUpdated(
-    const std::vector<MediaRoute>& routes) {
+    const MediaSource::Id source_id,
+    const std::vector<MediaRoute>& routes,
+    const std::vector<MediaRoute>& joinable_routes) {
+  if (source_id.compare(this->source_id()) != 0)
+    return;
+
   std::vector<MediaRoute> routes_for_display;
+  std::vector<MediaRoute> joinable_routes_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
       routes_for_display.push_back(route);
     }
   }
+  for (const MediaRoute& route: joinable_routes) {
+    if (route.for_display()) {
+#ifndef NDEBUG
+      for (const MediaRoute& existing_route : joinable_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
+      joinable_routes_for_display.push_back(route);
+    }
+  }
 
-  callback_.Run(routes_for_display);
+  callback_.Run(routes_for_display, joinable_routes_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 71 matching lines @@
 }
 
 void MediaRouterUI::InitCommon(content::WebContents* initiator,
                                const MediaSource& default_source,
                                const GURL& default_frame_url) {
   DCHECK(initiator);
   DCHECK(router_);
 
   // Register for MediaRoute updates.
   routes_observer_.reset(new UIMediaRoutesObserver(
-      router_,
+      router_, default_source.id(),
       base::Bind(&MediaRouterUI::OnRoutesUpdated, base::Unretained(this))));
 
   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(
@@ skipping 104 matching lines @@
   route_creation_timer_.Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kCreateRouteTimeoutSeconds),
       this, &MediaRouterUI::RouteCreationTimeout);
 
   router_->CreateRoute(source.id(), sink_id, origin,
                        initiator_,
                        route_response_callbacks);
   return true;
 }
 
+bool MediaRouterUI::JoinRoute(const MediaSink::Id& sink_id,
+                              const MediaRoute::Id& route_id) {
+  DCHECK(query_result_manager_.get());
+  DCHECK(initiator_);
+
+  current_route_request_id_ = ++route_request_counter_;
+  GURL origin = frame_url_.GetOrigin();
+
+  MediaSource source =
+      query_result_manager_->GetSourceForCastMode(MediaCastMode::DEFAULT);
+
+  if (source.Empty()) {
+    LOG(ERROR) << "No MediaSource to join";
+    return false;
+  }
+
+  DCHECK(origin.is_valid());
+
+  std::vector<MediaRouteResponseCallback> route_response_callbacks;
+  route_response_callbacks.push_back(base::Bind(
+      &MediaRouterUI::OnRouteResponseReceived, weak_factory_.GetWeakPtr(),
+      current_route_request_id_, sink_id));
+
+  if (presentation_service_delegate_) {
+    route_response_callbacks.push_back(
+        base::Bind(&PresentationServiceDelegateImpl::OnRouteResponse,
+                   presentation_service_delegate_));
+  }
+
+  // Start the timer.
+  route_creation_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromSeconds(kCreateRouteTimeoutSeconds), this,
+      &MediaRouterUI::RouteCreationTimeout);
+  router_->JoinRouteByRouteId(source.id(), route_id, origin,
+                     initiator_, route_response_callbacks);
+  return true;
+}
+
 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);
 }
 
 void MediaRouterUI::OnResultsUpdated(
     const std::vector<MediaSinkWithCastModes>& sinks) {
   sinks_ = sinks;
   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>& joinable_routes) {
   routes_ = routes;
+  joinable_routes_ = joinable_routes;
   if (ui_initialized_)
-    handler_->UpdateRoutes(routes_);
+    handler_->UpdateRoutes(routes_, joinable_routes_);
 }
 
 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_)
@@ skipping 34 matching lines @@
 
 std::string MediaRouterUI::GetFrameURLHost() const {
   return GetHostFromURL(frame_url_);
 }
 
 const std::string& MediaRouterUI::GetRouteProviderExtensionId() const {
   return router_->media_route_provider_extension_id();
 }
 
 }  // namespace media_router