Delete the old hotwording integration.

chrome/browser/search/hotword_service.cc

 // Copyright 2013 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/search/hotword_service.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/i18n/case_conversion.h"
@@ skipping 110 matching lines @@
 // This is used for UMA stats -- do not reorder or delete items; only add to
 // the end.
 enum HotwordError {
   NO_HOTWORD_ERROR = 0,
   GENERIC_HOTWORD_ERROR,
   NACL_HOTWORD_ERROR,
   MICROPHONE_HOTWORD_ERROR,
   NUM_HOTWORD_ERROR_METRICS
 };
 
-void RecordExtensionAvailabilityMetrics(
-    ExtensionService* service,
-    const extensions::Extension* extension) {
-  HotwordExtensionAvailability availability_state = UNAVAILABLE;
-  if (extension) {
-    availability_state = AVAILABLE;
-  } else if (service->pending_extension_manager() &&
-             service->pending_extension_manager()->IsIdPending(
-                 extension_misc::kHotwordExtensionId)) {
-    availability_state = PENDING_DOWNLOAD;
-  } else if (!service->IsExtensionEnabled(
-      extension_misc::kHotwordExtensionId)) {
-    availability_state = DISABLED_EXTENSION;
-  }
-  UMA_HISTOGRAM_ENUMERATION("Hotword.HotwordExtensionAvailability",
-                            availability_state,
-                            NUM_HOTWORD_EXTENSION_AVAILABILITY_METRICS);
-}
-
 void RecordLoggingMetrics(Profile* profile) {
   // If the user is not opted in to hotword voice search, the audio logging
   // metric is not valid so it is not recorded.
   if (!profile->GetPrefs()->GetBoolean(prefs::kHotwordSearchEnabled))
     return;
 
   UMA_HISTOGRAM_BOOLEAN(
       "Hotword.HotwordAudioLogging",
       profile->GetPrefs()->GetBoolean(prefs::kHotwordAudioLoggingEnabled));
 }
@@ skipping 18 matching lines @@
                             error,
                             NUM_HOTWORD_ERROR_METRICS);
 }
 
 void RecordHotwordEnabledMetric(HotwordService *service, Profile* profile) {
   HotwordEnabled enabled_state = DISABLED;
   auto prefs = profile->GetPrefs();
   if (!prefs->HasPrefPath(prefs::kHotwordSearchEnabled) &&
       !prefs->HasPrefPath(prefs::kHotwordAlwaysOnSearchEnabled)) {
     enabled_state = UNSET;
-  } else if (service->IsExperimentalHotwordingEnabled() &&
-             service->IsAlwaysOnEnabled()) {
+  } else if (service->IsAlwaysOnEnabled()) {
     enabled_state = ALWAYS_ON_ENABLED;
   } else if (prefs->GetBoolean(prefs::kHotwordSearchEnabled)) {
     enabled_state = ENABLED;
   }
   UMA_HISTOGRAM_ENUMERATION("Hotword.Enabled", enabled_state,
                             NUM_HOTWORD_ENABLED_METRICS);
 }
 
 ExtensionService* GetExtensionService(Profile* profile) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
@@ skipping 86 matching lines @@
       l10n_util::NormalizeLocale(GetCurrentLocale(profile));
   base::StringToLowerASCII(&normalized_locale);
 
   for (size_t i = 0; i < arraysize(kSupportedLocales); i++) {
     if (normalized_locale == kSupportedLocales[i])
       return true;
   }
   return false;
 }
 
-// static
-bool HotwordService::IsExperimentalHotwordingEnabled() {
-  return true;
-}
-
 #if defined(OS_CHROMEOS)
 class HotwordService::HotwordUserSessionStateObserver
     : public user_manager::UserManager::UserSessionStateObserver {
  public:
   explicit HotwordUserSessionStateObserver(HotwordService* service)
       : service_(service) {}
 
   // Overridden from UserSessionStateObserver:
   void ActiveUserChanged(const user_manager::User* active_user) override {
     service_->ActiveUserChanged();
@@ skipping 14 matching lines @@
 
 HotwordService::HotwordService(Profile* profile)
     : profile_(profile),
       extension_registry_observer_(this),
       client_(NULL),
       error_message_(0),
       reinstall_pending_(false),
       training_(false),
       weak_factory_(this) {
   extension_registry_observer_.Add(extensions::ExtensionRegistry::Get(profile));
-  if (IsExperimentalHotwordingEnabled()) {
-    // Disable the old extension so it doesn't interfere with the new stuff.
-    DisableHotwordExtension(GetExtensionService(profile_));
-  } else {
-    if (!profile_->GetPrefs()->HasPrefPath(prefs::kHotwordSearchEnabled) &&
-        IsHotwordAllowed()) {
-      // If the preference has not been set the hotword extension should
-      // not be running. However, this should only be done if auto-install
-      // is enabled which is gated through the IsHotwordAllowed check.
-      DisableHotwordExtension(GetExtensionService(profile_));
-    }
+
+  // Disable the old extension so it doesn't interfere with the new stuff.
+  ExtensionService* extension_service = GetExtensionService(profile_);
+  if (extension_service) {
+    extension_service->DisableExtension(
+        extension_misc::kHotwordOldExtensionId,
+        extensions::Extension::DISABLE_USER_ACTION);
   }
+
   // This will be called during profile initialization which is a good time
   // to check the user's hotword state.
   RecordHotwordEnabledMetric(this, profile_);
 
   pref_registrar_.Init(profile_->GetPrefs());
   pref_registrar_.Add(
-      prefs::kHotwordSearchEnabled,
-      base::Bind(&HotwordService::OnHotwordSearchEnabledChanged,
-      base::Unretained(this)));
-  pref_registrar_.Add(
       prefs::kHotwordAlwaysOnSearchEnabled,
       base::Bind(&HotwordService::OnHotwordAlwaysOnSearchEnabledChanged,
       base::Unretained(this)));
 
   extensions::ExtensionSystem::Get(profile_)->ready().Post(
       FROM_HERE,
       base::Bind(base::IgnoreResult(
           &HotwordService::MaybeReinstallHotwordExtension),
                  weak_factory_.GetWeakPtr()));
 
   // Clear the old user pref because it became unusable.
   // TODO(rlp): Remove this code per crbug.com/358789.
   if (profile_->GetPrefs()->HasPrefPath(
           hotword_internal::kHotwordUnusablePrefName)) {
     profile_->GetPrefs()->ClearPref(hotword_internal::kHotwordUnusablePrefName);
   }
 
   SetAudioHistoryHandler(new HotwordAudioHistoryHandler(
       profile_, base::MessageLoop::current()->task_runner()));
 
   if (HotwordServiceFactory::IsAlwaysOnAvailable() &&
-      IsHotwordAllowed() &&
-      IsExperimentalHotwordingEnabled()) {
+      IsHotwordAllowed()) {
     // Show the hotword notification in 5 seconds if the experimental flag is
     // on, or in 30 minutes if not. We need to wait at least a few seconds
     // for the hotword extension to be installed.
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     if (command_line->HasSwitch(switches::kEnableExperimentalHotwordHardware)) {
       base::MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&HotwordService::ShowHotwordNotification,
                      weak_factory_.GetWeakPtr()),
           base::TimeDelta::FromSeconds(5));
@@ skipping 59 matching lines @@
   profile_->GetPrefs()->SetBoolean(
       prefs::kHotwordAlwaysOnNotificationSeen, true);
 }
 
 void HotwordService::OnExtensionUninstalled(
     content::BrowserContext* browser_context,
     const extensions::Extension* extension,
     extensions::UninstallReason reason) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
-  if ((extension->id() != extension_misc::kHotwordExtensionId &&
-       extension->id() != extension_misc::kHotwordSharedModuleId) ||
-       profile_ != Profile::FromBrowserContext(browser_context) ||
+  if (extension->id() != extension_misc::kHotwordSharedModuleId ||
+      profile_ != Profile::FromBrowserContext(browser_context) ||
       !GetExtensionService(profile_))
     return;
 
   // If the extension wasn't uninstalled due to language change, don't try to
   // reinstall it.
   if (!reinstall_pending_)
     return;
 
   InstallHotwordExtensionFromWebstore(kMaxInstallRetries);
   SetPreviousLanguagePref();
 }
 
 std::string HotwordService::ReinstalledExtensionId() {
-  if (IsExperimentalHotwordingEnabled())
-    return extension_misc::kHotwordSharedModuleId;
-
-  return extension_misc::kHotwordExtensionId;
+  return extension_misc::kHotwordSharedModuleId;
 }
 
 void HotwordService::InstalledFromWebstoreCallback(
     int num_tries,
     bool success,
     const std::string& error,
     extensions::webstore_install::Result result) {
   if (result != extensions::webstore_install::SUCCESS && num_tries) {
     // Try again on failure.
     content::BrowserThread::PostDelayedTask(
@@ skipping 14 matching lines @@
                  weak_factory_.GetWeakPtr(),
                  num_tries - 1));
   installer_->BeginInstall();
 }
 
 void HotwordService::OnExtensionInstalled(
     content::BrowserContext* browser_context,
     const extensions::Extension* extension,
     bool is_update) {
 
-  if ((extension->id() != extension_misc::kHotwordExtensionId &&
-       extension->id() != extension_misc::kHotwordSharedModuleId) ||
-       profile_ != Profile::FromBrowserContext(browser_context))
+  if (extension->id() != extension_misc::kHotwordSharedModuleId ||
+      profile_ != Profile::FromBrowserContext(browser_context))
     return;
 
   // If the previous locale pref has never been set, set it now since
   // the extension has been installed.
   if (!profile_->GetPrefs()->HasPrefPath(prefs::kHotwordPreviousLanguage))
     SetPreviousLanguagePref();
 
   // If MaybeReinstallHotwordExtension already triggered an uninstall, we
   // don't want to loop and trigger another uninstall-install cycle.
   // However, if we arrived here via an uninstall-triggered-install (and in
   // that case |reinstall_pending_| will be true) then we know install
   // has completed and we can reset |reinstall_pending_|.
   if (!reinstall_pending_)
     MaybeReinstallHotwordExtension();
   else
     reinstall_pending_ = false;
-
-  // Now that the extension is installed, if the user has not selected
-  // the preference on, make sure it is turned off.
-  //
-  // Disabling the extension automatically on install should only occur
-  // if the user is in the field trial for auto-install which is gated
-  // by the IsHotwordAllowed check. The check for IsHotwordAllowed() here
-  // can be removed once it's known that few people have manually
-  // installed extension.
-  if (IsHotwordAllowed() && !IsSometimesOnEnabled())
-    DisableHotwordExtension(GetExtensionService(profile_));
 }
 
 bool HotwordService::MaybeReinstallHotwordExtension() {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   ExtensionService* extension_service = GetExtensionService(profile_);
   if (!extension_service)
     return false;
 
   const extensions::Extension* extension = extension_service->GetExtensionById(
@@ skipping 62 matching lines @@
   extensions::ExtensionSystem* system =
       extensions::ExtensionSystem::Get(profile_);
   ExtensionService* service = system->extension_service();
   // Include disabled extensions (true parameter) since it may not be enabled
   // if the user opted out.
   const extensions::Extension* extension =
       service->GetExtensionById(ReinstalledExtensionId(), true);
   if (!extension)
     error_message_ = IDS_HOTWORD_GENERIC_ERROR_MESSAGE;
 
-  RecordExtensionAvailabilityMetrics(service, extension);
+  // TODO(amistry): Record availability of shared module in UMA.
   RecordLoggingMetrics(profile_);
 
   // Determine if NaCl is available.
   bool nacl_enabled = false;
   base::FilePath path;
   if (PathService::Get(chrome::FILE_NACL_PLUGIN, &path)) {
     content::WebPluginInfo info;
     PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(profile_).get();
     if (content::PluginService::GetInstance()->GetPluginInfoByPath(path, &info))
       nacl_enabled = plugin_prefs->IsPluginEnabled(info);
@@ skipping 46 matching lines @@
       profile_->GetPrefs()->GetBoolean(prefs::kHotwordAlwaysOnSearchEnabled) &&
       HotwordServiceFactory::IsAlwaysOnAvailable();
 }
 
 bool HotwordService::IsSometimesOnEnabled() {
   return profile_->GetPrefs()->HasPrefPath(prefs::kHotwordSearchEnabled) &&
       profile_->GetPrefs()->GetBoolean(prefs::kHotwordSearchEnabled) &&
       !HotwordServiceFactory::IsAlwaysOnAvailable();
 }
 
-void HotwordService::EnableHotwordExtension(
-    ExtensionService* extension_service) {
-  if (extension_service && !IsExperimentalHotwordingEnabled())
-    extension_service->EnableExtension(extension_misc::kHotwordExtensionId);
-}
-
-void HotwordService::DisableHotwordExtension(
-    ExtensionService* extension_service) {
-  if (extension_service) {
-    extension_service->DisableExtension(
-        extension_misc::kHotwordExtensionId,
-        extensions::Extension::DISABLE_USER_ACTION);
-  }
-}
-
 void HotwordService::LaunchHotwordAudioVerificationApp(
     const LaunchMode& launch_mode) {
   hotword_audio_verification_launch_mode_ = launch_mode;
 
   ExtensionService* extension_service = GetExtensionService(profile_);
   if (!extension_service)
     return;
   const extensions::Extension* extension = extension_service->GetExtensionById(
       extension_misc::kHotwordAudioVerificationAppId, true);
   if (!extension)
@@ skipping 73 matching lines @@
       profile_->GetPrefs()->SetBoolean(prefs::kHotwordSearchEnabled, false);
   } else if (IsAlwaysOnEnabled()) {
     if (profile_->GetPrefs()->HasPrefPath(
             prefs::kHotwordAlwaysOnSearchEnabled)) {
       profile_->GetPrefs()->SetBoolean(prefs::kHotwordAlwaysOnSearchEnabled,
                                        false);
     }
   }
 }
 
-void HotwordService::OnHotwordSearchEnabledChanged(
-    const std::string& pref_name) {
-  DCHECK_EQ(pref_name, std::string(prefs::kHotwordSearchEnabled));
-
-  ExtensionService* extension_service = GetExtensionService(profile_);
-  if (profile_->GetPrefs()->GetBoolean(prefs::kHotwordSearchEnabled))
-    EnableHotwordExtension(extension_service);
-  else
-    DisableHotwordExtension(extension_service);
-}
-
 void HotwordService::OnHotwordAlwaysOnSearchEnabledChanged(
     const std::string& pref_name) {
   // If the pref for always on has been changed in some way, that means that
   // the user is aware of always on (either from settings or another source)
   // so they don't need to be shown the notification.
   profile_->GetPrefs()->SetBoolean(prefs::kHotwordAlwaysOnNotificationSeen,
                                    true);
   pref_registrar_.Remove(prefs::kHotwordAlwaysOnSearchEnabled);
 }
 
@@ skipping 39 matching lines @@
   std::string previous_locale =
       profile_->GetPrefs()->GetString(prefs::kHotwordPreviousLanguage);
   std::string locale = GetCurrentLocale(profile_);
 
   // If it's a new locale, then the old extension should be uninstalled.
   return locale != previous_locale &&
       HotwordService::DoesHotwordSupportLanguage(profile_);
 }
 
 void HotwordService::ActiveUserChanged() {
-  // Do nothing for old hotwording.
-  if (!IsExperimentalHotwordingEnabled())
-    return;
-
   // Don't bother notifying the extension if hotwording is completely off.
   if (!IsSometimesOnEnabled() && !IsAlwaysOnEnabled() && !IsTraining())
     return;
 
   HotwordPrivateEventService* event_service =
       BrowserContextKeyedAPIFactory<HotwordPrivateEventService>::Get(profile_);
   // "enabled" isn't being changed, but piggy-back off the notification anyway.
   if (event_service)
     event_service->OnEnabledChanged(prefs::kHotwordSearchEnabled);
 }
 
 bool HotwordService::UserIsActive() {
 #if defined(OS_CHROMEOS)
   // Only support multiple profiles and profile switching in ChromeOS.
   if (user_manager::UserManager::IsInitialized()) {
     user_manager::User* user =
         user_manager::UserManager::Get()->GetActiveUser();
     if (user && user->is_profile_created())
       return profile_ == ProfileManager::GetActiveUserProfile();
   }
 #endif
   return true;
 }