Reinstall the hotword shared module on a lanuage change.

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 "base/command_line.h"
 #include "base/i18n/case_conversion.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
@@ skipping 243 matching lines @@
     HotwordServiceFactory::GetInstance()->UpdateMicrophoneState();
   }
 }
 
 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 ||
-      profile_ != Profile::FromBrowserContext(browser_context) ||
+  if ((extension->id() != extension_misc::kHotwordExtensionId &&
+       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();
   SetPreviousLanguagePref();
 }
 
 void HotwordService::InstallHotwordExtensionFromWebstore() {
+  std::string extension_id;
+  if (IsExperimentalHotwordingEnabled())
+    extension_id = extension_misc::kHotwordSharedModuleId;
+  else
+    extension_id = extension_misc::kHotwordExtensionId;

[rpetterson, 2014/10/20 06:31:21]

You're repeating this code a lot in here. Helper function? Then you could just
replace extension_id with the call to the helper function.

[Anand Mistry (off Chromium), 2014/10/20 10:04:49]

Done.

   installer_ = new extensions::WebstoreStartupInstaller(
-      extension_misc::kHotwordExtensionId,
+      extension_id,
       profile_,
       false,
       extensions::WebstoreStandaloneInstaller::Callback());
   installer_->BeginInstall();
 }
 
 void HotwordService::OnExtensionInstalled(
     content::BrowserContext* browser_context,
     const extensions::Extension* extension,
     bool is_update) {
 
-  if (extension->id() != extension_misc::kHotwordExtensionId ||
-      profile_ != Profile::FromBrowserContext(browser_context))
+  if ((extension->id() != extension_misc::kHotwordExtensionId &&
+       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
@@ skipping 18 matching lines @@
   }
 }
 
 bool HotwordService::MaybeReinstallHotwordExtension() {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   ExtensionService* extension_service = GetExtensionService(profile_);
   if (!extension_service)
     return false;
 
+  std::string extension_id;
+  if (IsExperimentalHotwordingEnabled())
+    extension_id = extension_misc::kHotwordSharedModuleId;
+  else
+    extension_id = extension_misc::kHotwordExtensionId;
   const extensions::Extension* extension = extension_service->GetExtensionById(
-      extension_misc::kHotwordExtensionId, true);
+      extension_id, true);
   if (!extension)
     return false;
 
   // If the extension is currently pending, return and we'll check again
   // after the install is finished.
   extensions::PendingExtensionManager* pending_manager =
       extension_service->pending_extension_manager();
   if (pending_manager->IsIdPending(extension->id()))
     return false;
 
@@ skipping 10 matching lines @@
   // Ensure the call to OnExtensionUninstalled was triggered by a language
   // change so it's okay to reinstall.
   reinstall_pending_ = true;
 
   return UninstallHotwordExtension(extension_service);
 }
 
 bool HotwordService::UninstallHotwordExtension(
     ExtensionService* extension_service) {
   base::string16 error;
+  std::string extension_id;
+  if (IsExperimentalHotwordingEnabled())
+    extension_id = extension_misc::kHotwordSharedModuleId;
+  else
+    extension_id = extension_misc::kHotwordExtensionId;
   if (!extension_service->UninstallExtension(
-          extension_misc::kHotwordExtensionId,
+          extension_id,
           extensions::UNINSTALL_REASON_INTERNAL_MANAGEMENT,
           base::Bind(&base::DoNothing),
           &error)) {
     LOG(WARNING) << "Cannot uninstall extension with id "
-                 << extension_misc::kHotwordExtensionId
+                 << extension_id
                  << ": " << error;
     reinstall_pending_ = false;
     return false;
   }
   return true;
 }
 
 bool HotwordService::IsServiceAvailable() {
   error_message_ = 0;
 
   // Determine if the extension is available.
   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.
   std::string extensionId;
   if (IsExperimentalHotwordingEnabled()) {
-    // TODO(amistry): Handle reloading on language change as the old extension
-    // does.
     extensionId = extension_misc::kHotwordSharedModuleId;
   } else {
     extensionId = extension_misc::kHotwordExtensionId;
   }
   const extensions::Extension* extension =
       service->GetExtensionById(extensionId, true);
   if (!extension)
     error_message_ = IDS_HOTWORD_GENERIC_ERROR_MESSAGE;
 
   RecordExtensionAvailabilityMetrics(service, extension);
@@ skipping 130 matching lines @@
     return false;
 
   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_);
 }