Pass origin to StartObservingMediaSinks.

chrome/browser/media/router/presentation_service_delegate_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/presentation_service_delegate_impl.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 54 matching lines @@
 //  * PresentationFrameManager AddDelegateObserver
 //  * Reset 0+ times.
 //  * PresentationFrameManager.RemoveDelegateObserver.
 class PresentationFrame {
  public:
   PresentationFrame(content::WebContents* web_contents, MediaRouter* router);
   ~PresentationFrame();
 
   // Mirror corresponding APIs in PresentationServiceDelegateImpl.
   bool SetScreenAvailabilityListener(
-      content::PresentationScreenAvailabilityListener* listener);
+      content::PresentationScreenAvailabilityListener* listener,
+      const GURL& origin);
   bool RemoveScreenAvailabilityListener(
-      content::PresentationScreenAvailabilityListener* listener);
+      content::PresentationScreenAvailabilityListener* listener,
+      const GURL& origin);
   bool HasScreenAvailabilityListenerForTest(
-      const MediaSource::Id& source_id) const;
+      const MediaSource& source) const;
   std::string GetDefaultPresentationId() const;
   void ListenForConnectionStateChange(
       const content::PresentationSessionInfo& connection,
       const content::PresentationConnectionStateChangedCallback&
           state_changed_cb);
   void ListenForSessionMessages(
       const content::PresentationSessionInfo& session,
       const content::PresentationSessionMessageCallback& message_cb);
 
   void Reset();
   void RemoveConnection(const std::string& presentation_id,
                         const MediaRoute::Id& route_id);
 
   const MediaRoute::Id GetRouteId(const std::string& presentation_id) const;
   const std::vector<MediaRoute::Id> GetRouteIds() const;
 
   void OnPresentationSessionStarted(
       const content::PresentationSessionInfo& session,
       const MediaRoute::Id& route_id);
   void OnPresentationServiceDelegateDestroyed() const;
 
   void set_delegate_observer(DelegateObserver* observer) {
     delegate_observer_ = observer;
   }
 
  private:
   MediaSource GetMediaSourceFromListener(
-      content::PresentationScreenAvailabilityListener* listener) const;
+      content::PresentationScreenAvailabilityListener* listener,
+      const GURL& origin) const;
   base::SmallMap<std::map<std::string, MediaRoute::Id>>
       presentation_id_to_route_id_;
   base::SmallMap<
-      std::map<std::string, scoped_ptr<PresentationMediaSinksObserver>>>
-      url_to_sinks_observer_;
+      std::map<MediaSource, scoped_ptr<PresentationMediaSinksObserver>>>
+      media_source_to_sinks_observer_;
   base::ScopedPtrHashMap<MediaRoute::Id,
                          scoped_ptr<PresentationConnectionStateSubscription>>
       connection_state_subscriptions_;
   ScopedVector<PresentationSessionMessagesObserver> session_messages_observers_;
 
   // References to the owning WebContents, and the corresponding MediaRouter.
   const content::WebContents* web_contents_;
   MediaRouter* router_;
 
   DelegateObserver* delegate_observer_;
@@ skipping 29 matching lines @@
 }
 
 const std::vector<MediaRoute::Id> PresentationFrame::GetRouteIds() const {
   std::vector<MediaRoute::Id> route_ids;
   for (const auto& e : presentation_id_to_route_id_)
     route_ids.push_back(e.second);
   return route_ids;
 }
 
 bool PresentationFrame::SetScreenAvailabilityListener(
-    content::PresentationScreenAvailabilityListener* listener) {
-  MediaSource source(GetMediaSourceFromListener(listener));
-  auto& sinks_observer = url_to_sinks_observer_[source.id()];
+    content::PresentationScreenAvailabilityListener* listener,
+    const GURL& origin) {
+  MediaSource source(GetMediaSourceFromListener(listener, origin));
+  auto& sinks_observer = media_source_to_sinks_observer_[source];
   if (sinks_observer && sinks_observer->listener() == listener)
     return false;
 
   sinks_observer.reset(
       new PresentationMediaSinksObserver(router_, listener, source));
 
   if (!sinks_observer->Init()) {
-    url_to_sinks_observer_.erase(source.id());
+    media_source_to_sinks_observer_.erase(source);
     listener->OnScreenAvailabilityNotSupported();
     return false;
   }
 
   return true;
 }
 
 bool PresentationFrame::RemoveScreenAvailabilityListener(
-    content::PresentationScreenAvailabilityListener* listener) {
-  MediaSource source(GetMediaSourceFromListener(listener));
-  auto sinks_observer_it = url_to_sinks_observer_.find(source.id());
-  if (sinks_observer_it != url_to_sinks_observer_.end() &&
+    content::PresentationScreenAvailabilityListener* listener,
+    const GURL& origin) {
+  MediaSource source(GetMediaSourceFromListener(listener, origin));
+  auto sinks_observer_it = media_source_to_sinks_observer_.find(source);
+  if (sinks_observer_it != media_source_to_sinks_observer_.end() &&
       sinks_observer_it->second->listener() == listener) {
-    url_to_sinks_observer_.erase(sinks_observer_it);
+    media_source_to_sinks_observer_.erase(sinks_observer_it);
     return true;
   }
   return false;
 }
 
 bool PresentationFrame::HasScreenAvailabilityListenerForTest(
-    const MediaSource::Id& source_id) const {
-  return url_to_sinks_observer_.find(source_id) != url_to_sinks_observer_.end();
+    const MediaSource& source) const {
+  return media_source_to_sinks_observer_.find(source) !=
+         media_source_to_sinks_observer_.end();
 }
 
 void PresentationFrame::Reset() {
   for (const auto& pid_route_id : presentation_id_to_route_id_)
     router_->DetachRoute(pid_route_id.second);
 
   presentation_id_to_route_id_.clear();
-  url_to_sinks_observer_.clear();
+  media_source_to_sinks_observer_.clear();
   connection_state_subscriptions_.clear();
   session_messages_observers_.clear();
 }
 
 void PresentationFrame::RemoveConnection(const std::string& presentation_id,
                                          const MediaRoute::Id& route_id) {
   // Remove the presentation id mapping so a later call to Reset is a no-op.
   presentation_id_to_route_id_.erase(presentation_id);
 
   // We no longer need to observe route messages.
@@ skipping 41 matching lines @@
     DVLOG(2) << "ListenForSessionMessages: no route for "
              << session.presentation_id;
     return;
   }
 
   session_messages_observers_.push_back(
       new PresentationSessionMessagesObserver(message_cb, it->second, router_));
 }
 
 MediaSource PresentationFrame::GetMediaSourceFromListener(
-    content::PresentationScreenAvailabilityListener* listener) const {
+    content::PresentationScreenAvailabilityListener* listener,
+    const GURL& origin) const {
   // If the default presentation URL is empty then fall back to tab mirroring.
   std::string availability_url(listener->GetAvailabilityUrl());
   return availability_url.empty()
              ? MediaSourceForTab(SessionTabHelper::IdForTab(web_contents_))
-             : MediaSourceForPresentationUrl(availability_url);
+             : MediaSourceForPresentationUrl(availability_url, origin.spec());
 }
 
 // Used by PresentationServiceDelegateImpl to manage PresentationFrames.
 class PresentationFrameManager {
  public:
   PresentationFrameManager(content::WebContents* web_contents,
                            MediaRouter* router);
   ~PresentationFrameManager();
 
   // Mirror corresponding APIs in PresentationServiceDelegateImpl.
@@ skipping 144 matching lines @@
   auto presentation_frame = presentation_frames_.get(render_frame_host_id);
   return presentation_frame ? presentation_frame->GetRouteIds()
                             : std::vector<MediaRoute::Id>();
 }
 
 bool PresentationFrameManager::SetScreenAvailabilityListener(
     const RenderFrameHostId& render_frame_host_id,
     content::PresentationScreenAvailabilityListener* listener) {
   DCHECK(listener);
   auto presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
-  return presentation_frame->SetScreenAvailabilityListener(listener);
+  GURL frame_url(GetLastCommittedURLForFrame(render_frame_host_id));
+  return presentation_frame->SetScreenAvailabilityListener(listener, frame_url);
 }
 
 bool PresentationFrameManager::RemoveScreenAvailabilityListener(
     const RenderFrameHostId& render_frame_host_id,
     content::PresentationScreenAvailabilityListener* listener) {
   DCHECK(listener);
   auto presentation_frame = presentation_frames_.get(render_frame_host_id);
+  GURL frame_url(GetLastCommittedURLForFrame(render_frame_host_id));
   return presentation_frame &&
-         presentation_frame->RemoveScreenAvailabilityListener(listener);
+         presentation_frame->RemoveScreenAvailabilityListener(listener,
+                                                              frame_url);
 }
 
 bool PresentationFrameManager::HasScreenAvailabilityListenerForTest(
     const RenderFrameHostId& render_frame_host_id,
     const MediaSource::Id& source_id) const {
   auto presentation_frame = presentation_frames_.get(render_frame_host_id);
+  GURL frame_url(GetLastCommittedURLForFrame(render_frame_host_id));
+  MediaSource source(source_id);
+  source.set_origin(frame_url.spec());
   return presentation_frame &&
-         presentation_frame->HasScreenAvailabilityListenerForTest(source_id);
+         presentation_frame->HasScreenAvailabilityListenerForTest(source);
 }
 
 void PresentationFrameManager::ListenForConnectionStateChange(
     const RenderFrameHostId& render_frame_host_id,
     const content::PresentationSessionInfo& connection,
     const content::PresentationConnectionStateChangedCallback&
         state_changed_cb) {
   auto presentation_frame = presentation_frames_.get(render_frame_host_id);
   if (presentation_frame) {
     presentation_frame->ListenForConnectionStateChange(connection,
@@ skipping 279 matching lines @@
     const std::string& presentation_id,
     const content::PresentationSessionStartedCallback& success_cb,
     const content::PresentationSessionErrorCallback& error_cb) {
   bool off_the_record = web_contents_->GetBrowserContext()->IsOffTheRecord();
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
       &PresentationServiceDelegateImpl::OnJoinRouteResponse,
       weak_factory_.GetWeakPtr(), render_process_id, render_frame_id,
       content::PresentationSessionInfo(presentation_url, presentation_id),
       success_cb, error_cb));
-  router_->JoinRoute(MediaSourceForPresentationUrl(presentation_url).id(),
-                     presentation_id,
-                     GetLastCommittedURLForFrame(
-                         RenderFrameHostId(render_process_id, render_frame_id))
-                         .GetOrigin(),
-                     web_contents_, route_response_callbacks, base::TimeDelta(),
-                     off_the_record);
+  GURL origin(GetLastCommittedURLForFrame(
+              RenderFrameHostId(render_process_id, render_frame_id))
+                  .GetOrigin());
+  router_->JoinRoute(
+      MediaSourceForPresentationUrl(presentation_url, origin.spec()).id(),
+      presentation_id, origin, web_contents_, route_response_callbacks,
+      base::TimeDelta(), off_the_record);
 }
 
 void PresentationServiceDelegateImpl::CloseConnection(
     int render_process_id,
     int render_frame_id,
     const std::string& presentation_id) {
   const RenderFrameHostId rfh_id(render_process_id, render_frame_id);
   const MediaRoute::Id& route_id =
       frame_manager_->GetRouteId(rfh_id, presentation_id);
   if (route_id.empty()) {
@@ skipping 113 matching lines @@
 bool PresentationServiceDelegateImpl::HasScreenAvailabilityListenerForTest(
     int render_process_id,
     int render_frame_id,
     const MediaSource::Id& source_id) const {
   RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
   return frame_manager_->HasScreenAvailabilityListenerForTest(
       render_frame_host_id, source_id);
 }
 
 }  // namespace media_router