[Media Router] Add origins to sink query results.

chrome/browser/media/router/presentation_service_delegate_impl_unittest.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 <vector>
 
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/media_source.h"
 #include "chrome/browser/media/router/media_source_helper.h"
 #include "chrome/browser/media/router/mock_media_router.h"
@@ skipping 145 matching lines @@
   content::WebContents* incognito_web_contents_;
 };
 
 TEST_F(PresentationServiceDelegateImplTest, AddScreenAvailabilityListener) {
   std::string presentation_url1("http://url1.fakeUrl");
   std::string presentation_url2("http://url2.fakeUrl");
   MediaSource source1 = MediaSourceForPresentationUrl(presentation_url1);
   MediaSource source2 = MediaSourceForPresentationUrl(presentation_url2);
   MockScreenAvailabilityListener listener1(presentation_url1);
   MockScreenAvailabilityListener listener2(presentation_url2);
-  int render_process_id = 10;
-  int render_frame_id1 = 1;
+  content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
+  ASSERT_TRUE(main_frame);
+  int render_process_id = main_frame->GetProcess()->GetID();
+  int render_frame_id1 = main_frame->GetRoutingID();
+
+  // Note that |render_frame_id2| does not correspond to a real frame. As a
+  // result, the observer added with have an empty GURL as origin.
   int render_frame_id2 = 2;
 
   EXPECT_CALL(router_, RegisterMediaSinksObserver(_))
       .Times(2)
       .WillRepeatedly(Return(true));
   EXPECT_TRUE(delegate_impl_->AddScreenAvailabilityListener(
       render_process_id, render_frame_id1, &listener1));
   EXPECT_TRUE(delegate_impl_->AddScreenAvailabilityListener(
       render_process_id, render_frame_id2, &listener2));
   EXPECT_TRUE(delegate_impl_->HasScreenAvailabilityListenerForTest(
@@ skipping 16 matching lines @@
 
 TEST_F(PresentationServiceDelegateImplTest, AddMultipleListenersToFrame) {
   ON_CALL(router_, RegisterMediaSinksObserver(_)).WillByDefault(Return(true));
 
   std::string presentation_url1("http://url1.com");
   std::string presentation_url2("http://url2.com");
   MediaSource source1 = MediaSourceForPresentationUrl(presentation_url1);
   MediaSource source2 = MediaSourceForPresentationUrl(presentation_url2);
   MockScreenAvailabilityListener listener1(presentation_url1);
   MockScreenAvailabilityListener listener2(presentation_url2);
-  int render_process_id = 10;
-  int render_frame_id = 1;
+  content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
+  ASSERT_TRUE(main_frame);
+  int render_process_id = main_frame->GetProcess()->GetID();
+  int render_frame_id = main_frame->GetRoutingID();
 
   EXPECT_CALL(router_, RegisterMediaSinksObserver(_)).Times(2);
   EXPECT_TRUE(delegate_impl_->AddScreenAvailabilityListener(
       render_process_id, render_frame_id, &listener1));
   EXPECT_TRUE(delegate_impl_->AddScreenAvailabilityListener(
       render_process_id, render_frame_id, &listener2));
   EXPECT_TRUE(delegate_impl_->HasScreenAvailabilityListenerForTest(
       render_process_id, render_frame_id, source1.id()))
       << "Mapping not found for " << source1.ToString();
   EXPECT_TRUE(delegate_impl_->HasScreenAvailabilityListenerForTest(
       render_process_id, render_frame_id, source2.id()))
       << "Mapping not found for " << source2.ToString();
 
   EXPECT_CALL(router_, UnregisterMediaSinksObserver(_)).Times(2);
   delegate_impl_->RemoveScreenAvailabilityListener(
       render_process_id, render_frame_id, &listener1);
   delegate_impl_->RemoveScreenAvailabilityListener(
       render_process_id, render_frame_id, &listener2);
   EXPECT_FALSE(delegate_impl_->HasScreenAvailabilityListenerForTest(
       render_process_id, render_frame_id, source1.id()));
   EXPECT_FALSE(delegate_impl_->HasScreenAvailabilityListenerForTest(
       render_process_id, render_frame_id, source2.id()));
 }
 
 TEST_F(PresentationServiceDelegateImplTest, AddSameListenerTwice) {
   std::string presentation_url1("http://url1.fakeUrl");
   MediaSource source1(MediaSourceForPresentationUrl(presentation_url1));
   MockScreenAvailabilityListener listener1(presentation_url1);
-  int render_process_id = 1;
-  int render_frame_id = 0;
+  content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
+  ASSERT_TRUE(main_frame);
+  int render_process_id = main_frame->GetProcess()->GetID();
+  int render_frame_id = main_frame->GetRoutingID();
 
   EXPECT_CALL(router_, RegisterMediaSinksObserver(_)).WillOnce(Return(true));
   EXPECT_TRUE(delegate_impl_->AddScreenAvailabilityListener(
       render_process_id, render_frame_id, &listener1));
   EXPECT_FALSE(delegate_impl_->AddScreenAvailabilityListener(
       render_process_id, render_frame_id, &listener1));
   EXPECT_TRUE(delegate_impl_->HasScreenAvailabilityListenerForTest(
       render_process_id, render_frame_id, source1.id()));
 
   EXPECT_CALL(router_, UnregisterMediaSinksObserver(_)).Times(1);
@@ skipping 157 matching lines @@
                                                  connection, callback);
 }
 
 TEST_F(PresentationServiceDelegateImplTest, Reset) {
   EXPECT_CALL(router_, RegisterMediaSinksObserver(_))
       .WillRepeatedly(Return(true));
 
   std::string presentation_url1("http://url1.fakeUrl");
   MediaSource source = MediaSourceForPresentationUrl(presentation_url1);
   MockScreenAvailabilityListener listener1(presentation_url1);
-  int render_process_id = 1;
-  int render_frame_id = 0;
+
+  content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
+  ASSERT_TRUE(main_frame);
+  int render_process_id = main_frame->GetProcess()->GetID();
+  int render_frame_id = main_frame->GetRoutingID();
 
   EXPECT_TRUE(delegate_impl_->AddScreenAvailabilityListener(
       render_process_id, render_frame_id, &listener1));
   EXPECT_TRUE(delegate_impl_->HasScreenAvailabilityListenerForTest(
       render_process_id, render_frame_id, source.id()));
   EXPECT_CALL(router_, UnregisterMediaSinksObserver(_)).Times(1);
   delegate_impl_->Reset(render_process_id, render_frame_id);
   EXPECT_FALSE(delegate_impl_->HasScreenAvailabilityListenerForTest(
       render_process_id, render_frame_id, source.id()));
 }
@@ skipping 12 matching lines @@
   // Removes |delegate_observer2|.
   manager->RemoveObserver(345, 456);
 
   EXPECT_CALL(delegate_observer1, OnDelegateDestroyed()).Times(1);
   manager.reset();
 }
 
 TEST_F(PresentationServiceDelegateImplTest, SinksObserverCantRegister) {
   const std::string presentation_url("http://url1.fakeUrl");
   MockScreenAvailabilityListener listener(presentation_url);
-  const int render_process_id = 10;
-  const int render_frame_id = 1;
+  content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
+  ASSERT_TRUE(main_frame);
+  int render_process_id = main_frame->GetProcess()->GetID();
+  int render_frame_id = main_frame->GetRoutingID();
 
   EXPECT_CALL(router_, RegisterMediaSinksObserver(_)).WillOnce(Return(false));
   EXPECT_CALL(listener, OnScreenAvailabilityNotSupported());
   EXPECT_FALSE(delegate_impl_->AddScreenAvailabilityListener(
       render_process_id, render_frame_id, &listener));
 }
 
 }  // namespace media_router