[Media Router] Add origins to sink query results.

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 <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 147 matching lines @@
 
 void MediaRouterMojoImpl::OnIssue(const interfaces::IssuePtr issue) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG_WITH_INSTANCE(1) << "OnIssue " << issue->title;
   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) {
+    mojo::Array<interfaces::MediaSinkPtr> sinks,
+    mojo::Array<mojo::String> origins) {
   DCHECK(thread_checker_.CalledOnValidThread());
   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;
   sinks_query->has_cached_result = true;
   auto& cached_sink_list = sinks_query->cached_sink_list;
   cached_sink_list.clear();
   cached_sink_list.reserve(sinks.size());
   for (size_t i = 0; i < sinks.size(); ++i)
     cached_sink_list.push_back(sinks[i].To<MediaSink>());
 
+  auto& origins_list = sinks_query->origins;
+  origins_list.clear();
+  origins_list.reserve(origins.size());
+  for (size_t i = 0; i < origins.size(); ++i) {
+    GURL origin(origins[i].get());
+    DLOG_IF(ERROR, !origin.is_valid()) << "Received invalid origin: " << origin;
+    origins_list.push_back(origin);

[mark a. foltz, 2016/03/11 01:20:23]

If we receive an invalid origin from the MRPM, can we trust the result at all?

It would be simplest to log and drop the result on the floor rather than figure
out if it's okay to pass along to observers.

[imcheng, 2016/03/14 21:30:20]

Changed it to do an early return if an origin is invalid.

+  }
+
   if (!sinks_query->observers.might_have_observers()) {
     DVLOG_WITH_INSTANCE(1)
         << "Received sink list without any active observers: " << media_source;
   } else {
     FOR_EACH_OBSERVER(MediaSinksObserver, sinks_query->observers,
-                      OnSinksReceived(cached_sink_list));
+                      OnSinksUpdated(cached_sink_list, origins_list));
   }
 }
 
 void MediaRouterMojoImpl::OnRoutesUpdated(
     mojo::Array<interfaces::MediaRoutePtr> routes,
     const mojo::String& media_source,
     mojo::Array<mojo::String> joinable_route_ids) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG_WITH_INSTANCE(1) << "OnRoutesUpdated";
@@ skipping 187 matching lines @@
     sinks_query = new MediaSinksQuery;
     sinks_queries_.add(source_id, make_scoped_ptr(sinks_query));
   } 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_ == interfaces::MediaRouter::SinkAvailability::UNAVAILABLE) {
-    observer->OnSinksReceived(std::vector<MediaSink>());
+    observer->OnSinksUpdated(std::vector<MediaSink>(), std::vector<GURL>());
   } else {
     // Need to call MRPM to start observing sinks if the query is new.
     if (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->OnSinksReceived(sinks_query->cached_sink_list);
+      observer->OnSinksUpdated(sinks_query->cached_sink_list,

[mark a. foltz, 2016/03/11 01:20:23]

It seems like an observer could get an empty list without any origins, then an
empty list valid only for some list of origins.  Is that okay?  Or should we
assume an empty list is valid for all origins?

[imcheng, 2016/03/14 21:30:20]

It should be ok for now. In all cases, the observer will get back an empty list.

+                               sinks_query->origins);
     }
   }
   return true;
 }
 
 void MediaRouterMojoImpl::UnregisterMediaSinksObserver(
     MediaSinksObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const MediaSource::Id& source_id = observer->source().id();
@@ skipping 275 matching lines @@
     return;
 
   availability_ = availability;
   if (availability_ == interfaces::MediaRouter::SinkAvailability::UNAVAILABLE) {
     // Sinks are no longer available. MRPM has already removed all sink queries.
     for (auto& source_and_query : sinks_queries_) {
       auto* query = source_and_query.second;
       query->is_active = false;
       query->has_cached_result = false;
       query->cached_sink_list.clear();
+      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 173 matching lines @@
   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;
 }
 
 }  // namespace media_router