Pass origin to StartObservingMediaSinks.

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 67 matching lines @@
 
   void RunDefaultPresentationUrlCallbackTest(bool off_the_record) {
     content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
     ASSERT_TRUE(main_frame);
     int render_process_id = main_frame->GetProcess()->GetID();
     int routing_id = main_frame->GetRoutingID();
 
     auto callback = base::Bind(
         &PresentationServiceDelegateImplTest::OnDefaultPresentationStarted,
         base::Unretained(this));
     std::string presentation_url1("http://foo.fakeUrl");

[mark a. foltz, 2016/03/03 22:58:36]

Similar comment about URLs/origins in tests.

[matt.boetger, 2016/03/04 00:22:11]

Done.

+    std::string origin_url1("http://foo.fakeUrl");
     delegate_impl_->SetDefaultPresentationUrl(render_process_id, routing_id,
                                               presentation_url1, callback);
 
     ASSERT_TRUE(delegate_impl_->HasDefaultPresentationRequest());
     PresentationRequest request =
         delegate_impl_->GetDefaultPresentationRequest();
 
     // Should not trigger callback since route response is error.
     scoped_ptr<RouteRequestResult> result = RouteRequestResult::FromError(
         "Error", RouteRequestResult::UNKNOWN_ERROR);
     delegate_impl_->OnRouteResponse(request, *result);
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(this));
 
     // Should not trigger callback since request doesn't match.
     std::string presentation_url2("http://bar.fakeUrl");
+    std::string origin_url2("http://bar.fakeUrl");
     PresentationRequest different_request(
         RenderFrameHostId(100, 200), presentation_url2,
         GURL("http://anotherFrameUrl.fakeUrl"));
     MediaRoute* media_route = new MediaRoute(
-        "differentRouteId", MediaSourceForPresentationUrl(presentation_url2),
+        "differentRouteId", MediaSourceForPresentationUrl(presentation_url2,
+                                                          origin_url2),
         "mediaSinkId", "", true, "", true);
     media_route->set_off_the_record(off_the_record);
     result = RouteRequestResult::FromSuccess(make_scoped_ptr(media_route),
                                              "differentPresentationId");
     delegate_impl_->OnRouteResponse(different_request, *result);
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(this));
 
     // Should trigger callback since request matches.
     EXPECT_CALL(*this, OnDefaultPresentationStarted(_)).Times(1);
     MediaRoute* media_route2 = new MediaRoute(
-        "routeId", MediaSourceForPresentationUrl(presentation_url1),
+        "routeId", MediaSourceForPresentationUrl(presentation_url1,
+                                                 origin_url1),
         "mediaSinkId", "", true, "", true);
     media_route2->set_off_the_record(off_the_record);
     result = RouteRequestResult::FromSuccess(make_scoped_ptr(media_route2),
                                              "presentationId");
     delegate_impl_->OnRouteResponse(request, *result);
   }
 
   PresentationServiceDelegateImpl* delegate_impl_;
   MockMediaRouter router_;
 };
@@ skipping 21 matching lines @@
     // RenderViewHostTestHarness::TearDown().
     delete incognito_web_contents_;
     PresentationServiceDelegateImplTest::TearDown();
   }
 
   content::WebContents* incognito_web_contents_;
 };
 
 TEST_F(PresentationServiceDelegateImplTest, AddScreenAvailabilityListener) {
   std::string presentation_url1("http://url1.fakeUrl");
+  std::string origin_url1("http://url1.fakeUrl");
   std::string presentation_url2("http://url2.fakeUrl");
-  MediaSource source1 = MediaSourceForPresentationUrl(presentation_url1);
-  MediaSource source2 = MediaSourceForPresentationUrl(presentation_url2);
+  std::string origin_url2("http://url2.fakeUrl");
+  MediaSource source1 = MediaSourceForPresentationUrl(presentation_url1,
+                                                      origin_url1);
+  MediaSource source2 = MediaSourceForPresentationUrl(presentation_url2,
+                                                      origin_url2);
   MockScreenAvailabilityListener listener1(presentation_url1);
   MockScreenAvailabilityListener listener2(presentation_url2);
   int render_process_id = 10;
   int render_frame_id1 = 1;
   int render_frame_id2 = 2;
 
   EXPECT_CALL(router_, RegisterMediaSinksObserver(_))
       .Times(2)
       .WillRepeatedly(Return(true));
   EXPECT_TRUE(delegate_impl_->AddScreenAvailabilityListener(
@@ skipping 15 matching lines @@
   EXPECT_FALSE(delegate_impl_->HasScreenAvailabilityListenerForTest(
       render_process_id, render_frame_id1, source1.id()));
   EXPECT_FALSE(delegate_impl_->HasScreenAvailabilityListenerForTest(
       render_process_id, render_frame_id2, source2.id()));
 }
 
 TEST_F(PresentationServiceDelegateImplTest, AddMultipleListenersToFrame) {
   ON_CALL(router_, RegisterMediaSinksObserver(_)).WillByDefault(Return(true));
 
   std::string presentation_url1("http://url1.com");
+  std::string origin_url1("http://url1.com");
   std::string presentation_url2("http://url2.com");
-  MediaSource source1 = MediaSourceForPresentationUrl(presentation_url1);
-  MediaSource source2 = MediaSourceForPresentationUrl(presentation_url2);
+  std::string origin_url2("http://url2.com");
+  MediaSource source1 = MediaSourceForPresentationUrl(presentation_url1,
+                                                      origin_url1);
+  MediaSource source2 = MediaSourceForPresentationUrl(presentation_url2,
+                                                      origin_url2);
   MockScreenAvailabilityListener listener1(presentation_url1);
   MockScreenAvailabilityListener listener2(presentation_url2);
   int render_process_id = 10;
   int render_frame_id = 1;
 
   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));
@@ skipping 10 matching lines @@
   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));
+  MediaSource source1(MediaSourceForPresentationUrl(presentation_url1,
+                                                    presentation_url1));
   MockScreenAvailabilityListener listener1(presentation_url1);
   int render_process_id = 1;
   int render_frame_id = 0;
 
   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(
@@ skipping 120 matching lines @@
   ASSERT_TRUE(main_frame);
   int render_process_id = main_frame->GetProcess()->GetID();
   int routing_id = main_frame->GetRoutingID();
 
   // Set up a PresentationConnection so we can listen to it.
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   EXPECT_CALL(router_, JoinRoute(_, _, _, _, _, _, false))
       .WillOnce(SaveArg<4>(&route_response_callbacks));
 
   const std::string kPresentationUrl("http://url1.fakeUrl");
+  const std::string kOriginUrl("http://url1.fakeUrl");
   const std::string kPresentationId("pid");
   MockCreatePresentationConnnectionCallbacks mock_create_connection_callbacks;
   delegate_impl_->JoinSession(
       render_process_id, routing_id, kPresentationUrl, kPresentationId,
       base::Bind(&MockCreatePresentationConnnectionCallbacks::
                      OnCreateConnectionSuccess,
                  base::Unretained(&mock_create_connection_callbacks)),
       base::Bind(
           &MockCreatePresentationConnnectionCallbacks::OnCreateConnectionError,
           base::Unretained(&mock_create_connection_callbacks)));
 
   EXPECT_CALL(mock_create_connection_callbacks, OnCreateConnectionSuccess(_))
       .Times(1);
   scoped_ptr<RouteRequestResult> result = RouteRequestResult::FromSuccess(
       make_scoped_ptr(new MediaRoute(
-          "routeId", MediaSourceForPresentationUrl(kPresentationUrl),
+          "routeId", MediaSourceForPresentationUrl(kPresentationUrl,
+                                                   kOriginUrl),
           "mediaSinkId", "description", true, "", true)),
       kPresentationId);
   for (const auto& route_response_callback : route_response_callbacks)
     route_response_callback.Run(*result);
 
   MockPresentationConnectionStateChangedCallback mock_callback;
   content::PresentationConnectionStateChangedCallback callback =
       base::Bind(&MockPresentationConnectionStateChangedCallback::Run,
                  base::Unretained(&mock_callback));
   content::PresentationSessionInfo connection(kPresentationUrl,
                                               kPresentationId);
   EXPECT_CALL(router_, OnAddPresentationConnectionStateChangedCallbackInvoked(
                            Equals(callback)));
   delegate_impl_->ListenForConnectionStateChange(render_process_id, routing_id,
                                                  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);
+  std::string origin_url1("http://url1.fakeUrl");
+  MediaSource source = MediaSourceForPresentationUrl(presentation_url1,
+                                                     origin_url1);
   MockScreenAvailabilityListener listener1(presentation_url1);
   int render_process_id = 1;
   int render_frame_id = 0;
 
   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);
@@ skipping 25 matching lines @@
   const int render_process_id = 10;
   const int render_frame_id = 1;
 
   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