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

content/browser/presentation/presentation_service_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 "content/browser/presentation/presentation_service_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 35 matching lines @@
 
 // Matches PresentationSessionInfo passed by reference.
 MATCHER_P(SessionInfoEquals, expected, "") {
   blink::mojom::PresentationSessionInfo& expected_value = expected;
   return expected_value.Equals(arg);
 }
 
 const char kPresentationId[] = "presentationId";
 const char kPresentationUrl1[] = "http://foo.com/index.html";
 const char kPresentationUrl2[] = "http://example.com/index.html";
+const char kPresentationUrl3[] = "http://example.net/index.html";
 
 void DoNothing(blink::mojom::PresentationSessionInfoPtr info,
                blink::mojom::PresentationErrorPtr error) {}
 
-// TODO(crbug.com/632623): Convert downstream APIs to GURL and remove
-// conversions.
-std::vector<GURL> ToGURLs(const std::vector<std::string>& urls) {
-  std::vector<GURL> gurls(urls.size());
-  std::transform(urls.begin(), urls.end(), gurls.begin(),
-                 [](const std::string& url) { return GURL(url); });
-  return gurls;
-}
-
 }  // namespace
 
 class MockPresentationServiceDelegate : public PresentationServiceDelegate {
  public:
   MOCK_METHOD3(AddObserver,
       void(int render_process_id,
            int render_frame_id,
            PresentationServiceDelegate::Observer* observer));
   MOCK_METHOD2(RemoveObserver,
       void(int render_process_id, int render_frame_id));
@@ skipping 12 matching lines @@
   MOCK_METHOD3(RemoveScreenAvailabilityListener,
       void(int render_process_id,
            int routing_id,
            PresentationScreenAvailabilityListener* listener));
   MOCK_METHOD2(Reset,
       void(int render_process_id,
            int routing_id));
   MOCK_METHOD4(SetDefaultPresentationUrls,
                void(int render_process_id,
                     int routing_id,
-                    const std::vector<std::string>& default_presentation_urls,
+                    const std::vector<GURL>& default_presentation_urls,
                     const PresentationSessionStartedCallback& callback));
   MOCK_METHOD5(StartSession,
                void(int render_process_id,
                     int render_frame_id,
-                    const std::vector<std::string>& presentation_urls,
+                    const std::vector<GURL>& presentation_urls,
                     const PresentationSessionStartedCallback& success_cb,
                     const PresentationSessionErrorCallback& error_cb));
   MOCK_METHOD6(JoinSession,
                void(int render_process_id,
                     int render_frame_id,
-                    const std::vector<std::string>& presentation_urls,
+                    const std::vector<GURL>& presentation_urls,
                     const std::string& presentation_id,
                     const PresentationSessionStartedCallback& success_cb,
                     const PresentationSessionErrorCallback& error_cb));
   MOCK_METHOD3(CloseConnection,
                void(int render_process_id,
                     int render_frame_id,
                     const std::string& presentation_id));
   MOCK_METHOD3(Terminate,
                void(int render_process_id,
                     int render_frame_id,
@@ skipping 79 matching lines @@
     OnReceiverConnectionAvailable(*session_info);
   }
   MOCK_METHOD1(OnReceiverConnectionAvailable,
                void(const blink::mojom::PresentationSessionInfo& session_info));
 
   std::vector<blink::mojom::SessionMessagePtr> messages_received_;
 };
 
 class PresentationServiceImplTest : public RenderViewHostImplTestHarness {
  public:
-  PresentationServiceImplTest() {}
+  PresentationServiceImplTest()
+      : presentation_url1_(GURL(kPresentationUrl1)),
+        presentation_url2_(GURL(kPresentationUrl2)),
+        presentation_url3_(GURL(kPresentationUrl3)) {}
 
   void SetUp() override {
     RenderViewHostImplTestHarness::SetUp();
 
     auto request = mojo::GetProxy(&service_ptr_);
     EXPECT_CALL(mock_delegate_, AddObserver(_, _, _)).Times(1);
     TestRenderFrameHost* render_frame_host = contents()->GetMainFrame();
     render_frame_host->InitializeRenderFrameIfNeeded();
     service_impl_.reset(new PresentationServiceImpl(
         render_frame_host, contents(), &mock_delegate_));
     service_impl_->Bind(std::move(request));
 
     blink::mojom::PresentationServiceClientPtr client_ptr;
     client_binding_.reset(
         new mojo::Binding<blink::mojom::PresentationServiceClient>(
             &mock_client_, mojo::GetProxy(&client_ptr)));
     service_impl_->SetClient(std::move(client_ptr));
+
+    presentation_urls_.push_back(presentation_url1_);
+    presentation_urls_.push_back(presentation_url2_);
   }
 
   void TearDown() override {
     service_ptr_.reset();
     if (service_impl_.get()) {
       EXPECT_CALL(mock_delegate_, RemoveObserver(_, _)).Times(1);
       service_impl_.reset();
     }
     RenderViewHostImplTestHarness::TearDown();
   }
 
-  void ListenForScreenAvailabilityAndWait(const std::string& url,
+  void ListenForScreenAvailabilityAndWait(const GURL& url,
                                           bool delegate_success) {
     base::RunLoop run_loop;
     // This will call to |service_impl_| via mojo. Process the message
     // using RunLoop.
     // The callback shouldn't be invoked since there is no availability
     // result yet.
     EXPECT_CALL(mock_delegate_, AddScreenAvailabilityListener())
         .WillOnce(DoAll(
             InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
             Return(delegate_success)));
-    service_ptr_->ListenForScreenAvailability(GURL(url));
+    service_ptr_->ListenForScreenAvailability(url);
     run_loop.Run();
 
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_delegate_));
   }
 
   void RunLoopFor(base::TimeDelta duration) {
     base::RunLoop run_loop;
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, run_loop.QuitClosure(), duration);
     run_loop.Run();
   }
 
   void SaveQuitClosureAndRunLoop() {
     base::RunLoop run_loop;
     run_loop_quit_closure_ = run_loop.QuitClosure();
     run_loop.Run();
     run_loop_quit_closure_.Reset();
   }
 
-  void SimulateScreenAvailabilityChangeAndWait(
-      const std::string& url, bool available) {
+  void SimulateScreenAvailabilityChangeAndWait(const GURL& url,
+                                               bool available) {
     auto listener_it = service_impl_->screen_availability_listeners_.find(url);
     ASSERT_TRUE(listener_it->second);
 
     base::RunLoop run_loop;
-    EXPECT_CALL(mock_client_, OnScreenAvailabilityUpdated(GURL(url), available))
+    EXPECT_CALL(mock_client_, OnScreenAvailabilityUpdated(url, available))
         .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
     listener_it->second->OnScreenAvailabilityChanged(available);
     run_loop.Run();
   }
 
   void ExpectReset() {
     EXPECT_CALL(mock_delegate_, Reset(_, _)).Times(1);
   }
 
   void ExpectCleanState() {
     EXPECT_TRUE(service_impl_->default_presentation_urls_.empty());
     EXPECT_EQ(
-        service_impl_->screen_availability_listeners_.find(kPresentationUrl1),
+        service_impl_->screen_availability_listeners_.find(presentation_url1_),
         service_impl_->screen_availability_listeners_.end());
     EXPECT_FALSE(service_impl_->on_session_messages_callback_.get());
   }
 
   void ExpectNewSessionCallbackSuccess(
       blink::mojom::PresentationSessionInfoPtr info,
       blink::mojom::PresentationErrorPtr error) {
     EXPECT_FALSE(info.is_null());
     EXPECT_TRUE(error.is_null());
     if (!run_loop_quit_closure_.is_null())
@@ skipping 31 matching lines @@
     expected_msgs[0] = blink::mojom::SessionMessage::New();
     expected_msgs[0]->type = blink::mojom::PresentationMessageType::TEXT;
     expected_msgs[0]->message = text_msg;
     expected_msgs[1] = blink::mojom::SessionMessage::New();
     expected_msgs[1]->type =
         blink::mojom::PresentationMessageType::ARRAY_BUFFER;
     expected_msgs[1]->data = binary_data;
 
     blink::mojom::PresentationSessionInfoPtr session(
         blink::mojom::PresentationSessionInfo::New());
-    session->url = GURL(kPresentationUrl1);
+    session->url = presentation_url1_;
     session->id = kPresentationId;
 
     PresentationSessionMessageCallback message_cb;
     {
     base::RunLoop run_loop;
     EXPECT_CALL(mock_delegate_, ListenForSessionMessages(_, _, _, _))
         .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                         SaveArg<3>(&message_cb)));
     service_ptr_->ListenForSessionMessages(std::move(session));
     run_loop.Run();
@@ skipping 24 matching lines @@
   MockPresentationServiceDelegate mock_delegate_;
 
   std::unique_ptr<PresentationServiceImpl> service_impl_;
   mojo::InterfacePtr<blink::mojom::PresentationService> service_ptr_;
 
   MockPresentationServiceClient mock_client_;
   std::unique_ptr<mojo::Binding<blink::mojom::PresentationServiceClient>>
       client_binding_;
 
   base::Closure run_loop_quit_closure_;
+
+  GURL presentation_url1_;
+  GURL presentation_url2_;
+  GURL presentation_url3_;
+  std::vector<GURL> presentation_urls_;
 };
 
 TEST_F(PresentationServiceImplTest, ListenForScreenAvailability) {
-  ListenForScreenAvailabilityAndWait(kPresentationUrl1, true);
+  ListenForScreenAvailabilityAndWait(presentation_url1_, true);
 
-  SimulateScreenAvailabilityChangeAndWait(kPresentationUrl1, true);
-  SimulateScreenAvailabilityChangeAndWait(kPresentationUrl1, false);
-  SimulateScreenAvailabilityChangeAndWait(kPresentationUrl1, true);
+  SimulateScreenAvailabilityChangeAndWait(presentation_url1_, true);
+  SimulateScreenAvailabilityChangeAndWait(presentation_url1_, false);
+  SimulateScreenAvailabilityChangeAndWait(presentation_url1_, true);
 }
 
 TEST_F(PresentationServiceImplTest, Reset) {
-  ListenForScreenAvailabilityAndWait(kPresentationUrl1, true);
+  ListenForScreenAvailabilityAndWait(presentation_url1_, true);
 
   ExpectReset();
   service_impl_->Reset();
   ExpectCleanState();
 }
 
 TEST_F(PresentationServiceImplTest, DidNavigateThisFrame) {
-  ListenForScreenAvailabilityAndWait(kPresentationUrl1, true);
+  ListenForScreenAvailabilityAndWait(presentation_url1_, true);
 
   ExpectReset();
   service_impl_->DidNavigateAnyFrame(
       contents()->GetMainFrame(),
       content::LoadCommittedDetails(),
       content::FrameNavigateParams());
   ExpectCleanState();
 }
 
 TEST_F(PresentationServiceImplTest, DidNavigateOtherFrame) {
-  ListenForScreenAvailabilityAndWait(kPresentationUrl1, true);
+  ListenForScreenAvailabilityAndWait(presentation_url1_, true);
 
   // TODO(imcheng): How to get a different RenderFrameHost?
   service_impl_->DidNavigateAnyFrame(
       nullptr,
       content::LoadCommittedDetails(),
       content::FrameNavigateParams());
 
   // Availability is reported and callback is invoked since it was not
   // removed.
-  SimulateScreenAvailabilityChangeAndWait(kPresentationUrl1, true);
+  SimulateScreenAvailabilityChangeAndWait(presentation_url1_, true);
 }
 
 TEST_F(PresentationServiceImplTest, ThisRenderFrameDeleted) {
-  ListenForScreenAvailabilityAndWait(kPresentationUrl1, true);
+  ListenForScreenAvailabilityAndWait(presentation_url1_, true);
 
   ExpectReset();
 
   // Since the frame matched the service, |service_impl_| will be deleted.
   PresentationServiceImpl* service = service_impl_.release();
   EXPECT_CALL(mock_delegate_, RemoveObserver(_, _)).Times(1);
   service->RenderFrameDeleted(contents()->GetMainFrame());
 }
 
 TEST_F(PresentationServiceImplTest, OtherRenderFrameDeleted) {
-  ListenForScreenAvailabilityAndWait(kPresentationUrl1, true);
+  ListenForScreenAvailabilityAndWait(presentation_url1_, true);
 
   // TODO(imcheng): How to get a different RenderFrameHost?
   service_impl_->RenderFrameDeleted(nullptr);
 
   // Availability is reported and callback should be invoked since listener
   // has not been deleted.
-  SimulateScreenAvailabilityChangeAndWait(kPresentationUrl1, true);
+  SimulateScreenAvailabilityChangeAndWait(presentation_url1_, true);
 }
 
 TEST_F(PresentationServiceImplTest, DelegateFails) {
-  ListenForScreenAvailabilityAndWait(kPresentationUrl1, false);
+  ListenForScreenAvailabilityAndWait(presentation_url1_, false);
   ASSERT_EQ(
-      service_impl_->screen_availability_listeners_.find(kPresentationUrl1),
+      service_impl_->screen_availability_listeners_.find(presentation_url1_),
       service_impl_->screen_availability_listeners_.end());
 }
 
 TEST_F(PresentationServiceImplTest, SetDefaultPresentationUrls) {
-  std::vector<std::string> urls({kPresentationUrl1, kPresentationUrl2});
-  EXPECT_CALL(mock_delegate_, SetDefaultPresentationUrls(_, _, urls, _))
+  EXPECT_CALL(mock_delegate_,
+              SetDefaultPresentationUrls(_, _, presentation_urls_, _))
       .Times(1);
 
-  service_impl_->SetDefaultPresentationUrls(ToGURLs(urls));
+  service_impl_->SetDefaultPresentationUrls(presentation_urls_);
 
   // Sets different DPUs.
-  std::vector<std::string> more_urls(
-      {kPresentationUrl1, kPresentationUrl2, "http://barurl.com/"});
+  std::vector<GURL> more_urls = presentation_urls_;
+  more_urls.push_back(presentation_url3_);
 
   content::PresentationSessionStartedCallback callback;
   EXPECT_CALL(mock_delegate_, SetDefaultPresentationUrls(_, _, more_urls, _))
       .WillOnce(SaveArg<3>(&callback));
-  service_impl_->SetDefaultPresentationUrls(ToGURLs(more_urls));
+  service_impl_->SetDefaultPresentationUrls(more_urls);
 
   blink::mojom::PresentationSessionInfo session_info;
-  session_info.url = GURL(kPresentationUrl2);
+  session_info.url = presentation_url2_;
   session_info.id = kPresentationId;
+
   base::RunLoop run_loop;
   EXPECT_CALL(mock_client_,
               OnDefaultSessionStarted(SessionInfoEquals(ByRef(session_info))))
       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
+  EXPECT_CALL(mock_delegate_, ListenForConnectionStateChange(_, _, _, _));
   callback.Run(
-      content::PresentationSessionInfo(kPresentationUrl2, kPresentationId));
+      content::PresentationSessionInfo(presentation_url2_, kPresentationId));
   run_loop.Run();
 }
 
 TEST_F(PresentationServiceImplTest, ListenForConnectionStateChange) {
-  content::PresentationSessionInfo connection(kPresentationUrl1,
+  content::PresentationSessionInfo connection(presentation_url1_,
                                               kPresentationId);
   content::PresentationConnectionStateChangedCallback state_changed_cb;
   EXPECT_CALL(mock_delegate_, ListenForConnectionStateChange(_, _, _, _))
       .WillOnce(SaveArg<3>(&state_changed_cb));
   service_impl_->ListenForConnectionStateChange(connection);
 
   // Trigger state change. It should be propagated back up to |mock_client_|.
   blink::mojom::PresentationSessionInfo presentation_connection;
-  presentation_connection.url = GURL(kPresentationUrl1);
+  presentation_connection.url = presentation_url1_;
   presentation_connection.id = kPresentationId;
   {
     base::RunLoop run_loop;
     EXPECT_CALL(mock_client_,
                 OnConnectionStateChanged(
                     SessionInfoEquals(ByRef(presentation_connection)),
                     blink::mojom::PresentationConnectionState::TERMINATED))
         .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
     state_changed_cb.Run(PresentationConnectionStateChangeInfo(
         PRESENTATION_CONNECTION_STATE_TERMINATED));
     run_loop.Run();
   }
 }
 
 TEST_F(PresentationServiceImplTest, ListenForConnectionClose) {
-  content::PresentationSessionInfo connection(kPresentationUrl1,
+  content::PresentationSessionInfo connection(presentation_url1_,
                                               kPresentationId);
   content::PresentationConnectionStateChangedCallback state_changed_cb;
   EXPECT_CALL(mock_delegate_, ListenForConnectionStateChange(_, _, _, _))
       .WillOnce(SaveArg<3>(&state_changed_cb));
   service_impl_->ListenForConnectionStateChange(connection);
 
   // Trigger connection close. It should be propagated back up to
   // |mock_client_|.
   blink::mojom::PresentationSessionInfo presentation_connection;
-  presentation_connection.url = GURL(kPresentationUrl1);
+  presentation_connection.url = presentation_url1_;
   presentation_connection.id = kPresentationId;
   {
     base::RunLoop run_loop;
     PresentationConnectionStateChangeInfo closed_info(
         PRESENTATION_CONNECTION_STATE_CLOSED);
     closed_info.close_reason = PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY;
     closed_info.message = "Foo";
 
     EXPECT_CALL(
         mock_client_,
         OnConnectionClosed(
             SessionInfoEquals(ByRef(presentation_connection)),
             blink::mojom::PresentationConnectionCloseReason::WENT_AWAY, "Foo"))
         .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
     state_changed_cb.Run(closed_info);
     run_loop.Run();
   }
 }
 
 TEST_F(PresentationServiceImplTest, SetSameDefaultPresentationUrls) {
-  std::vector<std::string> urls({kPresentationUrl1, kPresentationUrl2});
-
-  EXPECT_CALL(mock_delegate_, SetDefaultPresentationUrls(_, _, urls, _))
+  EXPECT_CALL(mock_delegate_,
+              SetDefaultPresentationUrls(_, _, presentation_urls_, _))
       .Times(1);
-  service_impl_->SetDefaultPresentationUrls(ToGURLs(urls));
+  service_impl_->SetDefaultPresentationUrls(presentation_urls_);
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_delegate_));
 
   // Same URLs as before; no-ops.
-  service_impl_->SetDefaultPresentationUrls(ToGURLs(urls));
+  service_impl_->SetDefaultPresentationUrls(presentation_urls_);
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_delegate_));
 }
 
 TEST_F(PresentationServiceImplTest, StartSessionSuccess) {
-  std::vector<std::string> urls({kPresentationUrl1, kPresentationUrl2});
-
   service_ptr_->StartSession(
-      ToGURLs(urls),
+      presentation_urls_,
       base::Bind(&PresentationServiceImplTest::ExpectNewSessionCallbackSuccess,
                  base::Unretained(this)));
   base::RunLoop run_loop;
   base::Callback<void(const PresentationSessionInfo&)> success_cb;
-  EXPECT_CALL(mock_delegate_, StartSession(_, _, urls, _, _))
+  EXPECT_CALL(mock_delegate_, StartSession(_, _, presentation_urls_, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                       SaveArg<3>(&success_cb)));
   run_loop.Run();
 
   EXPECT_CALL(mock_delegate_, ListenForConnectionStateChange(_, _, _, _))
       .Times(1);
-  success_cb.Run(PresentationSessionInfo(kPresentationUrl1, kPresentationId));
+  success_cb.Run(PresentationSessionInfo(presentation_url1_, kPresentationId));
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, StartSessionError) {
-  std::vector<std::string> urls({kPresentationUrl1, kPresentationUrl2});
-
   service_ptr_->StartSession(
-      ToGURLs(urls),
+      presentation_urls_,
       base::Bind(&PresentationServiceImplTest::ExpectNewSessionCallbackError,
                  base::Unretained(this)));
   base::RunLoop run_loop;
   base::Callback<void(const PresentationError&)> error_cb;
-  EXPECT_CALL(mock_delegate_, StartSession(_, _, urls, _, _))
+  EXPECT_CALL(mock_delegate_, StartSession(_, _, presentation_urls_, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                       SaveArg<4>(&error_cb)));
   run_loop.Run();
   error_cb.Run(PresentationError(PRESENTATION_ERROR_UNKNOWN, "Error message"));
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, JoinSessionSuccess) {
-  std::vector<std::string> urls({kPresentationUrl1, kPresentationUrl2});
-
   service_ptr_->JoinSession(
-      ToGURLs(urls), base::Optional<std::string>(kPresentationId),
+      presentation_urls_, base::Optional<std::string>(kPresentationId),
       base::Bind(&PresentationServiceImplTest::ExpectNewSessionCallbackSuccess,
                  base::Unretained(this)));
   base::RunLoop run_loop;
   base::Callback<void(const PresentationSessionInfo&)> success_cb;
-  EXPECT_CALL(mock_delegate_, JoinSession(_, _, urls, kPresentationId, _, _))
+  EXPECT_CALL(mock_delegate_,
+              JoinSession(_, _, presentation_urls_, kPresentationId, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                       SaveArg<4>(&success_cb)));
   run_loop.Run();
 
   EXPECT_CALL(mock_delegate_, ListenForConnectionStateChange(_, _, _, _))
       .Times(1);
-  success_cb.Run(PresentationSessionInfo(kPresentationUrl1, kPresentationId));
+  success_cb.Run(PresentationSessionInfo(presentation_url1_, kPresentationId));
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, JoinSessionError) {
-  std::vector<std::string> urls({kPresentationUrl1, kPresentationUrl2});
-
   service_ptr_->JoinSession(
-      ToGURLs(urls), base::Optional<std::string>(kPresentationId),
+      presentation_urls_, base::Optional<std::string>(kPresentationId),
       base::Bind(&PresentationServiceImplTest::ExpectNewSessionCallbackError,
                  base::Unretained(this)));
   base::RunLoop run_loop;
   base::Callback<void(const PresentationError&)> error_cb;
-  EXPECT_CALL(mock_delegate_, JoinSession(_, _, urls, kPresentationId, _, _))
+  EXPECT_CALL(mock_delegate_,
+              JoinSession(_, _, presentation_urls_, kPresentationId, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                       SaveArg<5>(&error_cb)));
   run_loop.Run();
   error_cb.Run(PresentationError(PRESENTATION_ERROR_UNKNOWN, "Error message"));
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, CloseConnection) {
-  GURL url(kPresentationUrl1);
-  service_ptr_->CloseConnection(url, kPresentationId);
+  service_ptr_->CloseConnection(presentation_url1_, kPresentationId);
 
   base::RunLoop run_loop;
   EXPECT_CALL(mock_delegate_, CloseConnection(_, _, Eq(kPresentationId)))
       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   run_loop.Run();
 }
 
 TEST_F(PresentationServiceImplTest, Terminate) {
-  GURL url(kPresentationUrl1);
-  service_ptr_->Terminate(url, kPresentationId);
+  service_ptr_->Terminate(presentation_url1_, kPresentationId);
   base::RunLoop run_loop;
   EXPECT_CALL(mock_delegate_, Terminate(_, _, Eq(kPresentationId)))
       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   run_loop.Run();
 }
 
 TEST_F(PresentationServiceImplTest, ListenForSessionMessagesPassed) {
   std::string text_msg("123");
   std::vector<uint8_t> binary_data(3, '\1');
   RunListenForSessionMessages(text_msg, binary_data, true);
 }
 
 TEST_F(PresentationServiceImplTest, ListenForSessionMessagesCopied) {
   std::string text_msg("123");
   std::vector<uint8_t> binary_data(3, '\1');
   RunListenForSessionMessages(text_msg, binary_data, false);
 }
 
 TEST_F(PresentationServiceImplTest, ListenForSessionMessagesWithEmptyMsg) {
   std::string text_msg("");
   std::vector<uint8_t> binary_data;
   RunListenForSessionMessages(text_msg, binary_data, false);
 }
 
 TEST_F(PresentationServiceImplTest, StartSessionInProgress) {
-  std::vector<std::string> urls({"http://foourl.com/", "http://barurl.com/"});
-
-  EXPECT_CALL(mock_delegate_, StartSession(_, _, urls, _, _)).Times(1);
-  service_ptr_->StartSession(ToGURLs(urls), base::Bind(&DoNothing));
+  EXPECT_CALL(mock_delegate_, StartSession(_, _, presentation_urls_, _, _))
+      .Times(1);
+  service_ptr_->StartSession(presentation_urls_, base::Bind(&DoNothing));
 
   // This request should fail immediately, since there is already a StartSession
   // in progress.
   service_ptr_->StartSession(
-      ToGURLs(urls),
+      presentation_urls_,
       base::Bind(&PresentationServiceImplTest::ExpectNewSessionCallbackError,
                  base::Unretained(this)));
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, SendStringMessage) {
   std::string message("Test presentation session message");
 
   blink::mojom::PresentationSessionInfoPtr session(
       blink::mojom::PresentationSessionInfo::New());
-  session->url = GURL(kPresentationUrl1);
+  session->url = presentation_url1_;
   session->id = kPresentationId;
   blink::mojom::SessionMessagePtr message_request(
       blink::mojom::SessionMessage::New());
   message_request->type = blink::mojom::PresentationMessageType::TEXT;
   message_request->message = message;
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
                  base::Unretained(this)));
 
@@ skipping 17 matching lines @@
 }
 
 TEST_F(PresentationServiceImplTest, SendArrayBuffer) {
   // Test Array buffer data.
   const uint8_t buffer[] = {0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48};
   std::vector<uint8_t> data;
   data.assign(buffer, buffer + sizeof(buffer));
 
   blink::mojom::PresentationSessionInfoPtr session(
       blink::mojom::PresentationSessionInfo::New());
-  session->url = GURL(kPresentationUrl1);
+  session->url = presentation_url1_;
   session->id = kPresentationId;
   blink::mojom::SessionMessagePtr message_request(
       blink::mojom::SessionMessage::New());
   message_request->type = blink::mojom::PresentationMessageType::ARRAY_BUFFER;
   message_request->data = data;
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
                  base::Unretained(this)));
 
@@ skipping 23 matching lines @@
   // Create buffer with size exceeding the limit.
   // Use same size as in content::kMaxPresentationSessionMessageSize.
   const size_t kMaxBufferSizeInBytes = 64 * 1024;  // 64 KB.
   uint8_t buffer[kMaxBufferSizeInBytes + 1];
   memset(buffer, 0, kMaxBufferSizeInBytes+1);
   std::vector<uint8_t> data;
   data.assign(buffer, buffer + sizeof(buffer));
 
   blink::mojom::PresentationSessionInfoPtr session(
       blink::mojom::PresentationSessionInfo::New());
-  session->url = GURL(kPresentationUrl1);
+  session->url = presentation_url1_;
   session->id = kPresentationId;
   blink::mojom::SessionMessagePtr message_request(
       blink::mojom::SessionMessage::New());
   message_request->type = blink::mojom::PresentationMessageType::ARRAY_BUFFER;
   message_request->data = data;
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
                  base::Unretained(this)));
 
@@ skipping 10 matching lines @@
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, SendBlobData) {
   const uint8_t buffer[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
   std::vector<uint8_t> data;
   data.assign(buffer, buffer + sizeof(buffer));
 
   blink::mojom::PresentationSessionInfoPtr session(
       blink::mojom::PresentationSessionInfo::New());
-  session->url = GURL(kPresentationUrl1);
+  session->url = presentation_url1_;
   session->id = kPresentationId;
   blink::mojom::SessionMessagePtr message_request(
       blink::mojom::SessionMessage::New());
   message_request->type = blink::mojom::PresentationMessageType::BLOB;
   message_request->data = data;
   service_ptr_->SendSessionMessage(
       std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendSessionMessageCallback,
                  base::Unretained(this)));
 
@@ skipping 20 matching lines @@
 }
 
 TEST_F(PresentationServiceImplTest, MaxPendingJoinSessionRequests) {
   const char* presentation_url = "http://fooUrl%d";
   const char* presentation_id = "presentationId%d";
   int num_requests = PresentationServiceImpl::kMaxNumQueuedSessionRequests;
   int i = 0;
   EXPECT_CALL(mock_delegate_, JoinSession(_, _, _, _, _, _))
       .Times(num_requests);
   for (; i < num_requests; ++i) {
-    std::vector<GURL> urls({GURL(base::StringPrintf(presentation_url, i))});
+    std::vector<GURL> urls = {GURL(base::StringPrintf(presentation_url, i))};
     service_ptr_->JoinSession(urls, base::StringPrintf(presentation_id, i),
                               base::Bind(&DoNothing));
   }
 
-  std::vector<GURL> urls({GURL(base::StringPrintf(presentation_url, i))});
+  std::vector<GURL> urls = {GURL(base::StringPrintf(presentation_url, i))};
   // Exceeded maximum queue size, should invoke mojo callback with error.
   service_ptr_->JoinSession(
       urls, base::StringPrintf(presentation_id, i),
       base::Bind(&PresentationServiceImplTest::ExpectNewSessionCallbackError,
                  base::Unretained(this)));
   SaveQuitClosureAndRunLoop();
 }
 
 TEST_F(PresentationServiceImplTest, ScreenAvailabilityNotSupported) {
   mock_delegate_.set_screen_availability_listening_supported(false);
-  GURL url(kPresentationUrl1);
   base::RunLoop run_loop;
-  EXPECT_CALL(mock_client_, OnScreenAvailabilityNotSupported(url))
+  EXPECT_CALL(mock_client_,
+              OnScreenAvailabilityNotSupported(presentation_url1_))
       .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
-  ListenForScreenAvailabilityAndWait(kPresentationUrl1, false);
+  ListenForScreenAvailabilityAndWait(presentation_url1_, false);
   run_loop.Run();
 }
 
 }  // namespace content