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

chrome/browser/ui/webui/media_router/media_router_webui_message_handler.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_webui_message_handler.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 45 matching lines @@
 const char kReportSinkCount[] = "reportSinkCount";
 const char kReportTimeToClickSink[] = "reportTimeToClickSink";
 const char kReportTimeToInitialActionClose[] = "reportTimeToInitialActionClose";
 const char kOnInitialDataReceived[] = "onInitialDataReceived";
 
 // JS function names.
 const char kSetInitialData[] = "media_router.ui.setInitialData";
 const char kOnCreateRouteResponseReceived[] =
     "media_router.ui.onCreateRouteResponseReceived";
 const char kSetIssue[] = "media_router.ui.setIssue";
-const char kSetSinkList[] = "media_router.ui.setSinkList";
+const char kSetSinkListAndIdentityVisibility[] =
+    "media_router.ui.setSinkListAndIdentityVisibility";
 const char kSetRouteList[] = "media_router.ui.setRouteList";
 const char kSetCastModeList[] = "media_router.ui.setCastModeList";
 const char kUpdateMaxHeight[] = "media_router.ui.updateMaxHeight";
 const char kWindowOpen[] = "window.open";
 
-scoped_ptr<base::ListValue> SinksToValue(
+scoped_ptr<base::DictionaryValue> SinksToValue(
     const std::vector<MediaSinkWithCastModes>& sinks) {
+
+  Profile* profile = Profile::FromWebUI(web_ui());
+  SigninManagerBase* signin_manager =
+      SigninManagerFactory::GetForProfile(profile);
+  std::string userDomain =
+      signin_manager->GetAuthenticatedAccountInfo().hosted_domain;
+
+  scoped_ptr<base::DictionaryValue> sink_list_and_identity(
+      new base::DictionaryValue);
   scoped_ptr<base::ListValue> value(new base::ListValue);
+  int identityVisibility = 0;
 
   for (const MediaSinkWithCastModes& sink_with_cast_modes : sinks) {
     scoped_ptr<base::DictionaryValue> sink_val(new base::DictionaryValue);
 
     const MediaSink& sink = sink_with_cast_modes.sink;
     sink_val->SetString("id", sink.id());
     sink_val->SetString("name", sink.name());
     sink_val->SetInteger("iconType", sink.icon_type());
     if (!sink.description().empty())
       sink_val->SetString("description", sink.description());
-    if (!sink.domain().empty())
-      sink_val->SetString("domain", sink.domain());
+    if (!sink.domain().empty()) {
+      std::string domain = sink.domain();
+      // Convert default domains to user domain
+      if (sink.domain() == "default")
+        domain = userDomain;
+
+      sink_val->SetString("domain", domain);
+
+      // Don't reset visibliity to 1 if it was already 2

[apacible, 2016/02/13 08:13:02]

nit: "visibility" misspelled

[amp, 2016/02/16 22:19:12]

Done.

+      if (identityVisibility == 0)

[apacible, 2016/02/13 08:13:02]

Declare identity visibility options as enums here and in the js (see
media_router_data.js for examples). This will make it clear what each type of
visibility refers to and that they're properly used if/when updated.

[amp, 2016/02/16 22:19:12]

Done.  I declared a local enum to this class but decided that it was easier to
just set the boolean's directly instead of passing across the enum.  The end
result is the js side doesn't need to know about it.

+        identityVisibility = 1;
+      if (domain != userDomain)
+        identityVisibility = 2;
+    }
 
     int cast_mode_bits = 0;
     for (MediaCastMode cast_mode : sink_with_cast_modes.cast_modes)
       cast_mode_bits |= cast_mode;
 
     sink_val->SetInteger("castModes", cast_mode_bits);
     value->Append(sink_val.release());
   }
 
-  return value;
+  sink_list_and_identity->Set("sinks", sinks);
+  sink_list_and_identity->SetInteger("identityVisibility",
+      identityVisibility);
+  return sink_list_and_identity;
 }
 
 scoped_ptr<base::DictionaryValue> RouteToValue(
     const MediaRoute& route, bool canJoin, const std::string& extension_id) {
   scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue);
   dictionary->SetString("id", route.media_route_id());
   dictionary->SetString("sinkId", route.media_sink_id());
   dictionary->SetString("description", route.description());
   dictionary->SetBoolean("isLocal", route.is_local());
   dictionary->SetBoolean("canJoin", canJoin);
@@ skipping 93 matching lines @@
       media_router_ui_(media_router_ui) {
   DCHECK(media_router_ui_);
 }
 
 MediaRouterWebUIMessageHandler::~MediaRouterWebUIMessageHandler() {
 }
 
 void MediaRouterWebUIMessageHandler::UpdateSinks(
     const std::vector<MediaSinkWithCastModes>& sinks) {
   DVLOG(2) << "UpdateSinks";
-  scoped_ptr<base::ListValue> sinks_val(SinksToValue(sinks));
-  web_ui()->CallJavascriptFunction(kSetSinkList, *sinks_val);
+  scoped_ptr<base::DictionaryValue> sinks_val(SinksToValue(sinks));
+  web_ui()->CallJavascriptFunction(
+      kSetSinkListAndIdentityVisibility, *sinks_val);
 }
 
 void MediaRouterWebUIMessageHandler::UpdateRoutes(
     const std::vector<MediaRoute>& routes,
     const std::vector<MediaRoute::Id>& joinable_route_ids) {
   scoped_ptr<base::ListValue> routes_val(RoutesToValue(routes,
       joinable_route_ids,
       media_router_ui_->GetRouteProviderExtensionId()));
   web_ui()->CallJavascriptFunction(kSetRouteList, *routes_val);
 }
@@ skipping 120 matching lines @@
   // "Casting to a Hangout from Chrome" Chromecast help center page.
   initial_data.SetString("firstRunFlowCloudPrefLearnMoreUrl",
       base::StringPrintf(kHelpPageUrlPrefix, 6320939));
 #endif  // defined(GOOGLE_CHROME_BUILD)
   // General Chromecast learn more page.
   initial_data.SetString("firstRunFlowLearnMoreUrl", kCastLearnMorePageUrl);
   // "No Cast devices found?" Chromecast help center page.
   initial_data.SetString("deviceMissingUrl",
       base::StringPrintf(kHelpPageUrlPrefix, 3249268));
 
-  scoped_ptr<base::ListValue> sinks(SinksToValue(media_router_ui_->sinks()));
-  initial_data.Set("sinks", sinks.release());
+  scoped_ptr<base::DictionaryValue> sinks_with_identity(SinksToValue(
+      media_router_ui_->sinks()));
+  const base::ListValue* sinks_val = nullptr;
+  sinks_with_identity->GetList("sinks", &sinks_val);
+  int identity_visibility = -1;
+  sinks_with_identity->GetInteger("identityVisibility", &identity_visibility);
+  initial_data.Set("sinks", &sinks_val);
+  initial_data.SetInteger("identityVisibility", identity_visibility);
 
   scoped_ptr<base::ListValue> routes(RoutesToValue(media_router_ui_->routes(),
       media_router_ui_->joinable_route_ids(),
       media_router_ui_->GetRouteProviderExtensionId()));
   initial_data.Set("routes", routes.release());
 
   const std::set<MediaCastMode> cast_modes = media_router_ui_->cast_modes();
   scoped_ptr<base::ListValue> cast_modes_list(
       CastModesToValue(cast_modes,
                        media_router_ui_->GetPresentationRequestSourceName()));
   initial_data.Set("castModes", cast_modes_list.release());
 
   Profile* profile = Profile::FromWebUI(web_ui());
 
   bool first_run_flow_acknowledged =
       profile->GetPrefs()->GetBoolean(
           prefs::kMediaRouterFirstRunFlowAcknowledged);
   initial_data.SetBoolean("wasFirstRunFlowAcknowledged",
                           first_run_flow_acknowledged);
   bool show_cloud_pref = false;
 #if defined(GOOGLE_CHROME_BUILD)
   // Cloud services preference is shown if user is logged in and has sync
   // enabled. If the user enables sync after acknowledging the first run flow,
   // this is treated as the user opting into Google services, including cloud
   // services, if the browser is a Chrome branded build.
+    SigninManagerBase* signin_manager =
+    SigninManagerFactory::GetForProfile(profile);
   if (!profile->GetPrefs()->GetBoolean(
           prefs::kMediaRouterCloudServicesPrefSet) &&
       profile->IsSyncAllowed()) {
-    SigninManagerBase* signin_manager =
-        SigninManagerFactory::GetForProfile(profile);
     show_cloud_pref = signin_manager && signin_manager->IsAuthenticated() &&
         ProfileSyncServiceFactory::GetForProfile(profile)->IsSyncActive();
   }
+  initial_data.SetString("userEmail",
+      signin_manager->GetAuthenticatedAccountInfo().email);
+  initial_data.SetString("userDomain",
+      signin_manager->GetAuthenticatedAccountInfo().hosted_domain);
 #endif  // defined(GOOGLE_CHROME_BUILD)
   initial_data.SetBoolean("showFirstRunFlowCloudPref", show_cloud_pref);
 
   web_ui()->CallJavascriptFunction(kSetInitialData, initial_data);
   media_router_ui_->UIInitialized();
 }
 
 void MediaRouterWebUIMessageHandler::OnCreateRoute(
     const base::ListValue* args) {
   DVLOG(1) << "OnCreateRoute";
@@ skipping 296 matching lines @@
     // Do nothing; no other issue action types require any other action.
     return true;
   }
 }
 
 void MediaRouterWebUIMessageHandler::SetWebUIForTest(content::WebUI* web_ui) {
   set_web_ui(web_ui);
 }
 
 }  // namespace media_router