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

chrome/browser/ui/webui/media_router/query_result_manager_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 "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/router/media_sinks_observer.h"
 #include "chrome/browser/media/router/media_source_helper.h"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/ui/webui/media_router/query_result_manager.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
 
 using testing::Eq;
 using testing::IsEmpty;
 using testing::Eq;
 using testing::Mock;
 using testing::Return;
 using testing::_;
 
 namespace media_router {
 
@@ skipping 81 matching lines @@
 }
 
 TEST_F(QueryResultManagerTest, StartStopSinksQuery) {
   GURL origin(kOrigin);
   CastModeSet cast_modes = query_result_manager_.GetSupportedCastModes();
   EXPECT_TRUE(cast_modes.empty());
   std::vector<MediaSource> actual_sources =
       query_result_manager_.GetSourcesForCastMode(MediaCastMode::DEFAULT);
   EXPECT_EQ(0u, actual_sources.size());
 
-  MediaSource source(MediaSourceForPresentationUrl("http://foo.com"));
+  MediaSource source(MediaSourceForPresentationUrl(GURL("http://foo.com")));
   EXPECT_CALL(mock_router_, RegisterMediaSinksObserver(_))
       .WillOnce(Return(true));
   query_result_manager_.SetSourcesForCastMode(MediaCastMode::DEFAULT, {source},
                                               origin);
 
   cast_modes = query_result_manager_.GetSupportedCastModes();
   EXPECT_EQ(1u, cast_modes.size());
   EXPECT_TRUE(base::ContainsKey(cast_modes, MediaCastMode::DEFAULT));
   actual_sources =
       query_result_manager_.GetSourcesForCastMode(MediaCastMode::DEFAULT);
   EXPECT_EQ(1u, actual_sources.size());
   EXPECT_EQ(source, actual_sources[0]);
 
   // Register a different set of sources for the same cast mode.
-  MediaSource another_source(MediaSourceForPresentationUrl("http://bar.com"));
+  MediaSource another_source(
+      MediaSourceForPresentationUrl(GURL("http://bar.com")));
   EXPECT_CALL(mock_router_, UnregisterMediaSinksObserver(_)).Times(1);
   EXPECT_CALL(mock_router_, RegisterMediaSinksObserver(_))
       .WillOnce(Return(true));
   query_result_manager_.SetSourcesForCastMode(MediaCastMode::DEFAULT,
                                               {another_source}, origin);
 
   cast_modes = query_result_manager_.GetSupportedCastModes();
   EXPECT_EQ(1u, cast_modes.size());
   EXPECT_TRUE(base::ContainsKey(cast_modes, MediaCastMode::DEFAULT));
   actual_sources =
@@ skipping 10 matching lines @@
       query_result_manager_.GetSourcesForCastMode(MediaCastMode::DEFAULT);
   EXPECT_EQ(0u, actual_sources.size());
 }
 
 TEST_F(QueryResultManagerTest, MultipleQueries) {
   MediaSink sink1("sinkId1", "Sink 1", MediaSink::IconType::CAST);
   MediaSink sink2("sinkId2", "Sink 2", MediaSink::IconType::CAST);
   MediaSink sink3("sinkId3", "Sink 3", MediaSink::IconType::CAST);
   MediaSink sink4("sinkId4", "Sink 4", MediaSink::IconType::CAST);
   MediaSink sink5("sinkId5", "Sink 5", MediaSink::IconType::CAST);
-  MediaSource default_source1 = MediaSourceForPresentationUrl("http://bar.com");
-  MediaSource default_source2 = MediaSourceForPresentationUrl("http://baz.com");
+  MediaSource default_source1 =
+      MediaSourceForPresentationUrl(GURL("http://bar.com"));
+  MediaSource default_source2 =
+      MediaSourceForPresentationUrl(GURL("http://baz.com"));
   MediaSource tab_source = MediaSourceForTab(123);
   GURL origin(kOrigin);
 
   query_result_manager_.AddObserver(&mock_observer_);
   DiscoverSinks(MediaCastMode::DEFAULT, default_source1);
   DiscoverSinks(MediaCastMode::TAB_MIRROR, tab_source);
 
   // Scenario (results in this order):
   // Action: DEFAULT -> [1, 2, 3]
   // Expected result:
@@ skipping 94 matching lines @@
 
   // Remaining observers: DEFAULT observer, which will be removed on destruction
   EXPECT_CALL(mock_router_, UnregisterMediaSinksObserver(_)).Times(1);
 }
 
 TEST_F(QueryResultManagerTest, MultipleUrls) {
   const MediaSink sink1("sinkId1", "Sink 1", MediaSink::IconType::CAST);
   const MediaSink sink2("sinkId2", "Sink 2", MediaSink::IconType::CAST);
   const MediaSink sink3("sinkId3", "Sink 3", MediaSink::IconType::CAST);
   const MediaSink sink4("sinkId4", "Sink 4", MediaSink::IconType::CAST);
-  const MediaSource source_a(MediaSourceForPresentationUrl("http://urlA.com"));
-  const MediaSource source_b(MediaSourceForPresentationUrl("http://urlB.com"));
-  const MediaSource source_c(MediaSourceForPresentationUrl("http://urlC.com"));
+  const MediaSource source_a(
+      MediaSourceForPresentationUrl(GURL("http://urlA.com")));
+  const MediaSource source_b(
+      MediaSourceForPresentationUrl(GURL("http://urlB.com")));
+  const MediaSource source_c(
+      MediaSourceForPresentationUrl(GURL("http://urlC.com")));
   const MediaSource source_tab(MediaSourceForTab(1));
   // The sources are in decreasing order of priority.
   const std::vector<MediaSource> default_sources = {source_a, source_b,
                                                     source_c};
   const std::vector<MediaSource> tab_sources = {source_tab};
   const GURL origin(kOrigin);
   const auto& sinks_observers = query_result_manager_.sinks_observers_;
 
   // There should be one MediaSinksObserver per source.
   EXPECT_CALL(mock_router_, RegisterMediaSinksObserver(_))
@@ skipping 77 matching lines @@
   EXPECT_TRUE(IsTabSourceForSink(nullptr, sink3));
   EXPECT_TRUE(IsTabSourceForSink(nullptr, sink4));
 
   // The observers for the four sources should get unregistered.
   EXPECT_CALL(mock_router_, UnregisterMediaSinksObserver(_)).Times(4);
   query_result_manager_.RemoveSourcesForCastMode(MediaCastMode::DEFAULT);
   query_result_manager_.RemoveSourcesForCastMode(MediaCastMode::TAB_MIRROR);
 }
 
 TEST_F(QueryResultManagerTest, AddInvalidSource) {
-  const MediaSource source(MediaSourceForPresentationUrl("http://url.com"));
+  const MediaSource source(
+      MediaSourceForPresentationUrl(GURL("http://url.com")));
   const GURL origin(kOrigin);
 
   EXPECT_CALL(mock_router_, RegisterMediaSinksObserver(_))
       .Times(1)
       .WillRepeatedly(Return(true));
   query_result_manager_.SetSourcesForCastMode(MediaCastMode::DEFAULT, {source},
                                               origin);
   // |source| has already been registered with the default cast mode, so it
   // shouldn't get registered with tab mirroring.
   query_result_manager_.SetSourcesForCastMode(MediaCastMode::TAB_MIRROR,
                                               {source}, origin);
 
   const auto& cast_mode_sources = query_result_manager_.cast_mode_sources_;
   const auto& default_sources = cast_mode_sources.at(MediaCastMode::DEFAULT);
   EXPECT_TRUE(base::ContainsKey(cast_mode_sources, MediaCastMode::DEFAULT));
   EXPECT_EQ(default_sources.size(), 1u);
   EXPECT_EQ(default_sources.at(0), source);
   EXPECT_FALSE(base::ContainsKey(cast_mode_sources, MediaCastMode::TAB_MIRROR));
 }
 
 }  // namespace media_router