[Presentation API] Add support for multiple URLs in PresentationRequest on Media Router UI side

chrome/browser/ui/webui/media_router/media_router_ui_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/ui/webui/media_router/media_router_ui.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/media/router/create_presentation_connection_request.h"
 #include "chrome/browser/media/router/media_route.h"
 #include "chrome/browser/media/router/media_source_helper.h"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/media/router/route_request_result.h"
 #include "chrome/browser/media/router/test_helper.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
@@ skipping 13 matching lines @@
 
 using testing::_;
 using testing::AnyNumber;
 using testing::Invoke;
 using testing::SaveArg;
 using testing::Return;
 
 namespace media_router {
 
 class PresentationRequestCallbacks {
-public:
+ public:
   explicit PresentationRequestCallbacks(
       const content::PresentationError& expected_error)
       : expected_error_(expected_error) {}
 
   void Success(const content::PresentationSessionInfo&, const MediaRoute::Id&) {
   }
 
   void Error(const content::PresentationError& error) {
     EXPECT_EQ(expected_error_.error_type, error.error_type);
     EXPECT_EQ(expected_error_.message, error.message);
   }
 
-private:
+ private:
   content::PresentationError expected_error_;
 };
 
 class MockRoutesUpdatedCallback {
  public:
   MOCK_METHOD2(OnRoutesUpdated,
                void(const std::vector<MediaRoute>& routes,
                     const std::vector<MediaRoute::Id>& joinable_route_ids));
 };
 
@@ skipping 22 matching lines @@
           return true;
         }));
     EXPECT_CALL(mock_router_, RegisterMediaRoutesObserver(_))
         .Times(AnyNumber());
     media_router_ui_->InitForTest(&mock_router_, initiator_.get(),
                                   message_handler_.get(),
                                   std::move(create_session_request_));
     message_handler_->SetWebUIForTest(&web_ui_);
   }
 
+  MediaSink CreateSinkCompatibleWithAllSources() {
+    MediaSink sink("sinkId", "sinkName", MediaSink::GENERIC);
+    for (auto* observer : media_sinks_observers_)
+      observer->OnSinksUpdated({sink}, std::vector<GURL>());
+    return sink;
+  }
+
  protected:
   MockMediaRouter mock_router_;
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   std::unique_ptr<content::WebContents> initiator_;
   content::TestWebUI web_ui_;
   std::unique_ptr<content::WebContents> web_contents_;
   std::unique_ptr<CreatePresentationConnectionRequest> create_session_request_;
   std::unique_ptr<MediaRouterUI> media_router_ui_;
   std::unique_ptr<MediaRouterWebUIMessageHandler> message_handler_;
   std::vector<MediaSinksObserver*> media_sinks_observers_;
 };
 
 TEST_F(MediaRouterUITest, RouteCreationTimeoutForTab) {
   CreateMediaRouterUI(&profile_);
   std::vector<MediaRouteResponseCallback> callbacks;
   EXPECT_CALL(
       mock_router_,
       CreateRoute(_, _, _, _, _, base::TimeDelta::FromSeconds(60), false))
       .WillOnce(SaveArg<4>(&callbacks));
-  media_router_ui_->CreateRoute("sinkId", MediaCastMode::TAB_MIRROR);
+  media_router_ui_->CreateRoute(CreateSinkCompatibleWithAllSources().id(),
+                                MediaCastMode::TAB_MIRROR);
 
   std::string expected_title = l10n_util::GetStringUTF8(
       IDS_MEDIA_ROUTER_ISSUE_CREATE_ROUTE_TIMEOUT_FOR_TAB);
   EXPECT_CALL(mock_router_, AddIssue(IssueTitleEquals(expected_title)));
   std::unique_ptr<RouteRequestResult> result =
       RouteRequestResult::FromError("Timed out", RouteRequestResult::TIMED_OUT);
   for (const auto& callback : callbacks)
     callback.Run(*result);
 }
 
 TEST_F(MediaRouterUITest, RouteCreationTimeoutForDesktop) {
   CreateMediaRouterUI(&profile_);
   std::vector<MediaRouteResponseCallback> callbacks;
   EXPECT_CALL(
       mock_router_,
       CreateRoute(_, _, _, _, _, base::TimeDelta::FromSeconds(120), false))
       .WillOnce(SaveArg<4>(&callbacks));
-  media_router_ui_->CreateRoute("sinkId", MediaCastMode::DESKTOP_MIRROR);
+  media_router_ui_->CreateRoute(CreateSinkCompatibleWithAllSources().id(),
+                                MediaCastMode::DESKTOP_MIRROR);
 
   std::string expected_title = l10n_util::GetStringUTF8(
       IDS_MEDIA_ROUTER_ISSUE_CREATE_ROUTE_TIMEOUT_FOR_DESKTOP);
   EXPECT_CALL(mock_router_, AddIssue(IssueTitleEquals(expected_title)));
   std::unique_ptr<RouteRequestResult> result =
       RouteRequestResult::FromError("Timed out", RouteRequestResult::TIMED_OUT);
   for (const auto& callback : callbacks)
     callback.Run(*result);
 }
 
 TEST_F(MediaRouterUITest, RouteCreationTimeoutForPresentation) {
   CreateMediaRouterUI(&profile_);
   PresentationRequest presentation_request(RenderFrameHostId(0, 0),
-                                           "https://presentationurl.fakeurl",
+                                           {"https://presentationurl.fakeurl"},
                                            GURL("https://frameurl.fakeurl"));
   media_router_ui_->OnDefaultPresentationChanged(presentation_request);
   std::vector<MediaRouteResponseCallback> callbacks;
   EXPECT_CALL(
       mock_router_,
       CreateRoute(_, _, _, _, _, base::TimeDelta::FromSeconds(20), false))
       .WillOnce(SaveArg<4>(&callbacks));
-  media_router_ui_->CreateRoute("sinkId", MediaCastMode::DEFAULT);
+  media_router_ui_->CreateRoute(CreateSinkCompatibleWithAllSources().id(),
+                                MediaCastMode::DEFAULT);
 
   std::string expected_title =
       l10n_util::GetStringFUTF8(IDS_MEDIA_ROUTER_ISSUE_CREATE_ROUTE_TIMEOUT,
                                 base::UTF8ToUTF16("frameurl.fakeurl"));
   EXPECT_CALL(mock_router_, AddIssue(IssueTitleEquals(expected_title)));
   std::unique_ptr<RouteRequestResult> result =
       RouteRequestResult::FromError("Timed out", RouteRequestResult::TIMED_OUT);
   for (const auto& callback : callbacks)
     callback.Run(*result);
 }
@@ skipping 10 matching lines @@
   std::string expected_title = l10n_util::GetStringUTF8(
       IDS_MEDIA_ROUTER_ISSUE_CREATE_ROUTE_TIMEOUT_FOR_TAB);
   EXPECT_CALL(mock_router_, AddIssue(IssueTitleEquals(expected_title)));
   sink_callback.Run("foundSinkId");
 }
 
 TEST_F(MediaRouterUITest, RouteRequestFromIncognito) {
   CreateMediaRouterUI(profile_.GetOffTheRecordProfile());
 
   PresentationRequest presentation_request(
-      RenderFrameHostId(0, 0), "https://fooUrl", GURL("https://frameUrl"));
+      RenderFrameHostId(0, 0), {"https://fooUrl"}, GURL("https://frameUrl"));
   media_router_ui_->OnDefaultPresentationChanged(presentation_request);
 
   EXPECT_CALL(
       mock_router_,
       CreateRoute(_, _, _, _, _, base::TimeDelta::FromSeconds(20), true));
-  media_router_ui_->CreateRoute("sinkId", MediaCastMode::DEFAULT);
+  media_router_ui_->CreateRoute(CreateSinkCompatibleWithAllSources().id(),
+                                MediaCastMode::DEFAULT);
 }
 
 TEST_F(MediaRouterUITest, SortedSinks) {
   CreateMediaRouterUI(&profile_);
   std::vector<MediaSinkWithCastModes> unsorted_sinks;
   std::string sink_id1("sink3");
   std::string sink_name1("B sink");
   MediaSinkWithCastModes sink1(
       MediaSink(sink_id1, sink_name1, MediaSink::IconType::CAST));
   unsorted_sinks.push_back(sink1);
@@ skipping 299 matching lines @@
   for (auto* observer : media_sinks_observers_) {
     if (observer->source().id() == presentation_url) {
       observer->OnSinksUpdated(sinks, origins);
     }
   }
   // Destroying the UI should return the expected error from above to the error
   // callback.
   media_router_ui_.reset();
 }
 }  // namespace media_router