MediaRouter: Cache MediaRoutesObserver queries to prevent ext wake-ups

chrome/browser/media/router/mojo/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/mojo/media_router_mojo_impl.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 167 matching lines @@
     const std::vector<url::Origin>& origins) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DVLOG_WITH_INSTANCE(1) << "OnSinksReceived";
   auto it = sinks_queries_.find(media_source);
   if (it == sinks_queries_.end()) {
     DVLOG_WITH_INSTANCE(1) << "Received sink list without MediaSinksQuery.";
     return;
   }
 
   auto* sinks_query = it->second.get();
-  sinks_query->has_cached_result = true;
+  sinks_query->cached_sink_list = sinks;
   sinks_query->origins = origins;
-  sinks_query->cached_sink_list = sinks;
 
-  if (!sinks_query->observers.might_have_observers()) {
+  if (sinks_query->observers.might_have_observers()) {
+    for (auto& observer : sinks_query->observers) {
+      observer.OnSinksUpdated(*sinks_query->cached_sink_list,
+                              sinks_query->origins);
+    }
+  } else {
     DVLOG_WITH_INSTANCE(1)
         << "Received sink list without any active observers: " << media_source;
-  } else {
-    for (auto& observer : sinks_query->observers) {
-      observer.OnSinksUpdated(sinks_query->cached_sink_list,
-                              sinks_query->origins);
-    }
   }
 }
 
 void MediaRouterMojoImpl::OnRoutesUpdated(
     const std::vector<MediaRoute>& routes,
     const std::string& media_source,
     const std::vector<std::string>& joinable_route_ids) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   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;
   }
 
-  for (auto& observer : it->second->observers)
-    observer.OnRoutesUpdated(routes, joinable_route_ids);
+  auto* routes_query = it->second.get();
+  routes_query->cached_route_list = routes;
+  routes_query->joinable_route_ids = joinable_route_ids;
+
+  if (routes_query->observers.might_have_observers()) {
+    for (auto& observer : routes_query->observers)
+      observer.OnRoutesUpdated(routes, joinable_route_ids);
+  } else {
+    DVLOG_WITH_INSTANCE(1)
+        << "Received routes update without any active observers: "
+        << media_source;
+  }
 }
 
 void MediaRouterMojoImpl::RouteResponseReceived(
     const std::string& presentation_id,
     bool is_incognito,
     const std::vector<MediaRouteResponseCallback>& callbacks,
     bool is_join,
     const base::Optional<MediaRoute>& media_route,
     const base::Optional<std::string>& error_text,
     RouteRequestResult::ResultCode result_code) {
@@ skipping 156 matching lines @@
 }
 
 bool MediaRouterMojoImpl::RegisterMediaSinksObserver(
     MediaSinksObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // Create an observer list for the media source and add |observer|
   // to it. Fail if |observer| is already registered.
   const std::string& source_id = observer->source().id();
   std::unique_ptr<MediaSinksQuery>& sinks_query = sinks_queries_[source_id];
-  bool new_query = false;
+  bool is_new_query = false;
   if (!sinks_query) {
-    new_query = true;
+    is_new_query = true;
     sinks_query = base::MakeUnique<MediaSinksQuery>();
   } else {
     DCHECK(!sinks_query->observers.HasObserver(observer));
   }
 
   // If sink availability is UNAVAILABLE, then there is no need to call MRPM.
   // |observer| can be immediately notified with an empty list.
   sinks_query->observers.AddObserver(observer);
   if (availability_ == mojom::MediaRouter::SinkAvailability::UNAVAILABLE) {
     observer->OnSinksUpdated(std::vector<MediaSink>(),
                              std::vector<url::Origin>());
   } else {
     // Need to call MRPM to start observing sinks if the query is new.
-    if (new_query) {
+    if (is_new_query) {
       SetWakeReason(MediaRouteProviderWakeReason::START_OBSERVING_MEDIA_SINKS);
       RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStartObservingMediaSinks,
                             base::Unretained(this), source_id));
-    } else if (sinks_query->has_cached_result) {
-      observer->OnSinksUpdated(sinks_query->cached_sink_list,
+    } else if (sinks_query->cached_sink_list) {
+      observer->OnSinksUpdated(*sinks_query->cached_sink_list,
                                sinks_query->origins);
     }
   }
   return true;
 }
 
 void MediaRouterMojoImpl::UnregisterMediaSinksObserver(
     MediaSinksObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
@@ skipping 24 matching lines @@
       sinks_queries_.erase(source_id);
     }
   }
 }
 
 void MediaRouterMojoImpl::RegisterMediaRoutesObserver(
     MediaRoutesObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   const MediaSource::Id source_id = observer->source_id();
   auto& routes_query = routes_queries_[source_id];
+  bool is_new_query = false;
   if (!routes_query) {
+    is_new_query = true;
     routes_query = base::MakeUnique<MediaRoutesQuery>();
   } 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), source_id));
+  if (is_new_query) {
+    SetWakeReason(MediaRouteProviderWakeReason::START_OBSERVING_MEDIA_ROUTES);
+    RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStartObservingMediaRoutes,
+                          base::Unretained(this), source_id));
+    // The MRPM will call MediaRouterMojoImpl::OnRoutesUpdated() soon, if there
+    // are any existing routes the new observer should be aware of.
+  } else if (routes_query->cached_route_list) {
+    // Return to the event loop before notifying of a cached route list because
+    // MediaRoutesObserver is calling this method from its constructor, and that
+    // must complete before invoking its virtual OnRoutesUpdated() method.
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(&MediaRouterMojoImpl::NotifyOfExistingRoutesIfRegistered,
+                   weak_factory_.GetWeakPtr(), source_id, observer));
+  }
+}
+
+void MediaRouterMojoImpl::NotifyOfExistingRoutesIfRegistered(
+    const MediaSource::Id& source_id,
+    MediaRoutesObserver* observer) const {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  // Check that the route query still exists with a cached result, and that the
+  // observer is still registered. Otherwise, there is nothing to report to the
+  // observer.
+  const auto it = routes_queries_.find(source_id);
+  if (it == routes_queries_.end() || !it->second->cached_route_list ||
+      !it->second->observers.HasObserver(observer)) {
+    return;
+  }
+
+  observer->OnRoutesUpdated(*it->second->cached_route_list,
+                            it->second->joinable_route_ids);
 }
 
 void MediaRouterMojoImpl::UnregisterMediaRoutesObserver(
     MediaRoutesObserver* observer) {
   const MediaSource::Id source_id = observer->source_id();
   auto it = routes_queries_.find(source_id);
   if (it == routes_queries_.end() ||
       !it->second->observers.HasObserver(observer)) {
     return;
   }
@@ skipping 196 matching lines @@
     SinkAvailability availability) {
   if (availability_ == availability)
     return;
 
   availability_ = availability;
   if (availability_ == mojom::MediaRouter::SinkAvailability::UNAVAILABLE) {
     // Sinks are no longer available. MRPM has already removed all sink queries.
     for (auto& source_and_query : sinks_queries_) {
       const auto& query = source_and_query.second;
       query->is_active = false;
-      query->has_cached_result = false;
-      query->cached_sink_list.clear();
+      query->cached_sink_list = base::nullopt;
       query->origins.clear();
     }
   } else {
     // Sinks are now available. Tell MRPM to start all sink queries again.
     for (const auto& source_and_query : sinks_queries_) {
       RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStartObservingMediaSinks,
                             base::Unretained(this), source_and_query.first));
     }
   }
 }
@@ skipping 229 matching lines @@
                         base::Unretained(this), source_id));
 }
 
 void MediaRouterMojoImpl::DoUpdateMediaSinks(
     const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoUpdateMediaSinks" << source_id;
   media_route_provider_->UpdateMediaSinks(source_id);
 }
 
 }  // namespace media_router