[Media Router] Cherrypick "add sinks to origin list" to beta

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 35 matching lines @@
   int render_process_id = render_frame_host->GetProcess()->GetID();
   int render_frame_id = render_frame_host->GetRoutingID();
   return RenderFrameHostId(render_process_id, render_frame_id);
 }
 
 // Gets the last committed URL for the render frame specified by
 // |render_frame_host_id|.
 GURL GetLastCommittedURLForFrame(RenderFrameHostId render_frame_host_id) {
   RenderFrameHost* render_frame_host = RenderFrameHost::FromID(
       render_frame_host_id.first, render_frame_host_id.second);
-  DCHECK(render_frame_host);
-  return render_frame_host->GetLastCommittedURL();
+  return render_frame_host ? render_frame_host->GetLastCommittedURL() : GURL();
 }
 
 }  // namespace
 
 // Used by PresentationServiceDelegateImpl to manage
 // listeners and default presentation info in a render frame.
 // Its lifetime:
 //  * PresentationFrameManager AddDelegateObserver
 //  * Reset 0+ times.
 //  * PresentationFrameManager.RemoveDelegateObserver.
 class PresentationFrame {
  public:
-  PresentationFrame(content::WebContents* web_contents, MediaRouter* router);
+  PresentationFrame(const RenderFrameHostId& render_frame_host_id,
+                    content::WebContents* web_contents,
+                    MediaRouter* router);
   ~PresentationFrame();
 
   // Mirror corresponding APIs in PresentationServiceDelegateImpl.
   bool SetScreenAvailabilityListener(
       content::PresentationScreenAvailabilityListener* listener);
   bool RemoveScreenAvailabilityListener(
       content::PresentationScreenAvailabilityListener* listener);
   bool HasScreenAvailabilityListenerForTest(
       const MediaSource::Id& source_id) const;
   std::string GetDefaultPresentationId() const;
@@ skipping 25 matching lines @@
   MediaSource GetMediaSourceFromListener(
       content::PresentationScreenAvailabilityListener* listener) const;
   base::SmallMap<std::map<std::string, MediaRoute::Id>>
       presentation_id_to_route_id_;
   scoped_ptr<PresentationMediaSinksObserver> sinks_observer_;
   base::ScopedPtrHashMap<MediaRoute::Id,
                          scoped_ptr<PresentationConnectionStateSubscription>>
       connection_state_subscriptions_;
   ScopedVector<PresentationSessionMessagesObserver> session_messages_observers_;
 
+  RenderFrameHostId render_frame_host_id_;
+
   // References to the owning WebContents, and the corresponding MediaRouter.
   const content::WebContents* web_contents_;
   MediaRouter* router_;
 
   DelegateObserver* delegate_observer_;
 };
 
-PresentationFrame::PresentationFrame(content::WebContents* web_contents,
-                                     MediaRouter* router)
-    : web_contents_(web_contents),
+PresentationFrame::PresentationFrame(
+    const RenderFrameHostId& render_frame_host_id,
+    content::WebContents* web_contents,
+    MediaRouter* router)
+    : render_frame_host_id_(render_frame_host_id),
+      web_contents_(web_contents),
       router_(router),
       delegate_observer_(nullptr) {
   DCHECK(web_contents_);
   DCHECK(router_);
 }
 
 PresentationFrame::~PresentationFrame() {
 }
 
 void PresentationFrame::OnPresentationServiceDelegateDestroyed() const {
@@ skipping 19 matching lines @@
     route_ids.push_back(e.second);
   return route_ids;
 }
 
 bool PresentationFrame::SetScreenAvailabilityListener(
     content::PresentationScreenAvailabilityListener* listener) {
   if (sinks_observer_ && sinks_observer_->listener() == listener)
     return false;
 
   MediaSource source(GetMediaSourceFromListener(listener));
-  sinks_observer_.reset(
-      new PresentationMediaSinksObserver(router_, listener, source));
+  sinks_observer_.reset(new PresentationMediaSinksObserver(
+      router_, listener, source,
+      GetLastCommittedURLForFrame(render_frame_host_id_).GetOrigin()));
 
   if (!sinks_observer_->Init()) {
     sinks_observer_.reset();
     listener->OnScreenAvailabilityNotSupported();
     return false;
   }
 
   return true;
 }
 
@@ skipping 362 matching lines @@
   auto presentation_frame = presentation_frames_.get(render_frame_host_id);
   if (presentation_frame)
     presentation_frame->RemoveConnection(route_id, presentation_id);
 }
 
 PresentationFrame* PresentationFrameManager::GetOrAddPresentationFrame(
     const RenderFrameHostId& render_frame_host_id) {
   if (!presentation_frames_.contains(render_frame_host_id)) {
     presentation_frames_.add(
         render_frame_host_id,
-        scoped_ptr<PresentationFrame>(
-            new PresentationFrame(web_contents_, router_)));
+        scoped_ptr<PresentationFrame>(new PresentationFrame(
+            render_frame_host_id, web_contents_, router_)));
   }
   return presentation_frames_.get(render_frame_host_id);
 }
 
 void PresentationFrameManager::ClearDefaultPresentationRequest() {
   default_presentation_started_callback_.Reset();
   if (!default_presentation_request_)
     return;
 
   default_presentation_request_.reset();
@@ skipping 314 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