Pass origin to StartObservingMediaSinks.

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,
+    const mojo::String& origin,
     mojo::Array<interfaces::MediaSinkPtr> sinks) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG_WITH_INSTANCE(1) << "OnSinksReceived";
-  auto it = sinks_queries_.find(media_source);
+  MediaSource source(media_source);
+  source.set_origin(origin);
+  auto it = sinks_queries_.find(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>());
 
   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));
+                      OnSinksReceived(source, cached_sink_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 172 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   issue_manager_.ClearIssue(issue_id);
 }
 
 bool MediaRouterMojoImpl::RegisterMediaSinksObserver(
     MediaSinksObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // 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();
-  auto* sinks_query = sinks_queries_.get(source_id);
+  const MediaSource& source = observer->source();
+  auto* sinks_query = sinks_queries_.get(source);
   bool new_query = false;
   if (!sinks_query) {
     new_query = true;
     sinks_query = new MediaSinksQuery;
-    sinks_queries_.add(source_id, make_scoped_ptr(sinks_query));
+    sinks_queries_.add(source, 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->OnSinksReceived(source, std::vector<MediaSink>());
   } 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));
+                            base::Unretained(this), source));
     } else if (sinks_query->has_cached_result) {
-      observer->OnSinksReceived(sinks_query->cached_sink_list);
+      observer->OnSinksReceived(source, sinks_query->cached_sink_list);
     }
   }
   return true;
 }
 
 void MediaRouterMojoImpl::UnregisterMediaSinksObserver(
     MediaSinksObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  const MediaSource::Id& source_id = observer->source().id();
-  auto* sinks_query = sinks_queries_.get(source_id);
+  const MediaSource& source = observer->source();
+  auto* sinks_query = sinks_queries_.get(source);
   if (!sinks_query || !sinks_query->observers.HasObserver(observer)) {
     return;
   }
 
   // If we are removing the final observer for the source, then stop
   // observing sinks for it.
   // might_have_observers() is reliable here on the assumption that this call
   // is not inside the ObserverList iteration.
   sinks_query->observers.RemoveObserver(observer);
   if (!sinks_query->observers.might_have_observers()) {
     // Only ask MRPM to stop observing media sinks if the availability is not
     // UNAVAILABLE.
     // Otherwise, the MRPM would have discarded the queries already.
     if (availability_ !=
         interfaces::MediaRouter::SinkAvailability::UNAVAILABLE) {
       SetWakeReason(MediaRouteProviderWakeReason::STOP_OBSERVING_MEDIA_SINKS);
       // The |sinks_queries_| entry will be removed in the immediate or deferred
       // |DoStopObservingMediaSinks| call.
       RunOrDefer(base::Bind(&MediaRouterMojoImpl::DoStopObservingMediaSinks,
-                            base::Unretained(this), source_id));
+                            base::Unretained(this), source));
     } else {
-      sinks_queries_.erase(source_id);
+      sinks_queries_.erase(source);
     }
   }
 }
 
 void MediaRouterMojoImpl::RegisterMediaRoutesObserver(
     MediaRoutesObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const MediaSource::Id source_id = observer->source_id();
   auto* routes_query = routes_queries_.get(source_id);
   if (!routes_query) {
@@ skipping 269 matching lines @@
 void MediaRouterMojoImpl::OnPresentationConnectionClosed(
     const mojo::String& route_id,
     interfaces::MediaRouter::PresentationConnectionCloseReason reason,
     const mojo::String& message) {
   NotifyPresentationConnectionClose(
       route_id, mojo::PresentationConnectionCloseReasonFromMojo(reason),
       message);
 }
 
 void MediaRouterMojoImpl::DoStartObservingMediaSinks(
-    const MediaSource::Id& source_id) {
-  DVLOG_WITH_INSTANCE(1) << "DoStartObservingMediaSinks: " << source_id;
+    const MediaSource& source) {
+  DVLOG_WITH_INSTANCE(1) << "DoStartObservingMediaSinks: " << source.id();
   // No need to call MRPM if there are no sinks available.
   if (availability_ == interfaces::MediaRouter::SinkAvailability::UNAVAILABLE)
     return;
 
   // No need to call MRPM if all observers have been removed in the meantime.
-  auto* sinks_query = sinks_queries_.get(source_id);
+  auto* sinks_query = sinks_queries_.get(source);
   if (!sinks_query || !sinks_query->observers.might_have_observers())
     return;
 
-  DVLOG_WITH_INSTANCE(1) << "MRPM.StartObservingMediaSinks: " << source_id;
-  media_route_provider_->StartObservingMediaSinks(source_id);
+  DVLOG_WITH_INSTANCE(1) << "MRPM.StartObservingMediaSinks: " << source.id();
+  media_route_provider_->StartObservingMediaSinks(source.id(),
+                                                  source.origin());
   sinks_query->is_active = true;
 }
 
 void MediaRouterMojoImpl::DoStopObservingMediaSinks(
-    const MediaSource::Id& source_id) {
-  DVLOG_WITH_INSTANCE(1) << "DoStopObservingMediaSinks: " << source_id;
+    const MediaSource& source) {
+  DVLOG_WITH_INSTANCE(1) << "DoStopObservingMediaSinks: " << source.id();
 
-  auto* sinks_query = sinks_queries_.get(source_id);
+  auto* sinks_query = sinks_queries_.get(source);
   // No need to call MRPM if observers have been added in the meantime,
   // or StopObservingMediaSinks has already been called.
   if (!sinks_query || !sinks_query->is_active ||
       sinks_query->observers.might_have_observers()) {
     return;
   }
 
-  DVLOG_WITH_INSTANCE(1) << "MRPM.StopObservingMediaSinks: " << source_id;
-  media_route_provider_->StopObservingMediaSinks(source_id);
-  sinks_queries_.erase(source_id);
+  DVLOG_WITH_INSTANCE(1) << "MRPM.StopObservingMediaSinks: " << source.id();
+  media_route_provider_->StopObservingMediaSinks(source.id(),
+                                                 source.origin());
+  sinks_queries_.erase(source);
 }
 
 void MediaRouterMojoImpl::DoStartObservingMediaRoutes(
     const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoStartObservingMediaRoutes";
 
   // No need to call MRPM if all observers have been removed in the meantime.
   auto* routes_query = routes_queries_.get(source_id);
   if (!routes_query || !routes_query->observers.might_have_observers())
     return;
@@ skipping 115 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