Non-Local Join for Media Router and Presentation API

chrome/browser/media/router/media_router_mojo_impl.cc

Index: chrome/browser/media/router/media_router_mojo_impl.cc
diff --git a/chrome/browser/media/router/media_router_mojo_impl.cc b/chrome/browser/media/router/media_router_mojo_impl.cc
index 9fdd6fd14a59c4d9d3f67c011bae75ea6b788239..984c168fbf1e9799ad630db16219d4e3e840c4f6 100644
--- a/chrome/browser/media/router/media_router_mojo_impl.cc
+++ b/chrome/browser/media/router/media_router_mojo_impl.cc
@@ -63,8 +63,9 @@ ConvertToPresentationSessionMessage(interfaces::RouteMessagePtr input) {
 }  // namespace
 
 MediaRouterMojoImpl::MediaRouterMediaRoutesObserver::
-MediaRouterMediaRoutesObserver(MediaRouterMojoImpl* router)
-    : MediaRoutesObserver(router),
+MediaRouterMediaRoutesObserver(MediaRouterMojoImpl* router,
+    const MediaSource::Id source_id)
+    : MediaRoutesObserver(router, source_id),

[imcheng, 2015/11/19 18:55:08]

It looks like you can do MediaRoutesObserver(router) here since you have already
added a default value for |source_id| in MediaRoutesObserver's constructor.

[matt.boetger, 2015/11/24 19:45:23]

Done.

       router_(router) {
   DCHECK(router);
 }
@@ -73,12 +74,22 @@ MediaRouterMojoImpl::MediaRouterMediaRoutesObserver::
 ~MediaRouterMediaRoutesObserver() {
 }
 
+MediaRouterMojoImpl::MediaRoutesQuery::MediaRoutesQuery() = default;
+
+MediaRouterMojoImpl::MediaRoutesQuery::~MediaRoutesQuery() = default;
+
 MediaRouterMojoImpl::MediaSinksQuery::MediaSinksQuery() = default;
 
 MediaRouterMojoImpl::MediaSinksQuery::~MediaSinksQuery() = default;
 
 void MediaRouterMojoImpl::MediaRouterMediaRoutesObserver::OnRoutesUpdated(
-    const std::vector<media_router::MediaRoute>& routes) {
+    const MediaSource::Id source_id,
+    const std::vector<media_router::MediaRoute>& routes,
+    const std::vector<media_router::MediaRoute>& joinable_routes) {
+
+  if (source_id.compare(this->source_id()) !=0)
+    return;
+
   bool has_local_route =
       std::find_if(routes.begin(), routes.end(),
                    [](const media_router::MediaRoute& route) {
@@ -209,7 +220,10 @@ void MediaRouterMojoImpl::OnSinksReceived(
 }
 
 void MediaRouterMojoImpl::OnRoutesUpdated(
-    mojo::Array<interfaces::MediaRoutePtr> routes) {
+    const mojo::String& media_source,
+    mojo::Array<interfaces::MediaRoutePtr> routes,
+    mojo::Array<interfaces::MediaRoutePtr> joinable_routes) {
+  DCHECK(!media_source.is_null());
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG_WITH_INSTANCE(1) << "OnRoutesUpdated";
@@ -217,12 +231,28 @@ void MediaRouterMojoImpl::OnRoutesUpdated(
   std::vector<MediaRoute> routes_converted;
   routes_converted.reserve(routes.size());
 
+  std::vector<MediaRoute> joinable_routes_converted;
+  joinable_routes_converted.reserve(joinable_routes.size());
+
   for (size_t i = 0; i < routes.size(); ++i) {
     routes_converted.push_back(routes[i].To<MediaRoute>());
   }
 
-  FOR_EACH_OBSERVER(MediaRoutesObserver, routes_observers_,
-                    OnRoutesUpdated(routes_converted));
+  for (size_t i = 0; i < joinable_routes.size(); ++i) {
+    joinable_routes_converted.push_back(
+        joinable_routes[i].To<MediaRoute>());
+  }
+
+  auto it = routes_queries_.find(media_source);
+  if (it == routes_queries_.end() ||
+      !(it->second->observers.might_have_observers())) {
+    DVLOG_WITH_INSTANCE(1)
+        << "Received route list without any active observers: " << media_source;
+  } else {
+    FOR_EACH_OBSERVER(MediaRoutesObserver, it->second->observers,
+                      OnRoutesUpdated(media_source.get(), routes_converted,
+                        joinable_routes_converted));
+  }
 }
 
 void MediaRouterMojoImpl::RouteResponseReceived(
@@ -307,6 +337,30 @@ void MediaRouterMojoImpl::JoinRoute(
                         callbacks));
 }
 
+void MediaRouterMojoImpl::JoinRouteByRouteId(
+    const MediaSource::Id& source_id,
+    const MediaRoute::Id& route_id,
+    const GURL& origin,
+    content::WebContents* web_contents,
+    const std::vector<MediaRouteResponseCallback>& callbacks) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!origin.is_valid()) {
+    DVLOG_WITH_INSTANCE(1) << "Invalid origin: " << origin;
+    for (const MediaRouteResponseCallback& callback : callbacks)
+      callback.Run(nullptr, "", "Invalid origin");
+    return;
+  }
+
+  int tab_id = SessionTabHelper::IdForTab(web_contents);
+  std::string presentation_id("non-local-join_");
+  presentation_id += route_id;
+  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoJoinRoute,
+                        base::Unretained(this), source_id, presentation_id,
+                        origin.is_empty() ? "" : origin.spec(), tab_id,
+                        callbacks));
+}
+
 void MediaRouterMojoImpl::CloseRoute(const MediaRoute::Id& route_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ -414,22 +468,36 @@ void MediaRouterMojoImpl::UnregisterMediaSinksObserver(
 void MediaRouterMojoImpl::RegisterMediaRoutesObserver(
     MediaRoutesObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!routes_observers_.HasObserver(observer));
+  const MediaSource::Id source_id = observer->source_id();
+  auto* routes_query = routes_queries_.get(source_id);
+  if (!routes_query) {
+    routes_query = new MediaRoutesQuery;
+    routes_queries_.add(source_id, make_scoped_ptr(routes_query));
+  } else {
+    DCHECK(!routes_query->observers.HasObserver(observer));
+  }
 
+  routes_query->observers.AddObserver(observer);
   RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStartObservingMediaRoutes,
-                        base::Unretained(this)));
-  routes_observers_.AddObserver(observer);
+                        base::Unretained(this), source_id));
 }
 
 void MediaRouterMojoImpl::UnregisterMediaRoutesObserver(
     MediaRoutesObserver* observer) {
-  if (!routes_observers_.HasObserver(observer))
+  const MediaSource::Id source_id = observer->source_id();
+  auto* routes_query = routes_queries_.get(source_id);
+  if (!routes_query || !routes_query->observers.HasObserver(observer)) {
     return;
+  }
 
-  routes_observers_.RemoveObserver(observer);
-  if (!routes_observers_.might_have_observers()) {
+  // If we are removing the final observer for the source, then stop
+  // observing routes for it.
+  // might_have_observers() is reliable here on the assumption that this call
+  // is not inside the ObserverList iteration.
+  routes_query->observers.RemoveObserver(observer);
+  if (!routes_query->observers.might_have_observers()) {
     RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStopObservingMediaRoutes,
-                          base::Unretained(this)));
+                          base::Unretained(this), source_id));
   }
 }
 
@@ -691,14 +759,36 @@ void MediaRouterMojoImpl::DoStopObservingMediaSinks(
   sinks_queries_.erase(source_id);
 }
 
-void MediaRouterMojoImpl::DoStartObservingMediaRoutes() {
+void MediaRouterMojoImpl::DoStartObservingMediaRoutes(
+    const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoStartObservingMediaRoutes";
-  media_route_provider_->StartObservingMediaRoutes();
+
+  // No need to call MRPM if all observers have been removed in the meantime.
+  auto* routes_query = routes_queries_.get(source_id);
+  if (!routes_query || !routes_query->observers.might_have_observers()) {
+    return;
+  }
+
+  DVLOG_WITH_INSTANCE(1) << "MRPM.StartObservingMediaRoutes: " << source_id;
+  media_route_provider_->StartObservingMediaRoutes(source_id);
+  routes_query->is_active = true;
 }
 
-void MediaRouterMojoImpl::DoStopObservingMediaRoutes() {
+void MediaRouterMojoImpl::DoStopObservingMediaRoutes(
+    const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoStopObservingMediaRoutes";
-  media_route_provider_->StopObservingMediaRoutes();
+
+  auto* routes_query = routes_queries_.get(source_id);
+  // No need to call MRPM if observers have been added in the meantime,
+  // or StopObservingMediaSinks has already been called.
+  if (!routes_query || !routes_query->is_active ||
+      routes_query->observers.might_have_observers()) {
+    return;
+  }
+
+  DVLOG_WITH_INSTANCE(1) << "MRPM.StopObservingMediaRoutes: " << source_id;
+  media_route_provider_->StopObservingMediaRoutes(source_id);
+  routes_queries_.erase(source_id);
 }
 
 void MediaRouterMojoImpl::EnqueueTask(const base::Closure& closure) {