[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;
   }
 
+  std::vector<GURL> origin_list;
+  origin_list.reserve(origins.size());
+  for (size_t i = 0; i < origins.size(); ++i) {
+    GURL origin(origins[i].get());
+    if (!origin.is_valid()) {
+      DLOG(ERROR) << "Received invalid origin: " << origin

[mark a. foltz, 2016/03/15 00:36:43]

Perhaps LOG(WARNING)

[imcheng, 2016/03/15 01:52:41]

Done.

+                  << ". Dropping result.";
+      return;
+    }
+    origin_list.push_back(origin);
+  }
+
+  std::vector<MediaSink> sink_list;
+  sink_list.reserve(sinks.size());
+  for (size_t i = 0; i < sinks.size(); ++i)
+    sink_list.push_back(sinks[i].To<MediaSink>());
+
   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>());
+  sinks_query->origins.swap(origin_list);
+  sinks_query->cached_sink_list.swap(sink_list);
 
   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));
+    FOR_EACH_OBSERVER(
+        MediaSinksObserver, sinks_query->observers,
+        OnSinksUpdated(sinks_query->cached_sink_list, sinks_query->origins));
   }
 }
 
 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,
+                               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