Non-Local Join for Media Router and Presentation API

chrome/browser/media/router/media_router_mojo_impl.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/media/router/media_router_mojo_impl.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 56 matching lines @@
 MediaRouterMediaRoutesObserver(MediaRouterMojoImpl* router)
     : MediaRoutesObserver(router),
       router_(router) {
   DCHECK(router);
 }
 
 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 std::vector<media_router::MediaRoute>& routes,
+    const std::vector<media_router::MediaRoute::Id>& joinable_route_ids) {
   bool has_local_display_route =
       std::find_if(routes.begin(), routes.end(),
                    [](const media_router::MediaRoute& route) {
                      return route.is_local() && route.for_display();
                    }) != routes.end();
 
   // |this| will be deleted in UpdateHasLocalDisplayRoute() if
   // |has_local_display_route| is false. Note that ObserverList supports
   // removing an observer while iterating through it.
   router_->UpdateHasLocalDisplayRoute(has_local_display_route);
@@ skipping 92 matching lines @@
   const Issue& issue_converted = issue.To<Issue>();
   issue_manager_.AddIssue(issue_converted);
 }
 
 void MediaRouterMojoImpl::OnSinksReceived(
     const mojo::String& media_source,
     mojo::Array<interfaces::MediaSinkPtr> sinks) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG_WITH_INSTANCE(1) << "OnSinksReceived";
+  if (!HasSinksObservers(media_source)) {
+    DVLOG_WITH_INSTANCE(1)
+        << "Received sink list without any active observers: " << media_source;
+    return;
+  }
+
   std::vector<MediaSink> sinks_converted;
   sinks_converted.reserve(sinks.size());
 
   for (size_t i = 0; i < sinks.size(); ++i) {
     sinks_converted.push_back(sinks[i].To<MediaSink>());
   }
 
-  auto it = sinks_queries_.find(media_source);
-  if (it == sinks_queries_.end() ||
-      !(it->second->observers.might_have_observers())) {
-    DVLOG_WITH_INSTANCE(1)
-        << "Received sink list without any active observers: " << media_source;
-  } else {
-    FOR_EACH_OBSERVER(MediaSinksObserver, it->second->observers,
-                      OnSinksReceived(sinks_converted));
-  }
+  auto sinks_query = sinks_queries_.get(media_source);
+  FOR_EACH_OBSERVER(MediaSinksObserver, sinks_query->observers,
+                    OnSinksReceived(sinks_converted));
 }
 
 void MediaRouterMojoImpl::OnRoutesUpdated(
-    mojo::Array<interfaces::MediaRoutePtr> routes) {
+    const mojo::String& media_source,
+    mojo::Array<interfaces::MediaRoutePtr> routes,
+    mojo::Array<mojo::String> joinable_route_ids) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG_WITH_INSTANCE(1) << "OnRoutesUpdated";
+  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;
+    return;
+  }
 
   std::vector<MediaRoute> routes_converted;
   routes_converted.reserve(routes.size());
 
-  for (size_t i = 0; i < routes.size(); ++i) {
+  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));
+  std::vector<MediaRoute::Id> joinable_routes_converted;
+  joinable_routes_converted.reserve(joinable_route_ids.size());
+
+  for (size_t i = 0; i < joinable_route_ids.size(); ++i)
+    joinable_routes_converted.push_back(joinable_route_ids[i]);
+
+  FOR_EACH_OBSERVER(MediaRoutesObserver, it->second->observers,
+                    OnRoutesUpdated(routes_converted,
+                                    joinable_routes_converted));
 }
 
 void MediaRouterMojoImpl::RouteResponseReceived(
     const std::string& presentation_id,
     const std::vector<MediaRouteResponseCallback>& callbacks,
     interfaces::MediaRoutePtr media_route,
     const mojo::String& error_text) {
   scoped_ptr<MediaRoute> route;
   std::string actual_presentation_id;
   std::string error;
@@ skipping 69 matching lines @@
   }
 
   SetWakeReason(MediaRouteProviderWakeReason::JOIN_ROUTE);
   int tab_id = SessionTabHelper::IdForTab(web_contents);
   RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoJoinRoute,
                         base::Unretained(this), source_id, presentation_id,
                         origin.is_empty() ? "" : origin.spec(), tab_id,
                         callbacks));
 }
 
+void MediaRouterMojoImpl::ConnectRouteByRouteId(
+    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);
+  RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoConnectRouteByRouteId,
+                        base::Unretained(this), source_id, route_id,
+                        origin.is_empty() ? "" : origin.spec(), tab_id,
+                        callbacks));
+}
+
 void MediaRouterMojoImpl::CloseRoute(const MediaRoute::Id& route_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   SetWakeReason(MediaRouteProviderWakeReason::CLOSE_ROUTE);
   RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoCloseRoute,
                         base::Unretained(this), route_id));
 }
 
 void MediaRouterMojoImpl::SendRouteMessage(
     const MediaRoute::Id& route_id,
@@ skipping 96 matching lines @@
                             base::Unretained(this), source_id));
     } else {
       sinks_queries_.erase(source_id);
     }
   }
 }
 
 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);
   SetWakeReason(MediaRouteProviderWakeReason::START_OBSERVING_MEDIA_ROUTES);
   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()) {
     SetWakeReason(MediaRouteProviderWakeReason::STOP_OBSERVING_MEDIA_ROUTES);
     RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStopObservingMediaRoutes,
-                          base::Unretained(this)));
+                          base::Unretained(this), source_id));
   }
 }
 
 void MediaRouterMojoImpl::RegisterIssuesObserver(IssuesObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   issue_manager_.RegisterObserver(observer);
 }
 
 void MediaRouterMojoImpl::UnregisterIssuesObserver(IssuesObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 83 matching lines @@
     int tab_id,
     const std::vector<MediaRouteResponseCallback>& callbacks) {
   DVLOG_WITH_INSTANCE(1) << "DoJoinRoute " << source_id
                          << ", presentation ID: " << presentation_id;
   media_route_provider_->JoinRoute(
       source_id, presentation_id, origin, tab_id,
       base::Bind(&MediaRouterMojoImpl::RouteResponseReceived,
           base::Unretained(this), presentation_id, callbacks));
 }
 
+void MediaRouterMojoImpl::DoConnectRouteByRouteId(
+    const MediaSource::Id& source_id,
+    const MediaRoute::Id& route_id,
+    const std::string& origin,
+    int tab_id,
+    const std::vector<MediaRouteResponseCallback>& callbacks) {
+  std::string presentation_id("mr_");
+  presentation_id += base::GenerateGUID();
+  DVLOG_WITH_INSTANCE(1) << "DoConnectRouteByRouteId " << source_id
+                         << ", route ID: " << route_id
+                         << ", presentation ID: " << presentation_id;
+  media_route_provider_->ConnectRouteByRouteId(
+      source_id, route_id, presentation_id, origin, tab_id,
+      base::Bind(&MediaRouterMojoImpl::RouteResponseReceived,
+          base::Unretained(this), presentation_id, callbacks));
+}
+
 void MediaRouterMojoImpl::DoCloseRoute(const MediaRoute::Id& route_id) {
   DVLOG_WITH_INSTANCE(1) << "DoCloseRoute " << route_id;
   media_route_provider_->CloseRoute(route_id);
 }
 
 void MediaRouterMojoImpl::DoSendSessionMessage(
     const MediaRoute::Id& route_id,
     const std::string& message,
     const SendRouteMessageCallback& callback) {
   DVLOG_WITH_INSTANCE(1) << "SendRouteMessage " << route_id;
@@ skipping 126 matching lines @@
 }
 
 void MediaRouterMojoImpl::DoStartObservingMediaSinks(
     const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoStartObservingMediaSinks: " << source_id;
   // No need to call MRPM if there are no sinks available.
   if (availability_ == interfaces::MediaRouter::SINK_AVAILABILITY_UNAVAILABLE)
     return;
 
   // No need to call MRPM if all observers have been removed in the meantime.
-  auto* sinks_query = sinks_queries_.get(source_id);
-  if (!sinks_query || !sinks_query->observers.might_have_observers()) {
+  if (!HasSinksObservers(source_id))
     return;
-  }
 
   DVLOG_WITH_INSTANCE(1) << "MRPM.StartObservingMediaSinks: " << source_id;
   media_route_provider_->StartObservingMediaSinks(source_id);
+  auto* sinks_query = sinks_queries_.get(source_id);
   sinks_query->is_active = true;
 }
 
 void MediaRouterMojoImpl::DoStopObservingMediaSinks(
     const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoStopObservingMediaSinks: " << source_id;
 
   auto* sinks_query = sinks_queries_.get(source_id);
   // No need to call MRPM if observers have been added in the meantime,
   // or StopObservingMediaSinks has already been called.
   if (!sinks_query || !sinks_query->is_active ||
       sinks_query->observers.might_have_observers()) {
     return;
   }
 
   DVLOG_WITH_INSTANCE(1) << "MRPM.StopObservingMediaSinks: " << source_id;
   media_route_provider_->StopObservingMediaSinks(source_id);
   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.
+  if (!HasRoutesObservers(source_id))
+    return;
+
+  DVLOG_WITH_INSTANCE(1) << "MRPM.StartObservingMediaRoutes: " << source_id;
+  media_route_provider_->StartObservingMediaRoutes(source_id);
+  auto* routes_query = routes_queries_.get(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();
+
+  // No need to call MRPM if observers have been added in the meantime,
+  // or StopObservingMediaRoutes has already been called.
+  auto* routes_query = routes_queries_.get(source_id);
+  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) {
   pending_requests_.push_back(closure);
   if (pending_requests_.size() > kMaxPendingRequests) {
     DLOG_WITH_INSTANCE(ERROR) << "Reached max queue size. Dropping oldest "
                               << "request.";
     pending_requests_.pop_front();
   }
   DVLOG_WITH_INSTANCE(2) << "EnqueueTask (queue-length="
@@ skipping 83 matching lines @@
   DCHECK(reason != MediaRouteProviderWakeReason::TOTAL_COUNT);
   if (current_wake_reason_ == MediaRouteProviderWakeReason::TOTAL_COUNT)
     current_wake_reason_ = reason;
 }
 
 void MediaRouterMojoImpl::ClearWakeReason() {
   DCHECK(current_wake_reason_ != MediaRouteProviderWakeReason::TOTAL_COUNT);
   current_wake_reason_ = MediaRouteProviderWakeReason::TOTAL_COUNT;
 }
 
+bool MediaRouterMojoImpl::HasRoutesObservers(
+    const MediaSource::Id& source_id) const {
+  auto* routes_query = routes_queries_.get(source_id);
+  return routes_query && routes_query->observers.might_have_observers();
+}
+
+bool MediaRouterMojoImpl::HasSinksObservers(
+    const MediaSource::Id& source_id) const {
+  auto* sinks_query = sinks_queries_.get(source_id);
+  return sinks_query && sinks_query->observers.might_have_observers();
+}
+
 }  // namespace media_router