OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/macros.h" | 5 #include "base/macros.h" |
6 #include "base/strings/stringprintf.h" | 6 #include "base/strings/stringprintf.h" |
7 #include "chrome/browser/ui/browser_commands.h" | 7 #include "chrome/browser/ui/browser_commands.h" |
8 #include "chrome/browser/ui/tabs/tab_strip_model.h" | 8 #include "chrome/browser/ui/tabs/tab_strip_model.h" |
9 #include "chrome/browser/ui/webui/media_router/media_router_test.h" | 9 #include "chrome/browser/ui/webui/media_router/media_router_test.h" |
10 #include "chrome/browser/ui/webui/media_router/media_router_ui.h" | 10 #include "chrome/browser/ui/webui/media_router/media_router_ui.h" |
11 #include "chrome/browser/ui/webui/media_router/media_router_webui_message_handle
r.h" | 11 #include "chrome/browser/ui/webui/media_router/media_router_webui_message_handle
r.h" |
12 #include "content/public/browser/browser_context.h" | 12 #include "content/public/browser/browser_context.h" |
13 #include "content/public/test/test_web_ui.h" | 13 #include "content/public/test/test_web_ui.h" |
14 #include "extensions/common/constants.h" | 14 #include "extensions/common/constants.h" |
15 #include "testing/gmock/include/gmock/gmock.h" | 15 #include "testing/gmock/include/gmock/gmock.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
17 | 17 |
18 using testing::ReturnRef; | 18 using testing::ReturnRef; |
19 | 19 |
20 namespace media_router { | 20 namespace media_router { |
21 | 21 |
22 const char kProviderExtensionIdForTesting[] = "test_id"; | 22 const char kProviderExtensionIdForTesting[] = "test_id"; |
23 const char kControllerPathForTesting[] = "test_path"; | 23 const char kControllerPathForTesting[] = "test_path"; |
| 24 const std::string kUserEmailForTesting = "nobody@example.com"; |
| 25 const std::string kUserDomainForTesting = "example.com"; |
24 | 26 |
25 class MockMediaRouterUI : public MediaRouterUI { | 27 class MockMediaRouterUI : public MediaRouterUI { |
26 public: | 28 public: |
27 explicit MockMediaRouterUI(content::WebUI* web_ui) | 29 explicit MockMediaRouterUI(content::WebUI* web_ui) |
28 : MediaRouterUI(web_ui) {} | 30 : MediaRouterUI(web_ui) {} |
29 ~MockMediaRouterUI() {} | 31 ~MockMediaRouterUI() {} |
30 | 32 |
31 MOCK_CONST_METHOD0(GetRouteProviderExtensionId, const std::string&()); | 33 MOCK_CONST_METHOD0(GetRouteProviderExtensionId, const std::string&()); |
32 }; | 34 }; |
33 | 35 |
| 36 class TestMediaRouterWebUIMessageHandler |
| 37 : public MediaRouterWebUIMessageHandler { |
| 38 public: |
| 39 explicit TestMediaRouterWebUIMessageHandler(MediaRouterUI* media_router_ui) |
| 40 : MediaRouterWebUIMessageHandler(media_router_ui), |
| 41 email_(kUserEmailForTesting), |
| 42 domain_(kUserDomainForTesting) {} |
| 43 ~TestMediaRouterWebUIMessageHandler() override = default; |
| 44 |
| 45 AccountInfo GetAccountInfo() override { |
| 46 AccountInfo info = AccountInfo(); |
| 47 info.account_id = info.gaia = info.email = email_; |
| 48 info.hosted_domain = domain_; |
| 49 info.full_name = info.given_name = "name"; |
| 50 info.locale = "locale"; |
| 51 info.picture_url = "picture"; |
| 52 |
| 53 return info; |
| 54 } |
| 55 |
| 56 void SetEmailAndDomain(const std::string& email, const std::string& domain) { |
| 57 email_ = email; |
| 58 domain_ = domain; |
| 59 } |
| 60 |
| 61 private: |
| 62 std::string email_; |
| 63 std::string domain_; |
| 64 }; |
| 65 |
34 class MediaRouterWebUIMessageHandlerTest : public MediaRouterTest { | 66 class MediaRouterWebUIMessageHandlerTest : public MediaRouterTest { |
35 public: | 67 public: |
36 MediaRouterWebUIMessageHandlerTest() | 68 MediaRouterWebUIMessageHandlerTest() |
37 : web_ui_(new content::TestWebUI()), | 69 : web_ui_(new content::TestWebUI()), |
38 provider_extension_id_(kProviderExtensionIdForTesting) {} | 70 provider_extension_id_(kProviderExtensionIdForTesting) {} |
39 ~MediaRouterWebUIMessageHandlerTest() override {} | 71 ~MediaRouterWebUIMessageHandlerTest() override {} |
40 | 72 |
41 // BrowserWithTestWindowTest: | 73 // BrowserWithTestWindowTest: |
42 void SetUp() override { | 74 void SetUp() override { |
43 BrowserWithTestWindowTest::SetUp(); | 75 BrowserWithTestWindowTest::SetUp(); |
44 chrome::NewTab(browser()); | 76 chrome::NewTab(browser()); |
45 web_ui_->set_web_contents( | 77 web_ui_->set_web_contents( |
46 browser()->tab_strip_model()->GetActiveWebContents()); | 78 browser()->tab_strip_model()->GetActiveWebContents()); |
47 mock_media_router_ui_.reset(new MockMediaRouterUI(web_ui_.get())); | 79 mock_media_router_ui_.reset(new MockMediaRouterUI(web_ui_.get())); |
48 handler_.reset( | 80 handler_.reset( |
49 new MediaRouterWebUIMessageHandler(mock_media_router_ui_.get())); | 81 new TestMediaRouterWebUIMessageHandler(mock_media_router_ui_.get())); |
50 handler_->SetWebUIForTest(web_ui_.get()); | 82 handler_->SetWebUIForTest(web_ui_.get()); |
51 } | 83 } |
52 | 84 |
53 void TearDown() override { | 85 void TearDown() override { |
54 handler_.reset(); | 86 handler_.reset(); |
55 mock_media_router_ui_.reset(); | 87 mock_media_router_ui_.reset(); |
56 web_ui_.reset(); | 88 web_ui_.reset(); |
57 BrowserWithTestWindowTest::TearDown(); | 89 BrowserWithTestWindowTest::TearDown(); |
58 } | 90 } |
59 | 91 |
60 const std::string& provider_extension_id() const { | 92 const std::string& provider_extension_id() const { |
61 return provider_extension_id_; | 93 return provider_extension_id_; |
62 } | 94 } |
63 | 95 |
64 protected: | 96 protected: |
65 scoped_ptr<content::TestWebUI> web_ui_; | 97 scoped_ptr<content::TestWebUI> web_ui_; |
66 scoped_ptr<MockMediaRouterUI> mock_media_router_ui_; | 98 scoped_ptr<MockMediaRouterUI> mock_media_router_ui_; |
67 scoped_ptr<MediaRouterWebUIMessageHandler> handler_; | 99 scoped_ptr<TestMediaRouterWebUIMessageHandler> handler_; |
68 const std::string provider_extension_id_; | 100 const std::string provider_extension_id_; |
69 }; | 101 }; |
70 | 102 |
71 TEST_F(MediaRouterWebUIMessageHandlerTest, UpdateSinks) { | 103 TEST_F(MediaRouterWebUIMessageHandlerTest, UpdateSinks) { |
72 MediaSink::Id sink_id("sinkId123"); | 104 MediaSink::Id sink_id("sinkId123"); |
73 std::string sink_name("The sink"); | 105 std::string sink_name("The sink"); |
74 | 106 |
75 std::vector<MediaSinkWithCastModes> media_sink_with_cast_modes_list; | 107 std::vector<MediaSinkWithCastModes> media_sink_with_cast_modes_list; |
76 MediaSinkWithCastModes media_sink_with_cast_modes( | 108 MediaSinkWithCastModes media_sink_with_cast_modes( |
77 MediaSink(sink_id, sink_name, MediaSink::IconType::CAST)); | 109 MediaSink(sink_id, sink_name, MediaSink::IconType::CAST)); |
78 media_sink_with_cast_modes.cast_modes.insert(MediaCastMode::TAB_MIRROR); | 110 media_sink_with_cast_modes.cast_modes.insert(MediaCastMode::TAB_MIRROR); |
79 media_sink_with_cast_modes_list.push_back(media_sink_with_cast_modes); | 111 media_sink_with_cast_modes_list.push_back(media_sink_with_cast_modes); |
80 | 112 |
81 handler_->UpdateSinks(media_sink_with_cast_modes_list); | 113 handler_->UpdateSinks(media_sink_with_cast_modes_list); |
82 EXPECT_EQ(1u, web_ui_->call_data().size()); | 114 EXPECT_EQ(1u, web_ui_->call_data().size()); |
83 const content::TestWebUI::CallData& call_data = *web_ui_->call_data()[0]; | 115 const content::TestWebUI::CallData& call_data = *web_ui_->call_data()[0]; |
84 EXPECT_EQ("media_router.ui.setSinkList", call_data.function_name()); | 116 EXPECT_EQ("media_router.ui.setSinkListAndIdentity", |
| 117 call_data.function_name()); |
85 const base::Value* arg1 = call_data.arg1(); | 118 const base::Value* arg1 = call_data.arg1(); |
| 119 const base::DictionaryValue* sinks_with_identity_value = nullptr; |
| 120 ASSERT_TRUE(arg1->GetAsDictionary(&sinks_with_identity_value)); |
| 121 |
| 122 // Email is not displayed if there is no sinks with domain. |
| 123 bool show_email = false; |
| 124 bool actual_show_email = false; |
| 125 EXPECT_TRUE( |
| 126 sinks_with_identity_value->GetBoolean("showEmail", &actual_show_email)); |
| 127 EXPECT_EQ(show_email, actual_show_email); |
| 128 |
| 129 // Domain is not displayed if there is no sinks with domain. |
| 130 bool show_domain = false; |
| 131 bool actual_show_domain = false; |
| 132 EXPECT_TRUE( |
| 133 sinks_with_identity_value->GetBoolean("showDomain", &actual_show_domain)); |
| 134 EXPECT_EQ(show_domain, actual_show_domain); |
| 135 |
86 const base::ListValue* sinks_list_value = nullptr; | 136 const base::ListValue* sinks_list_value = nullptr; |
87 ASSERT_TRUE(arg1->GetAsList(&sinks_list_value)); | 137 ASSERT_TRUE(sinks_with_identity_value->GetList("sinks", &sinks_list_value)); |
88 const base::DictionaryValue* sink_value = nullptr; | 138 const base::DictionaryValue* sink_value = nullptr; |
89 ASSERT_TRUE(sinks_list_value->GetDictionary(0, &sink_value)); | 139 ASSERT_TRUE(sinks_list_value->GetDictionary(0, &sink_value)); |
90 | 140 |
91 std::string value; | 141 std::string value; |
92 EXPECT_TRUE(sink_value->GetString("id", &value)); | 142 EXPECT_TRUE(sink_value->GetString("id", &value)); |
93 EXPECT_EQ(sink_id, value); | 143 EXPECT_EQ(sink_id, value); |
94 | 144 |
95 EXPECT_TRUE(sink_value->GetString("name", &value)); | 145 EXPECT_TRUE(sink_value->GetString("name", &value)); |
96 EXPECT_EQ(sink_name, value); | 146 EXPECT_EQ(sink_name, value); |
97 | 147 |
98 int cast_mode_bits = -1; | 148 int cast_mode_bits = -1; |
99 ASSERT_TRUE(sink_value->GetInteger("castModes", &cast_mode_bits)); | 149 ASSERT_TRUE(sink_value->GetInteger("castModes", &cast_mode_bits)); |
100 EXPECT_EQ(static_cast<int>(MediaCastMode::TAB_MIRROR), cast_mode_bits); | 150 EXPECT_EQ(static_cast<int>(MediaCastMode::TAB_MIRROR), cast_mode_bits); |
101 } | 151 } |
102 | 152 |
| 153 #if defined(GOOGLE_CHROME_BUILD) |
| 154 TEST_F(MediaRouterWebUIMessageHandlerTest, UpdateSinksWithIdentity) { |
| 155 MediaSink::Id sink_id("sinkId123"); |
| 156 std::string sink_name("The sink"); |
| 157 |
| 158 std::vector<MediaSinkWithCastModes> media_sink_with_cast_modes_list; |
| 159 MediaSinkWithCastModes media_sink_with_cast_modes( |
| 160 MediaSink(sink_id, sink_name, MediaSink::IconType::CAST)); |
| 161 media_sink_with_cast_modes.sink.set_domain(kUserDomainForTesting); |
| 162 media_sink_with_cast_modes.cast_modes.insert(MediaCastMode::TAB_MIRROR); |
| 163 media_sink_with_cast_modes_list.push_back(media_sink_with_cast_modes); |
| 164 |
| 165 handler_->UpdateSinks(media_sink_with_cast_modes_list); |
| 166 EXPECT_EQ(1u, web_ui_->call_data().size()); |
| 167 const content::TestWebUI::CallData& call_data = *web_ui_->call_data()[0]; |
| 168 EXPECT_EQ("media_router.ui.setSinkListAndIdentity", |
| 169 call_data.function_name()); |
| 170 const base::Value* arg1 = call_data.arg1(); |
| 171 const base::DictionaryValue* sinks_with_identity_value = nullptr; |
| 172 ASSERT_TRUE(arg1->GetAsDictionary(&sinks_with_identity_value)); |
| 173 |
| 174 bool show_email = true; |
| 175 bool actual_show_email = false; |
| 176 EXPECT_TRUE( |
| 177 sinks_with_identity_value->GetBoolean("showEmail", &actual_show_email)); |
| 178 EXPECT_EQ(show_email, actual_show_email); |
| 179 |
| 180 // Sink domain is not displayed if it matches user domain. |
| 181 bool show_domain = false; |
| 182 bool actual_show_domain = false; |
| 183 EXPECT_TRUE( |
| 184 sinks_with_identity_value->GetBoolean("showDomain", &actual_show_domain)); |
| 185 EXPECT_EQ(show_domain, actual_show_domain); |
| 186 |
| 187 std::string value; |
| 188 EXPECT_TRUE(sinks_with_identity_value->GetString("userEmail", &value)); |
| 189 EXPECT_EQ(kUserEmailForTesting, value); |
| 190 |
| 191 EXPECT_TRUE(sinks_with_identity_value->GetString("userDomain", &value)); |
| 192 EXPECT_EQ(kUserDomainForTesting, value); |
| 193 } |
| 194 |
| 195 TEST_F(MediaRouterWebUIMessageHandlerTest, UpdateSinksWithIdentityAndDomain) { |
| 196 MediaSink::Id sink_id("sinkId123"); |
| 197 std::string sink_name("The sink"); |
| 198 std::string domain_name("google.com"); |
| 199 |
| 200 std::vector<MediaSinkWithCastModes> media_sink_with_cast_modes_list; |
| 201 MediaSinkWithCastModes media_sink_with_cast_modes( |
| 202 MediaSink(sink_id, sink_name, MediaSink::IconType::CAST)); |
| 203 media_sink_with_cast_modes.sink.set_domain(domain_name); |
| 204 media_sink_with_cast_modes.cast_modes.insert(MediaCastMode::TAB_MIRROR); |
| 205 media_sink_with_cast_modes_list.push_back(media_sink_with_cast_modes); |
| 206 |
| 207 handler_->UpdateSinks(media_sink_with_cast_modes_list); |
| 208 EXPECT_EQ(1u, web_ui_->call_data().size()); |
| 209 const content::TestWebUI::CallData& call_data = *web_ui_->call_data()[0]; |
| 210 EXPECT_EQ("media_router.ui.setSinkListAndIdentity", |
| 211 call_data.function_name()); |
| 212 const base::Value* arg1 = call_data.arg1(); |
| 213 const base::DictionaryValue* sinks_with_identity_value = nullptr; |
| 214 ASSERT_TRUE(arg1->GetAsDictionary(&sinks_with_identity_value)); |
| 215 |
| 216 // Domain is displayed for sinks with domains that are not the user domain. |
| 217 bool show_domain = true; |
| 218 bool actual_show_domain = false; |
| 219 EXPECT_TRUE( |
| 220 sinks_with_identity_value->GetBoolean("showDomain", &actual_show_domain)); |
| 221 EXPECT_EQ(show_domain, actual_show_domain); |
| 222 |
| 223 std::string value; |
| 224 EXPECT_TRUE(sinks_with_identity_value->GetString("userDomain", &value)); |
| 225 EXPECT_EQ(kUserDomainForTesting, value); |
| 226 } |
| 227 |
| 228 TEST_F(MediaRouterWebUIMessageHandlerTest, UpdateSinksWithNoDomain) { |
| 229 MediaSink::Id sink_id("sinkId123"); |
| 230 std::string sink_name("The sink"); |
| 231 std::string user_email("nobody@gmail.com"); |
| 232 std::string user_domain("NO_HOSTED_DOMAIN"); |
| 233 std::string domain_name("default"); |
| 234 |
| 235 handler_->SetEmailAndDomain(user_email, user_domain); |
| 236 |
| 237 std::vector<MediaSinkWithCastModes> media_sink_with_cast_modes_list; |
| 238 MediaSinkWithCastModes media_sink_with_cast_modes( |
| 239 MediaSink(sink_id, sink_name, MediaSink::IconType::CAST)); |
| 240 media_sink_with_cast_modes.sink.set_domain(domain_name); |
| 241 media_sink_with_cast_modes.cast_modes.insert(MediaCastMode::TAB_MIRROR); |
| 242 media_sink_with_cast_modes_list.push_back(media_sink_with_cast_modes); |
| 243 |
| 244 handler_->UpdateSinks(media_sink_with_cast_modes_list); |
| 245 EXPECT_EQ(1u, web_ui_->call_data().size()); |
| 246 const content::TestWebUI::CallData& call_data = *web_ui_->call_data()[0]; |
| 247 EXPECT_EQ("media_router.ui.setSinkListAndIdentity", |
| 248 call_data.function_name()); |
| 249 const base::Value* arg1 = call_data.arg1(); |
| 250 const base::DictionaryValue* sinks_with_identity_value = nullptr; |
| 251 ASSERT_TRUE(arg1->GetAsDictionary(&sinks_with_identity_value)); |
| 252 |
| 253 const base::ListValue* sinks_list_value = nullptr; |
| 254 ASSERT_TRUE(sinks_with_identity_value->GetList("sinks", &sinks_list_value)); |
| 255 const base::DictionaryValue* sink_value = nullptr; |
| 256 ASSERT_TRUE(sinks_list_value->GetDictionary(0, &sink_value)); |
| 257 |
| 258 // Domain should not be shown if there were only default sink domains. |
| 259 bool show_domain = false; |
| 260 bool actual_show_domain = false; |
| 261 EXPECT_TRUE( |
| 262 sinks_with_identity_value->GetBoolean("showDomain", &actual_show_domain)); |
| 263 EXPECT_EQ(show_domain, actual_show_domain); |
| 264 |
| 265 // Sink domain should be empty if user has no hosted domain. |
| 266 std::string value; |
| 267 EXPECT_TRUE(sink_value->GetString("domain", &value)); |
| 268 EXPECT_EQ(std::string(), value); |
| 269 |
| 270 EXPECT_TRUE(sinks_with_identity_value->GetString("userDomain", &value)); |
| 271 EXPECT_EQ(user_domain, value); |
| 272 } |
| 273 |
| 274 TEST_F(MediaRouterWebUIMessageHandlerTest, UpdateSinksWithDefaultDomain) { |
| 275 MediaSink::Id sink_id("sinkId123"); |
| 276 std::string sink_name("The sink"); |
| 277 std::string domain_name("default"); |
| 278 |
| 279 std::vector<MediaSinkWithCastModes> media_sink_with_cast_modes_list; |
| 280 MediaSinkWithCastModes media_sink_with_cast_modes( |
| 281 MediaSink(sink_id, sink_name, MediaSink::IconType::CAST)); |
| 282 media_sink_with_cast_modes.sink.set_domain(domain_name); |
| 283 media_sink_with_cast_modes.cast_modes.insert(MediaCastMode::TAB_MIRROR); |
| 284 media_sink_with_cast_modes_list.push_back(media_sink_with_cast_modes); |
| 285 |
| 286 handler_->UpdateSinks(media_sink_with_cast_modes_list); |
| 287 EXPECT_EQ(1u, web_ui_->call_data().size()); |
| 288 const content::TestWebUI::CallData& call_data = *web_ui_->call_data()[0]; |
| 289 EXPECT_EQ("media_router.ui.setSinkListAndIdentity", |
| 290 call_data.function_name()); |
| 291 const base::Value* arg1 = call_data.arg1(); |
| 292 const base::DictionaryValue* sinks_with_identity_value = nullptr; |
| 293 ASSERT_TRUE(arg1->GetAsDictionary(&sinks_with_identity_value)); |
| 294 |
| 295 const base::ListValue* sinks_list_value = nullptr; |
| 296 ASSERT_TRUE(sinks_with_identity_value->GetList("sinks", &sinks_list_value)); |
| 297 const base::DictionaryValue* sink_value = nullptr; |
| 298 ASSERT_TRUE(sinks_list_value->GetDictionary(0, &sink_value)); |
| 299 |
| 300 // Domain should not be shown if there were only default sink domains. |
| 301 bool show_domain = false; |
| 302 bool actual_show_domain = false; |
| 303 EXPECT_TRUE( |
| 304 sinks_with_identity_value->GetBoolean("showDomain", &actual_show_domain)); |
| 305 EXPECT_EQ(show_domain, actual_show_domain); |
| 306 |
| 307 std::string value; |
| 308 EXPECT_TRUE(sinks_with_identity_value->GetString("userDomain", &value)); |
| 309 EXPECT_EQ(kUserDomainForTesting, value); |
| 310 |
| 311 // Sink domain should be updated from 'default' to user domain. |
| 312 EXPECT_TRUE(sink_value->GetString("domain", &value)); |
| 313 EXPECT_EQ(kUserDomainForTesting, value); |
| 314 } |
| 315 #endif // defined(GOOGLE_CHROME_BUILD) |
| 316 |
103 TEST_F(MediaRouterWebUIMessageHandlerTest, UpdateRoutes) { | 317 TEST_F(MediaRouterWebUIMessageHandlerTest, UpdateRoutes) { |
104 MediaRoute::Id route_id("routeId123"); | 318 MediaRoute::Id route_id("routeId123"); |
105 MediaSink::Id sink_id("sinkId123"); | 319 MediaSink::Id sink_id("sinkId123"); |
106 MediaSink sink(sink_id, "The sink", MediaSink::IconType::CAST); | 320 MediaSink sink(sink_id, "The sink", MediaSink::IconType::CAST); |
107 MediaSource media_source("mediaSource"); | 321 MediaSource media_source("mediaSource"); |
108 std::string description("This is a route"); | 322 std::string description("This is a route"); |
109 bool is_local = true; | 323 bool is_local = true; |
110 std::vector<MediaRoute> routes; | 324 std::vector<MediaRoute> routes; |
111 routes.push_back(MediaRoute(route_id, media_source, sink_id, | 325 routes.push_back(MediaRoute(route_id, media_source, sink_id, |
112 description, is_local, kControllerPathForTesting, | 326 description, is_local, kControllerPathForTesting, |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
230 | 444 |
231 EXPECT_TRUE(issue_value->GetString("routeId", &value)); | 445 EXPECT_TRUE(issue_value->GetString("routeId", &value)); |
232 EXPECT_EQ(route_id, value); | 446 EXPECT_EQ(route_id, value); |
233 | 447 |
234 bool actual_is_blocking = false; | 448 bool actual_is_blocking = false; |
235 EXPECT_TRUE(issue_value->GetBoolean("isBlocking", &actual_is_blocking)); | 449 EXPECT_TRUE(issue_value->GetBoolean("isBlocking", &actual_is_blocking)); |
236 EXPECT_EQ(is_blocking, actual_is_blocking); | 450 EXPECT_EQ(is_blocking, actual_is_blocking); |
237 } | 451 } |
238 | 452 |
239 } // namespace media_router | 453 } // namespace media_router |
OLD | NEW |