[Media Router] Convert MediaRouter to use GURL for presentation URLs.

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 "chrome/browser/media/router/presentation_service_delegate_impl.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/media_source.h"
 #include "chrome/browser/media/router/media_source_helper.h"
@@ skipping 12 matching lines @@
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
 namespace {
 
-const char kPresentationUrl1[] = "http://foo.fakeUrl.com/";
-const char kPresentationUrl2[] = "http://bar.fakeUrl.com/";
-const char kFrameUrl[] = "http://anotherFrameUrl.fakeUrl.com/";
+const char kPresentationUrl1[] = "http://foo.fakeurl.com/";
+const char kPresentationUrl2[] = "http://bar.fakeurl.com/";
+const char kFrameUrl[] = "http://anotherframeurl.fakeurl.com/";
 
 }  // namespace
 
 namespace media_router {
 
 class MockDelegateObserver
     : public content::PresentationServiceDelegate::Observer {
  public:
   MOCK_METHOD0(OnDelegateDestroyed, void());
   MOCK_METHOD1(OnDefaultPresentationStarted,
@@ skipping 12 matching lines @@
  public:
   MOCK_METHOD1(OnCreateConnectionSuccess,
                void(const content::PresentationSessionInfo& connection));
   MOCK_METHOD1(OnCreateConnectionError,
                void(const content::PresentationError& error));
 };
 
 class PresentationServiceDelegateImplTest
     : public ChromeRenderViewHostTestHarness {
  public:
-  PresentationServiceDelegateImplTest() : delegate_impl_(nullptr) {}
+  PresentationServiceDelegateImplTest()
+      : delegate_impl_(nullptr),
+        presentation_url1_(kPresentationUrl1),
+        presentation_url2_(kPresentationUrl2) {}
 
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
     content::WebContents* wc = GetWebContents();
     ASSERT_TRUE(wc);
     PresentationServiceDelegateImpl::CreateForWebContents(wc);
     delegate_impl_ = PresentationServiceDelegateImpl::FromWebContents(wc);
     delegate_impl_->SetMediaRouterForTest(&router_);
+    presentation_urls_.push_back(presentation_url1_);
   }
 
   MOCK_METHOD1(OnDefaultPresentationStarted,
                void(const content::PresentationSessionInfo& session_info));
 
  protected:
   virtual content::WebContents* GetWebContents() { return web_contents(); }
 
   void RunDefaultPresentationUrlCallbackTest(bool incognito) {
     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::vector<std::string> urls({kPresentationUrl1});
     delegate_impl_->SetDefaultPresentationUrls(render_process_id, routing_id,
-                                               urls, callback);
+                                               presentation_urls_, callback);
 
     ASSERT_TRUE(delegate_impl_->HasDefaultPresentationRequest());
     PresentationRequest request =
         delegate_impl_->GetDefaultPresentationRequest();
 
     // Should not trigger callback since route response is error.
     std::unique_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.
-    PresentationRequest different_request(RenderFrameHostId(100, 200),
-                                          {kPresentationUrl2}, GURL(kFrameUrl));
+    PresentationRequest different_request(
+        RenderFrameHostId(100, 200), {presentation_url2_}, GURL(kFrameUrl));
     MediaRoute* media_route = new MediaRoute(
-        "differentRouteId", MediaSourceForPresentationUrl(kPresentationUrl2),
+        "differentRouteId", MediaSourceForPresentationUrl(presentation_url2_),
         "mediaSinkId", "", true, "", true);
     media_route->set_incognito(incognito);
     result = RouteRequestResult::FromSuccess(base::WrapUnique(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(kPresentationUrl1),
+        "routeId", MediaSourceForPresentationUrl(presentation_url1_),
         "mediaSinkId", "", true, "", true);
     media_route2->set_incognito(incognito);
     result = RouteRequestResult::FromSuccess(base::WrapUnique(media_route2),
                                              "presentationId");
     delegate_impl_->OnRouteResponse(request, *result);
   }
 
   PresentationServiceDelegateImpl* delegate_impl_;
   MockMediaRouter router_;
+  const GURL presentation_url1_;
+  const GURL presentation_url2_;
+  std::vector<GURL> presentation_urls_;
 };
 
 class PresentationServiceDelegateImplIncognitoTest
     : public PresentationServiceDelegateImplTest {
  public:
   PresentationServiceDelegateImplIncognitoTest() :
       incognito_web_contents_(nullptr) {}
 
  protected:
   content::WebContents* GetWebContents() override {
@@ skipping 11 matching lines @@
     // require RenderViewHost, etc., that in turn are deleted by
     // RenderViewHostTestHarness::TearDown().
     delete incognito_web_contents_;
     PresentationServiceDelegateImplTest::TearDown();
   }
 
   content::WebContents* incognito_web_contents_;
 };
 
 TEST_F(PresentationServiceDelegateImplTest, AddScreenAvailabilityListener) {
-  MediaSource source1 = MediaSourceForPresentationUrl(kPresentationUrl1);
-  MediaSource source2 = MediaSourceForPresentationUrl(kPresentationUrl2);
-  MockScreenAvailabilityListener listener1(kPresentationUrl1);
-  MockScreenAvailabilityListener listener2(kPresentationUrl2);
+  MediaSource source1 = MediaSourceForPresentationUrl(presentation_url1_);
+  MediaSource source2 = MediaSourceForPresentationUrl(presentation_url2_);
+  MockScreenAvailabilityListener listener1(presentation_url1_);
+  MockScreenAvailabilityListener listener2(presentation_url2_);
   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(_))
@@ skipping 17 matching lines @@
       render_process_id, render_frame_id2, &listener2);
   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));
 
-  MediaSource source1 = MediaSourceForPresentationUrl(kPresentationUrl1);
-  MediaSource source2 = MediaSourceForPresentationUrl(kPresentationUrl2);
-  MockScreenAvailabilityListener listener1(kPresentationUrl1);
-  MockScreenAvailabilityListener listener2(kPresentationUrl2);
+  MediaSource source1 = MediaSourceForPresentationUrl(presentation_url1_);
+  MediaSource source2 = MediaSourceForPresentationUrl(presentation_url2_);
+  MockScreenAvailabilityListener listener1(presentation_url1_);
+  MockScreenAvailabilityListener listener2(presentation_url2_);
   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) {
-  MediaSource source1(MediaSourceForPresentationUrl(kPresentationUrl1));
-  MockScreenAvailabilityListener listener1(kPresentationUrl1);
+  MediaSource source1(MediaSourceForPresentationUrl(presentation_url1_));
+  MockScreenAvailabilityListener listener1(presentation_url1_);
   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));
@@ skipping 16 matching lines @@
   content::WebContentsTester::For(GetWebContents())
       ->NavigateAndCommit(frame_url);
   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::vector<std::string> urls({kPresentationUrl1});
   delegate_impl_->SetDefaultPresentationUrls(render_process_id, routing_id,
-                                             urls, callback);
+                                             presentation_urls_, callback);
   ASSERT_TRUE(delegate_impl_->HasDefaultPresentationRequest());
   PresentationRequest request1 =
       delegate_impl_->GetDefaultPresentationRequest();
-  EXPECT_EQ(kPresentationUrl1, request1.presentation_url());
+  EXPECT_EQ(presentation_url1_, request1.presentation_url());
   EXPECT_EQ(RenderFrameHostId(render_process_id, routing_id),
             request1.render_frame_host_id());
   EXPECT_EQ(frame_url, request1.frame_url());
 
   // Set to a new default presentation URL
-  std::vector<std::string> new_urls({kPresentationUrl2});
+  std::vector<GURL> new_urls({presentation_url2_});
   delegate_impl_->SetDefaultPresentationUrls(render_process_id, routing_id,
                                              new_urls, callback);
   ASSERT_TRUE(delegate_impl_->HasDefaultPresentationRequest());
   PresentationRequest request2 =
       delegate_impl_->GetDefaultPresentationRequest();
-  EXPECT_EQ(kPresentationUrl2, request2.presentation_url());
+  EXPECT_EQ(presentation_url2_, request2.presentation_url());
   EXPECT_EQ(RenderFrameHostId(render_process_id, routing_id),
             request2.render_frame_host_id());
   EXPECT_EQ(frame_url, request2.frame_url());
 
   // Remove default presentation URL.
-  delegate_impl_->SetDefaultPresentationUrls(
-      render_process_id, routing_id, std::vector<std::string>(), callback);
+  delegate_impl_->SetDefaultPresentationUrls(render_process_id, routing_id,
+                                             std::vector<GURL>(), callback);
   EXPECT_FALSE(delegate_impl_->HasDefaultPresentationRequest());
 }
 
 TEST_F(PresentationServiceDelegateImplTest, DefaultPresentationUrlCallback) {
   RunDefaultPresentationUrlCallbackTest(false);
 }
 
 TEST_F(PresentationServiceDelegateImplIncognitoTest,
        DefaultPresentationUrlCallback) {
   RunDefaultPresentationUrlCallbackTest(true);
 }
 
 TEST_F(PresentationServiceDelegateImplTest,
        DefaultPresentationRequestObserver) {
   auto callback = base::Bind(
       &PresentationServiceDelegateImplTest::OnDefaultPresentationStarted,
       base::Unretained(this));
 
   StrictMock<MockDefaultPresentationRequestObserver> observer;
   delegate_impl_->AddDefaultPresentationRequestObserver(&observer);
 
   GURL frame_url(kFrameUrl);
   content::WebContentsTester::For(GetWebContents())
       ->NavigateAndCommit(frame_url);
   content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
   ASSERT_TRUE(main_frame);
   int render_process_id = main_frame->GetProcess()->GetID();
   int routing_id = main_frame->GetRoutingID();
 
+  std::vector<GURL> request1_urls({presentation_url1_});
   PresentationRequest observed_request1(
-      RenderFrameHostId(render_process_id, routing_id), {kPresentationUrl1},
+      RenderFrameHostId(render_process_id, routing_id), request1_urls,
       frame_url);
   EXPECT_CALL(observer, OnDefaultPresentationChanged(Equals(observed_request1)))
       .Times(1);
-  std::vector<std::string> request1_urls({kPresentationUrl1});
   delegate_impl_->SetDefaultPresentationUrls(render_process_id, routing_id,
                                              request1_urls, callback);
 
   ASSERT_TRUE(delegate_impl_->HasDefaultPresentationRequest());
   PresentationRequest request1 =
       delegate_impl_->GetDefaultPresentationRequest();
   EXPECT_TRUE(request1.Equals(observed_request1));
 
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer));
 
+  std::vector<GURL> request2_urls({presentation_url2_});
   PresentationRequest observed_request2(
-      RenderFrameHostId(render_process_id, routing_id), {kPresentationUrl2},
+      RenderFrameHostId(render_process_id, routing_id), request2_urls,
       frame_url);
   EXPECT_CALL(observer, OnDefaultPresentationChanged(Equals(observed_request2)))
       .Times(1);
-  std::vector<std::string> request2_urls({kPresentationUrl2});
   delegate_impl_->SetDefaultPresentationUrls(render_process_id, routing_id,
                                              request2_urls, callback);
   ASSERT_TRUE(delegate_impl_->HasDefaultPresentationRequest());
   PresentationRequest request2 =
       delegate_impl_->GetDefaultPresentationRequest();
   EXPECT_TRUE(request2.Equals(observed_request2));
 
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&observer));
 
   // Remove default presentation URL.
   EXPECT_CALL(observer, OnDefaultPresentationRemoved()).Times(1);
-  delegate_impl_->SetDefaultPresentationUrls(
-      render_process_id, routing_id, std::vector<std::string>(), callback);
+  delegate_impl_->SetDefaultPresentationUrls(render_process_id, routing_id,
+                                             std::vector<GURL>(), callback);
 }
 
 TEST_F(PresentationServiceDelegateImplTest, ListenForConnnectionStateChange) {
   GURL frame_url(kFrameUrl);
   content::WebContentsTester::For(GetWebContents())
       ->NavigateAndCommit(frame_url);
   content::RenderFrameHost* main_frame = GetWebContents()->GetMainFrame();
   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 kPresentationId("pid");
-  std::vector<std::string> join_urls({kPresentationUrl1});
   MockCreatePresentationConnnectionCallbacks mock_create_connection_callbacks;
   delegate_impl_->JoinSession(
-      render_process_id, routing_id, join_urls, kPresentationId,
+      render_process_id, routing_id, presentation_urls_, 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);
   std::unique_ptr<RouteRequestResult> result = RouteRequestResult::FromSuccess(
       base::MakeUnique<MediaRoute>(
-          "routeId", MediaSourceForPresentationUrl(kPresentationUrl1),
+          "routeId", MediaSourceForPresentationUrl(presentation_url1_),
           "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(kPresentationUrl1,
+  content::PresentationSessionInfo connection(presentation_url1_,
                                               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));
 
-  MediaSource source = MediaSourceForPresentationUrl(kPresentationUrl1);
-  MockScreenAvailabilityListener listener1(kPresentationUrl1);
+  MediaSource source = MediaSourceForPresentationUrl(presentation_url1_);
+  MockScreenAvailabilityListener listener1(presentation_url1_);
 
   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()));
@@ skipping 15 matching lines @@
   manager->AddObserver(345, 456, &delegate_observer2);
 
   // Removes |delegate_observer2|.
   manager->RemoveObserver(345, 456);
 
   EXPECT_CALL(delegate_observer1, OnDelegateDestroyed()).Times(1);
   manager.reset();
 }
 
 TEST_F(PresentationServiceDelegateImplTest, SinksObserverCantRegister) {
-  MockScreenAvailabilityListener listener(kPresentationUrl1);
+  MockScreenAvailabilityListener listener(presentation_url1_);
   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