MediaRouterAction: Only observe Media Routes when there is a local route.

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"
 #include "base/observer_list.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/issues_observer.h"
+#include "chrome/browser/media/router/local_media_routes_observer.h"
 #include "chrome/browser/media/router/media_router_factory.h"
 #include "chrome/browser/media/router/media_router_type_converters.h"
 #include "chrome/browser/media/router/media_routes_observer.h"
 #include "chrome/browser/media/router/media_sinks_observer.h"
 #include "chrome/browser/media/router/presentation_session_messages_observer.h"
 #include "extensions/browser/process_manager.h"
 
 #define DVLOG_WITH_INSTANCE(level) \
   DVLOG(level) << "MR #" << instance_id_ << ": "
 
 #define DLOG_WITH_INSTANCE(level) DLOG(level) << "MR #" << instance_id_ << ": "
 
 namespace media_router {
 namespace {
 
-// Converts the callback result of calling Mojo CreateRoute()/JoinRoute()
-// into a local callback.
-void 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;
-  if (media_route.is_null()) {
-    // An error occurred.
-    DCHECK(!error_text.is_null());
-    error = !error_text.get().empty() ? error_text.get() : "Unknown error.";
-  } else {
-    route = media_route.To<scoped_ptr<MediaRoute>>();
-    actual_presentation_id = presentation_id;
-  }
-
-  for (const MediaRouteResponseCallback& callback : callbacks)
-    callback.Run(route.get(), actual_presentation_id, error);
-}
-
 // TODO(imcheng): We should handle failure in this case. One way is to invoke
 // all pending requests with failure. (crbug.com/490787)
 void EventPageWakeComplete(bool success) {
   if (!success)
     LOG(ERROR) << "An error encountered while waking the event page.";
 }
 
 scoped_ptr<content::PresentationSessionMessage>
 ConvertToPresentationSessionMessage(interfaces::RouteMessagePtr input) {
   DCHECK(!input.is_null());
@@ skipping 17 matching lines @@
       return output.Pass();
     }
   }
 
   NOTREACHED() << "Invalid route message type " << input->type;
   return output.Pass();
 }
 
 }  // namespace
 
+MediaRouterMojoImpl::MediaRouterMediaRoutesObserver::
+MediaRouterMediaRoutesObserver(MediaRouterMojoImpl* router)
+    : MediaRoutesObserver(router),
+      router_(router) {
+  DCHECK(router);
+}
+
+MediaRouterMojoImpl::MediaRouterMediaRoutesObserver::
+~MediaRouterMediaRoutesObserver() {
+}
+
+void MediaRouterMojoImpl::MediaRouterMediaRoutesObserver::OnRoutesUpdated(
+    const std::vector<media_router::MediaRoute>& routes) {
+  bool has_local_route =
+      std::find_if(routes.begin(), routes.end(),
+                   [](const media_router::MediaRoute& route) {
+                      return route.is_local(); }) !=
+      routes.end();
+
+  // |this| will be deleted beyond this point if |has_local_route| is false.
+  router_->UpdateHasLocalRoute(has_local_route);
+}
+
 MediaRouterMojoImpl::MediaRouterMojoImpl(
     extensions::EventPageTracker* event_page_tracker)
     : event_page_tracker_(event_page_tracker),
-      instance_id_(base::GenerateGUID()) {
+      instance_id_(base::GenerateGUID()),
+      has_local_route_(false) {
   DCHECK(event_page_tracker_);
 }
 
 MediaRouterMojoImpl::~MediaRouterMojoImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 // static
 void MediaRouterMojoImpl::BindToRequest(
     const std::string& extension_id,
@@ skipping 81 matching lines @@
   routes_converted.reserve(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));
 }
 
+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;
+  if (media_route.is_null()) {
+    // An error occurred.
+    DCHECK(!error_text.is_null());
+    error = !error_text.get().empty() ? error_text.get() : "Unknown error.";
+  } else {
+    route = media_route.To<scoped_ptr<MediaRoute>>();
+    actual_presentation_id = presentation_id;
+
+    FOR_EACH_OBSERVER(LocalMediaRoutesObserver, local_routes_observers_,
+                      UpdateHasLocalRoute(true));
+    if (!routes_observer_)
+      routes_observer_.reset(new MediaRouterMediaRoutesObserver(this));
+  }
+
+  for (const MediaRouteResponseCallback& callback : callbacks)
+    callback.Run(route.get(), actual_presentation_id, error);
+}
+
+void MediaRouterMojoImpl::UpdateHasLocalRoute(bool has_local_route) {
+  has_local_route_ = has_local_route;

[imcheng, 2015/10/02 17:21:11]

Can we skip the logic below if has_local_route_ == has_local_route?

[apacible, 2015/10/02 18:48:20]

Done.

+
+  if (!has_local_route_)
+    routes_observer_.reset();
+
+  FOR_EACH_OBSERVER(LocalMediaRoutesObserver, local_routes_observers_,
+                    UpdateHasLocalRoute(has_local_route_));
+}
+
 void MediaRouterMojoImpl::CreateRoute(
     const MediaSource::Id& source_id,
     const MediaSink::Id& sink_id,
     const GURL& origin,
     int tab_id,
     const std::vector<MediaRouteResponseCallback>& callbacks) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!origin.is_valid()) {
     DVLOG_WITH_INSTANCE(1) << "Invalid origin: " << origin;
@@ skipping 181 matching lines @@
     return;
 
   observer_list->RemoveObserver(observer);
   if (!observer_list->might_have_observers()) {
     messages_observers_.erase(route_id);
     RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStopListeningForRouteMessages,
                           base::Unretained(this), route_id));
   }
 }
 
+void MediaRouterMojoImpl::RegisterLocalMediaRoutesObserver(
+    LocalMediaRoutesObserver* observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(observer);
+
+  DCHECK(!local_routes_observers_.HasObserver(observer));
+  local_routes_observers_.AddObserver(observer);
+}
+
+void MediaRouterMojoImpl::UnregisterLocalMediaRoutesObserver(
+    LocalMediaRoutesObserver* observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(observer);
+
+  if (!local_routes_observers_.HasObserver(observer))
+    return;
+  local_routes_observers_.RemoveObserver(observer);
+}
+
 void MediaRouterMojoImpl::DoCreateRoute(
     const MediaSource::Id& source_id,
     const MediaSink::Id& sink_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) << "DoCreateRoute " << source_id << "=>" << sink_id
                          << ", presentation ID: " << presentation_id;
   media_route_provider_->CreateRoute(
       source_id, sink_id, presentation_id, origin, tab_id,
-      base::Bind(&RouteResponseReceived, presentation_id, callbacks));
+      base::Bind(&MediaRouterMojoImpl::RouteResponseReceived,
+          base::Unretained(this), presentation_id, callbacks));
 }
 
 void MediaRouterMojoImpl::DoJoinRoute(
     const MediaSource::Id& source_id,
     const std::string& presentation_id,
     const std::string& origin,
     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(&RouteResponseReceived, presentation_id, callbacks));
+      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,
@@ skipping 79 matching lines @@
       route_id, base::Bind(&MediaRouterMojoImpl::OnRouteMessagesReceived,
                            base::Unretained(this), route_id));
 }
 
 void MediaRouterMojoImpl::DoOnPresentationSessionDetached(
     const MediaRoute::Id& route_id) {
   DVLOG_WITH_INSTANCE(1) << "DoOnPresentationSessionDetached " << route_id;
   media_route_provider_->OnPresentationSessionDetached(route_id);
 }
 
+bool MediaRouterMojoImpl::GetHasLocalRoute() {
+  return has_local_route_;
+}
+
 void MediaRouterMojoImpl::DoStartObservingMediaSinks(
     const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoStartObservingMediaSinks: " << source_id;
   media_route_provider_->StartObservingMediaSinks(source_id);
 }
 
 void MediaRouterMojoImpl::DoStopObservingMediaSinks(
     const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoStopObservingMediaSinks: " << source_id;
   media_route_provider_->StopObservingMediaSinks(source_id);
@@ skipping 53 matching lines @@
     return;
   }
 
   for (const auto& next_request : pending_requests_)
     next_request.Run();
 
   pending_requests_.clear();
 }
 
 }  // namespace media_router