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 168 matching lines @@
   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()) {
-    DVLOG_WITH_INSTANCE(1)
-        << "Received sink list without any active observers: " << media_source;
-  } else {
+  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;
   }
 }
 
 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->has_cached_result = true;
+  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 222 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 new_query = false;

[Wez, 2017/03/04 02:07:32]

nit: is_new_query

[miu, 2017/03/04 02:24:39]

Done.

   if (!routes_query) {
+    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 (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->has_cached_result) {
+    // 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::NotifyOfExistingRoutesAfterRegistration,
+            weak_factory_.GetWeakPtr(), source_id, observer));
+  }
+}
+
+void MediaRouterMojoImpl::NotifyOfExistingRoutesAfterRegistration(
+    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, punt.

[Wez, 2017/03/04 02:07:32]

nit: What does "punt" mean here? Perhaps rephrase to something like "If the
query has no cached result, or the observer is gone, then there is nothing to do
here."

[miu, 2017/03/04 02:24:39]

Done.

+  const auto it = routes_queries_.find(source_id);
+  if (it == routes_queries_.end() || !it->second->has_cached_result ||
+      !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 447 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