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 396 matching lines @@
 
 void MediaRouterMojoImpl::ClearIssue(const Issue::Id& issue_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   issue_manager_.ClearIssue(issue_id);
 }
 
 bool MediaRouterMojoImpl::RegisterMediaSinksObserver(
     MediaSinksObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  const GURL& origin = observer->origin();
+  DCHECK(origin.is_valid());

[mark a. foltz, 2016/02/17 21:50:51]

You might want to DCHECK or LOG(WARNING) that the GURL doesn't have a path, it
means some truncation didn't happen upstream.

[matt.boetger, 2016/02/18 00:50:33]

Done.

   // 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);
   bool new_query = false;
   if (!sinks_query) {
     new_query = true;
     sinks_query = new MediaSinksQuery;
+    sinks_query->origin = origin;
     sinks_queries_.add(source_id, make_scoped_ptr(sinks_query));
   } else {
     DCHECK(!sinks_query->observers.HasObserver(observer));
   }
 
+

[mark a. foltz, 2016/02/17 21:50:51]

Extra newline

[matt.boetger, 2016/02/18 00:50:33]

Done.

   // 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>());
   } 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_id, origin));
     } else if (sinks_query->has_cached_result) {
       observer->OnSinksReceived(sinks_query->cached_sink_list);
     }
   }
   return true;
 }
 
 void MediaRouterMojoImpl::UnregisterMediaSinksObserver(
     MediaSinksObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 288 matching lines @@
     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();
     }
   } 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));
+                            base::Unretained(this), source_and_query.first,
+                            source_and_query.second->origin));
     }
   }
 }
 
 void MediaRouterMojoImpl::OnPresentationConnectionStateChanged(
     const mojo::String& route_id,
     interfaces::MediaRouter::PresentationConnectionState state) {
   NotifyPresentationConnectionStateChange(
       route_id, mojo::PresentationConnectionStateFromMojo(state));
 }
 
 bool MediaRouterMojoImpl::HasLocalDisplayRoute() const {
   return has_local_display_route_;
 }
 
 void MediaRouterMojoImpl::DoStartObservingMediaSinks(
-    const MediaSource::Id& source_id) {
+    const MediaSource::Id& source_id, const GURL& origin) {
+  DCHECK(origin.is_valid());
   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);
   if (!sinks_query || !sinks_query->observers.might_have_observers())
     return;
 
   DVLOG_WITH_INSTANCE(1) << "MRPM.StartObservingMediaSinks: " << source_id;
-  media_route_provider_->StartObservingMediaSinks(source_id);
+  media_route_provider_->StartObservingMediaSinks(source_id,
+      origin.is_empty() ? "" : origin.spec());
   sinks_query->is_active = true;
 }
 
 void MediaRouterMojoImpl::DoStopObservingMediaSinks(
     const MediaSource::Id& source_id) {
   DVLOG_WITH_INSTANCE(1) << "DoStopObservingMediaSinks: " << source_id;
 
   auto* sinks_query = sinks_queries_.get(source_id);
   // No need to call MRPM if observers have been added in the meantime,
   // or StopObservingMediaSinks has already been called.
@@ skipping 133 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