[Hotword] Hotword and Audio History settings should reflect sync sign in

chrome/browser/ui/webui/options/browser_options_handler.cc

 // Copyright (c) 2012 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/options/browser_options_handler.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 521 matching lines @@
   base::string16 omnibox_url = base::ASCIIToUTF16(chrome::kOmniboxLearnMoreURL);
   values->SetString(
       "defaultSearchGroupLabel",
       l10n_util::GetStringFUTF16(IDS_SEARCH_PREF_EXPLANATION, omnibox_url));
   values->SetString("hotwordLearnMoreURL", chrome::kHotwordLearnMoreURL);
   RegisterTitle(values, "hotwordConfirmOverlay",
                 IDS_HOTWORD_CONFIRM_BUBBLE_TITLE);
   values->SetString("hotwordManageAudioHistoryURL",
                     chrome::kManageAudioHistoryURL);
 
+#if defined(OS_CHROMEOS)
   Profile* profile = Profile::FromWebUI(web_ui());
-#if defined(OS_CHROMEOS)
   std::string username = profile->GetProfileName();
   if (username.empty()) {
     user_manager::User* user =
-      chromeos::ProfileHelper::Get()->GetUserByProfile(profile);
+        chromeos::ProfileHelper::Get()->GetUserByProfile(profile);
     if (user && (user->GetType() != user_manager::USER_TYPE_GUEST))
       username = user->email();
   }
   if (!username.empty())
     username = gaia::SanitizeEmail(gaia::CanonicalizeEmail(username));
 
   values->SetString("username", username);
 #endif
 
-  base::string16 user_email;
-  // If the profile is a guest session, it will not be found in the cache.
-  // In that case, just set the value with an empty string for the email since
-  // it won't be displayed anyways for a guest profile.
-  if (!profile->IsGuestSession()) {
-    ProfileInfoCache& cache =
-        g_browser_process->profile_manager()->GetProfileInfoCache();
-    user_email = cache.GetUserNameOfProfileAtIndex(
-        cache.GetIndexOfProfileWithPath(profile->GetPath()));
-  }
-  values->SetString(
-      "hotwordAudioHistoryEnabled",
-      l10n_util::GetStringFUTF16(IDS_HOTWORD_AUDIO_HISTORY_ENABLED,
-                                 user_email));
-
   // Pass along sync status early so it will be available during page init.
   values->Set("syncData", GetSyncStateDictionary().release());
 
   values->SetString("privacyLearnMoreURL", chrome::kPrivacyLearnMoreURL);
   values->SetString("doNotTrackLearnMoreURL", chrome::kDoNotTrackLearnMoreURL);
 
 #if !defined(OS_CHROMEOS)
   values->SetBoolean("metricsReportingEnabledAtStart",
        ChromeMetricsServiceAccessor::IsMetricsReportingEnabled());
 #endif
@@ skipping 625 matching lines @@
           template_url_service_->IsExtensionControlledDefaultSearch()));
 
   if (default_index != -1 && model_urls[default_index]->HasGoogleBaseURLs(
           template_url_service_->search_terms_data())) {
     // If the user has chosen Google as the default search provider, make
     // hotwording as an option available again.
     HandleRequestHotwordAvailable(nullptr);
   } else {
     // If the user has chosen a default search provide other than Google, turn
     // off hotwording since other providers don't provide that functionality.
-    web_ui()->CallJavascriptFunction("BrowserOptions.setHotwordSectionVisible",
-                                     base::FundamentalValue(false));
+    web_ui()->CallJavascriptFunction(
+        "BrowserOptions.setAllHotwordSectionsVisible",
+        base::FundamentalValue(false));
     HotwordService* hotword_service =
         HotwordServiceFactory::GetForProfile(Profile::FromWebUI(web_ui()));
     if (hotword_service)
       hotword_service->DisableHotwordPreferences();
   }
 
   SetupExtensionControlledIndicators();
 }
 
 void BrowserOptionsHandler::SetDefaultSearchEngine(
@@ skipping 330 matching lines @@
           GetStatusString();
   web_ui()->CallJavascriptFunction(
       "BrowserOptions.setConsumerManagementStatus", base::StringValue(status));
 }
 
 #endif  // defined(OS_CHROMEOS)
 
 void BrowserOptionsHandler::UpdateSyncState() {
   web_ui()->CallJavascriptFunction("BrowserOptions.updateSyncState",
                                    *GetSyncStateDictionary());
+
+  // A change in sign-in state also affects how hotwording and audio history are
+  // displayed. Hide all hotwording and re-display properly.
+  web_ui()->CallJavascriptFunction(
+      "BrowserOptions.setAllHotwordSectionsVisible",
+      base::FundamentalValue(false));
+  HandleRequestHotwordAvailable(nullptr);
 }
 
 void BrowserOptionsHandler::OnSigninAllowedPrefChange() {
   UpdateSyncState();
 }
 
 void BrowserOptionsHandler::HandleAutoOpenButton(const base::ListValue* args) {
   content::RecordAction(UserMetricsAction("Options_ResetAutoOpenFiles"));
   DownloadManager* manager = BrowserContext::GetDownloadManager(
       web_ui()->GetWebContents()->GetBrowserContext());
@@ skipping 100 matching lines @@
   Profile* profile = Profile::FromWebUI(web_ui());
   std::string group = base::FieldTrialList::FindFullName("VoiceTrigger");
   if (group != "" && group != "Disabled" &&
       HotwordServiceFactory::IsHotwordAllowed(profile)) {
     // Update the current error value.
     HotwordServiceFactory::IsServiceAvailable(profile);
     int error = HotwordServiceFactory::GetCurrentError(profile);
 
     std::string function_name;
     bool always_on = false;
+    SigninManagerBase* signin = SigninManagerFactory::GetForProfile(profile);
+    bool authenticated = signin && signin->IsAuthenticated();
     if (HotwordService::IsExperimentalHotwordingEnabled()) {
-      if (HotwordServiceFactory::IsHotwordHardwareAvailable()) {
+      if (HotwordServiceFactory::IsHotwordHardwareAvailable() &&
+          authenticated) {
         function_name = "BrowserOptions.showHotwordAlwaysOnSection";
         always_on = true;
         // Show the retrain link if always-on is enabled.
         if (profile->GetPrefs()->GetBoolean(
                 prefs::kHotwordAlwaysOnSearchEnabled)) {
           web_ui()->CallJavascriptFunction(
               "BrowserOptions.setHotwordRetrainLinkVisible",
               base::FundamentalValue(true));
         }
       } else {
         function_name = "BrowserOptions.showHotwordNoDspSection";
       }
     } else {
       function_name = "BrowserOptions.showHotwordSection";
     }
 
     // Audio history should be displayed if it's enabled regardless of the
-    // hotword error state. An additional message is displayed if always-on
-    // hotwording is enabled.
+    // hotword error state if the user is signed in. If the user is not signed
+    // in, audio history is meaningless. An additional message is displayed if
+    // always-on hotwording is enabled.
     if (profile->GetPrefs()->GetBoolean(prefs::kHotwordAudioLoggingEnabled) &&
-        HotwordService::IsExperimentalHotwordingEnabled()) {
+        HotwordService::IsExperimentalHotwordingEnabled() &&
+        authenticated) {
+      std::string user_display_name = signin->GetAuthenticatedUsername();
+      DCHECK(!user_display_name.empty());
+
+      base::string16 audio_history_state =
+          l10n_util::GetStringFUTF16(IDS_HOTWORD_AUDIO_HISTORY_ENABLED,
+                                     base::ASCIIToUTF16(user_display_name));
       web_ui()->CallJavascriptFunction("BrowserOptions.showAudioHistorySection",
-                                       base::FundamentalValue(always_on));
+                                       base::FundamentalValue(always_on),
+                                       base::StringValue(audio_history_state));
     }
 
     if (!error) {
       web_ui()->CallJavascriptFunction(function_name);
     } else {
       base::string16 hotword_help_url =
           base::ASCIIToUTF16(chrome::kHotwordLearnMoreURL);
       base::StringValue error_message(l10n_util::GetStringUTF16(error));
       if (error == IDS_HOTWORD_GENERIC_ERROR_MESSAGE) {
         error_message = base::StringValue(
@@ skipping 347 matching lines @@
 void BrowserOptionsHandler::OnPolicyUpdated(const policy::PolicyNamespace& ns,
                                             const policy::PolicyMap& previous,
                                             const policy::PolicyMap& current) {
   std::set<std::string> different_keys;
   current.GetDifferingKeys(previous, &different_keys);
   if (ContainsKey(different_keys, policy::key::kMetricsReportingEnabled))
     SetupMetricsReportingCheckbox();
 }
 
 }  // namespace options