[Media Router] Show user email in header if cloud sink is present.

chrome/browser/ui/webui/media_router/media_router_webui_message_handler_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/macros.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/media_router/media_router_test.h"
 #include "chrome/browser/ui/webui/media_router/media_router_ui.h"
 #include "chrome/browser/ui/webui/media_router/media_router_webui_message_handler.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/test/test_web_ui.h"
 #include "extensions/common/constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::ReturnRef;
 
 namespace media_router {
 
 const char kProviderExtensionIdForTesting[] = "test_id";
 const char kControllerPathForTesting[] = "test_path";
+const std::string kUserEmailForTesting = "nobody@example.com";
+const std::string kUserDomainForTesting = "example.com";
 
 class MockMediaRouterUI : public MediaRouterUI {
  public:
   explicit MockMediaRouterUI(content::WebUI* web_ui)
       : MediaRouterUI(web_ui) {}
   ~MockMediaRouterUI() {}
 
   MOCK_CONST_METHOD0(GetRouteProviderExtensionId, const std::string&());
 };
 
+class TestMediaRouterWebUIMessageHandler
+    : public MediaRouterWebUIMessageHandler {
+ public:
+  explicit TestMediaRouterWebUIMessageHandler(MediaRouterUI* media_router_ui)
+      : MediaRouterWebUIMessageHandler(media_router_ui),
+        email_(kUserEmailForTesting),
+        domain_(kUserDomainForTesting) {}
+  ~TestMediaRouterWebUIMessageHandler() override = default;
+
+  AccountInfo GetAccountInfo() override {
+    AccountInfo info = AccountInfo();
+    info.account_id = info.gaia = info.email = email_;
+    info.hosted_domain = domain_;
+    info.full_name = info.given_name = "name";
+    info.locale = "locale";
+    info.picture_url = "picture";
+
+    return info;
+  }
+
+  void SetEmailAndDomain(const std::string& email, const std::string& domain) {
+    email_ = email;
+    domain_ = domain;
+  }
+
+ private:
+  std::string email_;
+  std::string domain_;
+};
+
 class MediaRouterWebUIMessageHandlerTest : public MediaRouterTest {
  public:
   MediaRouterWebUIMessageHandlerTest()
     : web_ui_(new content::TestWebUI()),
       provider_extension_id_(kProviderExtensionIdForTesting) {}
   ~MediaRouterWebUIMessageHandlerTest() override {}
 
   // BrowserWithTestWindowTest:
   void SetUp() override {
     BrowserWithTestWindowTest::SetUp();
     chrome::NewTab(browser());
     web_ui_->set_web_contents(
         browser()->tab_strip_model()->GetActiveWebContents());
     mock_media_router_ui_.reset(new MockMediaRouterUI(web_ui_.get()));
     handler_.reset(
-        new MediaRouterWebUIMessageHandler(mock_media_router_ui_.get()));
+        new TestMediaRouterWebUIMessageHandler(mock_media_router_ui_.get()));
     handler_->SetWebUIForTest(web_ui_.get());
   }
 
   void TearDown() override {
     handler_.reset();
     mock_media_router_ui_.reset();
     web_ui_.reset();
     BrowserWithTestWindowTest::TearDown();
   }
 
   const std::string& provider_extension_id() const {
     return provider_extension_id_;
   }
 
  protected:
   scoped_ptr<content::TestWebUI> web_ui_;
   scoped_ptr<MockMediaRouterUI> mock_media_router_ui_;
-  scoped_ptr<MediaRouterWebUIMessageHandler> handler_;
+  scoped_ptr<TestMediaRouterWebUIMessageHandler> handler_;
   const std::string provider_extension_id_;
 };
 
 TEST_F(MediaRouterWebUIMessageHandlerTest, UpdateSinks) {
   MediaSink::Id sink_id("sinkId123");
   std::string sink_name("The sink");
 
   std::vector<MediaSinkWithCastModes> media_sink_with_cast_modes_list;
   MediaSinkWithCastModes media_sink_with_cast_modes(
       MediaSink(sink_id, sink_name, MediaSink::IconType::CAST));
   media_sink_with_cast_modes.cast_modes.insert(MediaCastMode::TAB_MIRROR);
   media_sink_with_cast_modes_list.push_back(media_sink_with_cast_modes);
 
   handler_->UpdateSinks(media_sink_with_cast_modes_list);
   EXPECT_EQ(1u, web_ui_->call_data().size());
   const content::TestWebUI::CallData& call_data = *web_ui_->call_data()[0];
-  EXPECT_EQ("media_router.ui.setSinkList", call_data.function_name());
+  EXPECT_EQ("media_router.ui.setSinkListAndIdentity",
+            call_data.function_name());
   const base::Value* arg1 = call_data.arg1();
+  const base::DictionaryValue* sinks_with_identity_value = nullptr;
+  ASSERT_TRUE(arg1->GetAsDictionary(&sinks_with_identity_value));
+
+  // Email is not displayed if there is no sinks with domain.
+  bool show_email = false;
+  bool actual_show_email = false;
+  EXPECT_TRUE(
+      sinks_with_identity_value->GetBoolean("showEmail", &actual_show_email));
+  EXPECT_EQ(show_email, actual_show_email);
+
+  // Domain is not displayed if there is no sinks with domain.
+  bool show_domain = false;
+  bool actual_show_domain = false;
+  EXPECT_TRUE(
+      sinks_with_identity_value->GetBoolean("showDomain", &actual_show_domain));
+  EXPECT_EQ(show_domain, actual_show_domain);
+
   const base::ListValue* sinks_list_value = nullptr;
-  ASSERT_TRUE(arg1->GetAsList(&sinks_list_value));
+  ASSERT_TRUE(sinks_with_identity_value->GetList("sinks", &sinks_list_value));
   const base::DictionaryValue* sink_value = nullptr;
   ASSERT_TRUE(sinks_list_value->GetDictionary(0, &sink_value));
 
   std::string value;
   EXPECT_TRUE(sink_value->GetString("id", &value));
   EXPECT_EQ(sink_id, value);
 
   EXPECT_TRUE(sink_value->GetString("name", &value));
   EXPECT_EQ(sink_name, value);
 
   int cast_mode_bits = -1;
   ASSERT_TRUE(sink_value->GetInteger("castModes", &cast_mode_bits));
   EXPECT_EQ(static_cast<int>(MediaCastMode::TAB_MIRROR), cast_mode_bits);
 }
 
+#if defined(GOOGLE_CHROME_BUILD)
+TEST_F(MediaRouterWebUIMessageHandlerTest, UpdateSinksWithIdentity) {
+  MediaSink::Id sink_id("sinkId123");
+  std::string sink_name("The sink");
+
+  std::vector<MediaSinkWithCastModes> media_sink_with_cast_modes_list;
+  MediaSinkWithCastModes media_sink_with_cast_modes(
+      MediaSink(sink_id, sink_name, MediaSink::IconType::CAST));
+  media_sink_with_cast_modes.sink.set_domain(kUserDomainForTesting);
+  media_sink_with_cast_modes.cast_modes.insert(MediaCastMode::TAB_MIRROR);
+  media_sink_with_cast_modes_list.push_back(media_sink_with_cast_modes);
+
+  handler_->UpdateSinks(media_sink_with_cast_modes_list);
+  EXPECT_EQ(1u, web_ui_->call_data().size());
+  const content::TestWebUI::CallData& call_data = *web_ui_->call_data()[0];
+  EXPECT_EQ("media_router.ui.setSinkListAndIdentity",
+            call_data.function_name());
+  const base::Value* arg1 = call_data.arg1();
+  const base::DictionaryValue* sinks_with_identity_value = nullptr;
+  ASSERT_TRUE(arg1->GetAsDictionary(&sinks_with_identity_value));
+
+  bool show_email = true;
+  bool actual_show_email = false;
+  EXPECT_TRUE(
+      sinks_with_identity_value->GetBoolean("showEmail", &actual_show_email));
+  EXPECT_EQ(show_email, actual_show_email);
+
+  // Sink domain is not displayed if it matches user domain.
+  bool show_domain = false;
+  bool actual_show_domain = false;
+  EXPECT_TRUE(
+      sinks_with_identity_value->GetBoolean("showDomain", &actual_show_domain));
+  EXPECT_EQ(show_domain, actual_show_domain);
+
+  std::string value;
+  EXPECT_TRUE(sinks_with_identity_value->GetString("userEmail", &value));
+  EXPECT_EQ(kUserEmailForTesting, value);
+
+  EXPECT_TRUE(sinks_with_identity_value->GetString("userDomain", &value));
+  EXPECT_EQ(kUserDomainForTesting, value);
+}
+
+TEST_F(MediaRouterWebUIMessageHandlerTest, UpdateSinksWithIdentityAndDomain) {
+  MediaSink::Id sink_id("sinkId123");
+  std::string sink_name("The sink");
+  std::string domain_name("google.com");
+
+  std::vector<MediaSinkWithCastModes> media_sink_with_cast_modes_list;
+  MediaSinkWithCastModes media_sink_with_cast_modes(
+      MediaSink(sink_id, sink_name, MediaSink::IconType::CAST));
+  media_sink_with_cast_modes.sink.set_domain(domain_name);
+  media_sink_with_cast_modes.cast_modes.insert(MediaCastMode::TAB_MIRROR);
+  media_sink_with_cast_modes_list.push_back(media_sink_with_cast_modes);
+
+  handler_->UpdateSinks(media_sink_with_cast_modes_list);
+  EXPECT_EQ(1u, web_ui_->call_data().size());
+  const content::TestWebUI::CallData& call_data = *web_ui_->call_data()[0];
+  EXPECT_EQ("media_router.ui.setSinkListAndIdentity",
+            call_data.function_name());
+  const base::Value* arg1 = call_data.arg1();
+  const base::DictionaryValue* sinks_with_identity_value = nullptr;
+  ASSERT_TRUE(arg1->GetAsDictionary(&sinks_with_identity_value));
+
+  // Domain is displayed for sinks with domains that are not the user domain.
+  bool show_domain = true;
+  bool actual_show_domain = false;
+  EXPECT_TRUE(
+      sinks_with_identity_value->GetBoolean("showDomain", &actual_show_domain));
+  EXPECT_EQ(show_domain, actual_show_domain);
+
+  std::string value;
+  EXPECT_TRUE(sinks_with_identity_value->GetString("userDomain", &value));
+  EXPECT_EQ(kUserDomainForTesting, value);
+}
+
+TEST_F(MediaRouterWebUIMessageHandlerTest, UpdateSinksWithNoDomain) {
+  MediaSink::Id sink_id("sinkId123");
+  std::string sink_name("The sink");
+  std::string user_email("nobody@gmail.com");
+  std::string user_domain("NO_HOSTED_DOMAIN");
+  std::string domain_name("default");
+
+  handler_->SetEmailAndDomain(user_email, user_domain);
+
+  std::vector<MediaSinkWithCastModes> media_sink_with_cast_modes_list;
+  MediaSinkWithCastModes media_sink_with_cast_modes(
+      MediaSink(sink_id, sink_name, MediaSink::IconType::CAST));
+  media_sink_with_cast_modes.sink.set_domain(domain_name);
+  media_sink_with_cast_modes.cast_modes.insert(MediaCastMode::TAB_MIRROR);
+  media_sink_with_cast_modes_list.push_back(media_sink_with_cast_modes);
+
+  handler_->UpdateSinks(media_sink_with_cast_modes_list);
+  EXPECT_EQ(1u, web_ui_->call_data().size());
+  const content::TestWebUI::CallData& call_data = *web_ui_->call_data()[0];
+  EXPECT_EQ("media_router.ui.setSinkListAndIdentity",
+            call_data.function_name());
+  const base::Value* arg1 = call_data.arg1();
+  const base::DictionaryValue* sinks_with_identity_value = nullptr;
+  ASSERT_TRUE(arg1->GetAsDictionary(&sinks_with_identity_value));
+
+  const base::ListValue* sinks_list_value = nullptr;
+  ASSERT_TRUE(sinks_with_identity_value->GetList("sinks", &sinks_list_value));
+  const base::DictionaryValue* sink_value = nullptr;
+  ASSERT_TRUE(sinks_list_value->GetDictionary(0, &sink_value));
+
+  // Domain should not be shown if there were only default sink domains.
+  bool show_domain = false;
+  bool actual_show_domain = false;
+  EXPECT_TRUE(
+      sinks_with_identity_value->GetBoolean("showDomain", &actual_show_domain));
+  EXPECT_EQ(show_domain, actual_show_domain);
+
+  // Sink domain should be empty if user has no hosted domain.
+  std::string value;
+  EXPECT_TRUE(sink_value->GetString("domain", &value));
+  EXPECT_EQ(std::string(), value);
+
+  EXPECT_TRUE(sinks_with_identity_value->GetString("userDomain", &value));
+  EXPECT_EQ(user_domain, value);
+}
+
+TEST_F(MediaRouterWebUIMessageHandlerTest, UpdateSinksWithDefaultDomain) {
+  MediaSink::Id sink_id("sinkId123");
+  std::string sink_name("The sink");
+  std::string domain_name("default");
+
+  std::vector<MediaSinkWithCastModes> media_sink_with_cast_modes_list;
+  MediaSinkWithCastModes media_sink_with_cast_modes(
+      MediaSink(sink_id, sink_name, MediaSink::IconType::CAST));
+  media_sink_with_cast_modes.sink.set_domain(domain_name);
+  media_sink_with_cast_modes.cast_modes.insert(MediaCastMode::TAB_MIRROR);
+  media_sink_with_cast_modes_list.push_back(media_sink_with_cast_modes);
+
+  handler_->UpdateSinks(media_sink_with_cast_modes_list);
+  EXPECT_EQ(1u, web_ui_->call_data().size());
+  const content::TestWebUI::CallData& call_data = *web_ui_->call_data()[0];
+  EXPECT_EQ("media_router.ui.setSinkListAndIdentity",
+            call_data.function_name());
+  const base::Value* arg1 = call_data.arg1();
+  const base::DictionaryValue* sinks_with_identity_value = nullptr;
+  ASSERT_TRUE(arg1->GetAsDictionary(&sinks_with_identity_value));
+
+  const base::ListValue* sinks_list_value = nullptr;
+  ASSERT_TRUE(sinks_with_identity_value->GetList("sinks", &sinks_list_value));
+  const base::DictionaryValue* sink_value = nullptr;
+  ASSERT_TRUE(sinks_list_value->GetDictionary(0, &sink_value));
+
+  // Domain should not be shown if there were only default sink domains.
+  bool show_domain = false;
+  bool actual_show_domain = false;
+  EXPECT_TRUE(
+      sinks_with_identity_value->GetBoolean("showDomain", &actual_show_domain));
+  EXPECT_EQ(show_domain, actual_show_domain);
+
+  std::string value;
+  EXPECT_TRUE(sinks_with_identity_value->GetString("userDomain", &value));
+  EXPECT_EQ(kUserDomainForTesting, value);
+
+  // Sink domain should be updated from 'default' to user domain.
+  EXPECT_TRUE(sink_value->GetString("domain", &value));
+  EXPECT_EQ(kUserDomainForTesting, value);
+}
+#endif  // defined(GOOGLE_CHROME_BUILD)
+
 TEST_F(MediaRouterWebUIMessageHandlerTest, UpdateRoutes) {
   MediaRoute::Id route_id("routeId123");
   MediaSink::Id sink_id("sinkId123");
   MediaSink sink(sink_id, "The sink", MediaSink::IconType::CAST);
   MediaSource media_source("mediaSource");
   std::string description("This is a route");
   bool is_local = true;
   std::vector<MediaRoute> routes;
   routes.push_back(MediaRoute(route_id, media_source, sink_id,
                               description, is_local, kControllerPathForTesting,
@@ skipping 117 matching lines @@
 
   EXPECT_TRUE(issue_value->GetString("routeId", &value));
   EXPECT_EQ(route_id, value);
 
   bool actual_is_blocking = false;
   EXPECT_TRUE(issue_value->GetBoolean("isBlocking", &actual_is_blocking));
   EXPECT_EQ(is_blocking, actual_is_blocking);
 }
 
 }  // namespace media_router