6 files changed, 226 insertions, 125 deletions

diff --git a/chrome/browser/dom_ui/app_launcher_handler.cc b/chrome/browser/dom_ui/app_launcher_handler.cc
index 64d128a..58ee56f 100644
--- a/chrome/browser/dom_ui/app_launcher_handler.cc
+++ b/chrome/browser/dom_ui/app_launcher_handler.cc
@@ -193,15 +193,10 @@ void AppLauncherHandler::FillAppDictionary(DictionaryValue* dictionary) {
   dictionary->SetBoolean("disableCreateAppShortcut", true);
 #endif
 
-  // We always show the launcher on Chrome OS. On Desktop Chrome, only show it
-  // if we've installed our default apps.
-#if defined(OS_CHROMEOS)
-  dictionary->SetBoolean("showLauncher", true);
-#else
   dictionary->SetBoolean(
       "showLauncher",
-      extensions_service_->default_apps()->GetDefaultAppsInstalled());
-#endif
+      extensions_service_->default_apps()->ShouldShowAppLauncher(
+          extensions_service_->GetAppIds()));
 }
 
 void AppLauncherHandler::HandleGetApps(const ListValue* args) {
@@ -217,7 +212,7 @@ void AppLauncherHandler::HandleGetApps(const ListValue* args) {
   // b) Conceptually, it doesn't really make sense to count a
   //    prefchange-triggered refresh as a promo 'view'.
   DefaultApps* default_apps = extensions_service_->default_apps();
-  if (default_apps->CheckShouldShowPromo(extensions_service_->GetAppIds())) {
+  if (default_apps->ShouldShowPromo(extensions_service_->GetAppIds())) {
     dictionary.SetBoolean("showPromo", true);
     default_apps->DidShowPromo();
     promo_active_ = true;
@@ -335,12 +330,11 @@ void AppLauncherHandler::HandleHideAppsPromo(const ListValue* args) {
   UMA_HISTOGRAM_ENUMERATION(extension_misc::kAppsPromoHistogram,
                             extension_misc::PROMO_CLOSE,
                             extension_misc::PROMO_BUCKET_BOUNDARY);
-  DefaultApps* default_apps = extensions_service_->default_apps();
-  const ExtensionIdSet* app_ids = default_apps->GetDefaultApps();
-  DCHECK(*app_ids == extensions_service_->GetAppIds());
 
-  for (ExtensionIdSet::const_iterator iter = app_ids->begin();
-       iter != app_ids->end(); ++iter) {
+  DefaultApps* default_apps = extensions_service_->default_apps();
+  const ExtensionIdSet& app_ids = default_apps->default_apps();
+  for (ExtensionIdSet::const_iterator iter = app_ids.begin();
+       iter != app_ids.end(); ++iter) {
     if (extensions_service_->GetExtensionById(*iter, true))
       extensions_service_->UninstallExtension(*iter, false);
   }
diff --git a/chrome/browser/extensions/default_apps.cc b/chrome/browser/extensions/default_apps.cc
index a9e305f..4afe325 100644
--- a/chrome/browser/extensions/default_apps.cc
+++ b/chrome/browser/extensions/default_apps.cc
@@ -18,55 +18,90 @@ void DefaultApps::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterIntegerPref(prefs::kAppsPromoCounter, 0);
 }
 
-DefaultApps::DefaultApps(PrefService* prefs)
-    : prefs_(prefs) {
-#if !defined(OS_CHROMEOS)
+DefaultApps::DefaultApps(PrefService* prefs,
+                         const std::string& application_locale)
+    : prefs_(prefs), application_locale_(application_locale) {
   // Poppit, Entanglement
   ids_.insert("mcbkbpnkkkipelfledbfocopglifcfmi");
   ids_.insert("aciahcmjmecflokailenpkdchphgkefd");
-#endif  // OS_CHROMEOS
 }
 
 DefaultApps::~DefaultApps() {}
 
-const ExtensionIdSet* DefaultApps::GetAppsToInstall() const {
-  if (GetDefaultAppsInstalled())
-    return NULL;
-  else
-    return &ids_;
+const ExtensionIdSet& DefaultApps::default_apps() const {
+  return ids_;
 }
 
-const ExtensionIdSet* DefaultApps::GetDefaultApps() const {
-  return &ids_;
+bool DefaultApps::DefaultAppSupported() {
+  // On Chrome OS the default apps are installed via a different mechanism.
+#if defined(OS_CHROMEOS)
+  return false;
+#else
+  return DefaultAppsSupportedForLanguage();
+#endif
 }
 
-void DefaultApps::DidInstallApp(const ExtensionIdSet& installed_ids) {
-  // If all the default apps have been installed, stop trying to install them.
-  // Note that we use std::includes here instead of == because apps might have
-  // been manually installed while the the default apps were installing and we
-  // wouldn't want to keep trying to install them in that case.
-  if (!GetDefaultAppsInstalled() &&
-      std::includes(installed_ids.begin(), installed_ids.end(),
-                    ids_.begin(), ids_.end())) {
+bool DefaultApps::DefaultAppsSupportedForLanguage() {
+  return application_locale_ == "en-US";
+}
+
+bool DefaultApps::ShouldInstallDefaultApps(
+    const ExtensionIdSet& installed_ids) {
+  if (!DefaultAppSupported())
+    return false;
+
+  if (GetDefaultAppsInstalled())
+    return false;
+
+  // If there are any non-default apps installed, we should never try to install
+  // the default apps again, even if the non-default apps are later removed.
+  if (NonDefaultAppIsInstalled(installed_ids)) {
     SetDefaultAppsInstalled(true);
+    return false;
   }
+
+  return true;
 }
 
-bool DefaultApps::CheckShouldShowPromo(const ExtensionIdSet& installed_ids) {
-#if defined(OS_CHROMEOS)
-  // Don't show the promo at all on Chrome OS.
-  return false;
+bool DefaultApps::ShouldShowAppLauncher(const ExtensionIdSet& installed_ids) {
+  // On Chrome OS the default apps are installed via a separate mechanism that
+  // is always enabled. Therefore we always show the launcher.
+#if defined(OS_CHROME)
+  return true;
+#else
+  // The app store only supports en-us at the moment, so we don't show the apps
+  // section by default for users in other locales. But we do show it if a user
+  // from a non-supported locale somehow installs an app (eg by navigating
+  // directly to the store).
+  if (!DefaultAppsSupportedForLanguage())
+    return !installed_ids.empty();
+
+  // For supported locales, we need to wait for all the default apps to be
+  // installed before showing the apps section. We also show it if any
+  // non-default app is installed (eg because the user installed the app in a
+  // previous version of Chrome).
+  if (GetDefaultAppsInstalled() || NonDefaultAppIsInstalled(installed_ids))
+    return true;
+  else
+    return false;
 #endif
+}
+
+bool DefaultApps::ShouldShowPromo(const ExtensionIdSet& installed_ids) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kForceAppsPromoVisible)) {
     return true;
   }
 
+  if (!DefaultAppSupported())
+    return false;
+
   if (GetDefaultAppsInstalled() && GetPromoCounter() < kAppsPromoCounterMax) {
     // If we have the exact set of default apps, show the promo. If we don't
     // have the exact set of default apps, this means that the user manually
-    // installed one. The promo doesn't make sense if it shows apps the user
-    // manually installed, so expire it immediately in that situation.
+    // installed or uninstalled one. The promo doesn't make sense if it shows
+    // apps the user manually installed, so expire it immediately in that
+    // situation.
     if (installed_ids == ids_)
       return true;
     else
@@ -76,6 +111,18 @@ bool DefaultApps::CheckShouldShowPromo(const ExtensionIdSet& installed_ids) {
   return false;
 }
 
+void DefaultApps::DidInstallApp(const ExtensionIdSet& installed_ids) {
+  // If all the default apps have been installed, stop trying to install them.
+  // Note that we use std::includes here instead of == because apps might have
+  // been manually installed while the the default apps were installing and we
+  // wouldn't want to keep trying to install them in that case.
+  if (!GetDefaultAppsInstalled() &&
+      std::includes(installed_ids.begin(), installed_ids.end(),
+                    ids_.begin(), ids_.end())) {
+    SetDefaultAppsInstalled(true);
+  }
+}
+
 void DefaultApps::DidShowPromo() {
   if (!GetDefaultAppsInstalled()) {
     NOTREACHED() << "Should not show promo until default apps are installed.";
@@ -99,6 +146,17 @@ void DefaultApps::DidShowPromo() {
   }
 }
 
+bool DefaultApps::NonDefaultAppIsInstalled(
+    const ExtensionIdSet& installed_ids) const {
+  for (ExtensionIdSet::const_iterator iter = installed_ids.begin();
+       iter != installed_ids.end(); ++iter) {
+    if (ids_.find(*iter) == ids_.end())
+      return true;
+  }
+
+  return false;
+}
+
 void DefaultApps::SetPromoHidden() {
   SetPromoCounter(kAppsPromoCounterMax);
 }
diff --git a/chrome/browser/extensions/default_apps.h b/chrome/browser/extensions/default_apps.h
index b03f6ec..a8b162c 100644
--- a/chrome/browser/extensions/default_apps.h
+++ b/chrome/browser/extensions/default_apps.h
@@ -13,21 +13,10 @@
 
 class PrefService;
 
-// Manages the installation of the set of default apps into Chrome, and the
-// promotion of those apps in the launcher.
-//
-// It implements the following rules:
-//
-// - Only install default apps once per-profile.
-// - Don't install default apps if any apps are already installed.
-// - Do not start showing the promo until all default apps have been installed.
-// - Do not show the promo if it has been hidden by the user.
-// - Do not show promo after one app has been manually installed or uninstalled.
-// - Do not show promo if the set of installed apps is different than the set of
-//   default apps.
-// - Only show promo a certain amount of times.
-//
-// The promo can also be forced on with --force-apps-promo-visible.
+// Encapsulates business logic for:
+// - Whether to install default apps on Chrome startup
+// - Whether to show the app launcher
+// - Whether to show the apps promo in the launcher
 class DefaultApps {
  public:
   // The maximum number of times to show the apps promo.
@@ -36,28 +25,28 @@ class DefaultApps {
   // Register our preferences.
   static void RegisterUserPrefs(PrefService* prefs);
 
-  explicit DefaultApps(PrefService* prefs);
+  explicit DefaultApps(PrefService* prefs,
+                       const std::string& application_locale);
   ~DefaultApps();
 
-  // Gets the list of default apps that should be installed. Can return NULL if
-  // no apps need to be installed.
-  const ExtensionIdSet* GetAppsToInstall() const;
+  // Gets the set of default apps.
+  const ExtensionIdSet& default_apps() const;
 
-  // Gets the list of default apps.
-  const ExtensionIdSet* GetDefaultApps() const;
+  // Returns true if the default apps should be installed.
+  bool ShouldInstallDefaultApps(const ExtensionIdSet& installed_ids);
 
-  // Returns true if the default apps have been installed. False otherwise.
-  bool GetDefaultAppsInstalled() const;
-
-  // Should be called after each app is installed. Once installed_ids contains
-  // all the default apps, GetAppsToInstall() will start returning NULL.
-  void DidInstallApp(const ExtensionIdSet& installed_ids);
+  // Returns true if the app launcher in the NTP should be shown.
+  bool ShouldShowAppLauncher(const ExtensionIdSet& installed_ids);
 
   // Returns true if the apps promo should be displayed in the launcher.
   //
   // NOTE: If the default apps have been installed, but |installed_ids| is
   // different than GetDefaultApps(), this will permanently expire the promo.
-  bool CheckShouldShowPromo(const ExtensionIdSet& installed_ids);
+  bool ShouldShowPromo(const ExtensionIdSet& installed_ids);
+
+  // Should be called after each app is installed. Once installed_ids contains
+  // all the default apps, GetAppsToInstall() will start returning NULL.
+  void DidInstallApp(const ExtensionIdSet& installed_ids);
 
   // Should be called after each time the promo is installed.
   void DidShowPromo();
@@ -66,12 +55,19 @@ class DefaultApps {
   void SetPromoHidden();
 
  private:
-  FRIEND_TEST_ALL_PREFIXES(ExtensionDefaultApps, Basics);
+  FRIEND_TEST_ALL_PREFIXES(ExtensionDefaultApps, HappyPath);
+  FRIEND_TEST_ALL_PREFIXES(ExtensionDefaultApps, UnsupportedLocale);
   FRIEND_TEST_ALL_PREFIXES(ExtensionDefaultApps, HidePromo);
   FRIEND_TEST_ALL_PREFIXES(ExtensionDefaultApps, InstallingAnAppHidesPromo);
   FRIEND_TEST_ALL_PREFIXES(ExtensionDefaultApps,
                            ManualAppInstalledWhileInstallingDefaultApps);
 
+  bool DefaultAppSupported();
+  bool DefaultAppsSupportedForLanguage();
+
+  bool NonDefaultAppIsInstalled(const ExtensionIdSet& installed_ids) const;
+
+  bool GetDefaultAppsInstalled() const;
   void SetDefaultAppsInstalled(bool val);
 
   int GetPromoCounter() const;
@@ -80,6 +76,9 @@ class DefaultApps {
   // Our permanent state is stored in this PrefService instance.
   PrefService* prefs_;
 
+  // The locale the browser is currently in.
+  std::string application_locale_;
+
   // The set of default extensions. Initialized to a static list in the
   // constructor.
   ExtensionIdSet ids_;
diff --git a/chrome/browser/extensions/default_apps_unittest.cc b/chrome/browser/extensions/default_apps_unittest.cc
index 4fa9bc2..fd87d58 100644
--- a/chrome/browser/extensions/default_apps_unittest.cc
+++ b/chrome/browser/extensions/default_apps_unittest.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "base/logging.h"
 #include "chrome/browser/extensions/default_apps.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/test/testing_pref_service.h"
@@ -10,93 +11,141 @@
 // TODO(dpolukhin): On Chrome OS all apps are installed via external extensions,
 // and the web store promo is never shown.
 #if !defined(OS_CHROMEOS)
-TEST(ExtensionDefaultApps, Basics) {
+TEST(ExtensionDefaultApps, HappyPath) {
   TestingPrefService pref_service;
   DefaultApps::RegisterUserPrefs(&pref_service);
-  DefaultApps default_apps(&pref_service);
+  DefaultApps default_apps(&pref_service, "en-US");
 
-  ExtensionIdSet default_app_ids = *default_apps.GetAppsToInstall();
+  const ExtensionIdSet& default_app_ids = default_apps.default_apps();
   ASSERT_GT(default_app_ids.size(), 0u);
   EXPECT_FALSE(default_apps.GetDefaultAppsInstalled());
   EXPECT_EQ(0, default_apps.GetPromoCounter());
-  EXPECT_EQ(default_app_ids, *default_apps.GetDefaultApps());
 
-  // The promo should not be shown until the default apps have been installed.
+  // If no apps are installed, the default apps should be installed.
   ExtensionIdSet installed_app_ids;
-  EXPECT_FALSE(default_apps.CheckShouldShowPromo(installed_app_ids));
+  EXPECT_TRUE(default_apps.ShouldInstallDefaultApps(installed_app_ids));
+
+  // The launcher should not be shown until the default apps have been
+  // installed.
+  EXPECT_FALSE(default_apps.ShouldShowAppLauncher(installed_app_ids));
+
+  // The promo should not be shown until the default apps have been installed.
+  EXPECT_FALSE(default_apps.ShouldShowPromo(installed_app_ids));
 
   // Simulate installing the apps one by one and notifying default_apps after
   // each intallation. Nothing should change until we have installed all the
   // default apps.
-  ExtensionIdSet extension_id_sets[] = {
-    default_app_ids,
-    default_app_ids,
-    default_app_ids
-  };
-  extension_id_sets[0].clear();
-  extension_id_sets[1].erase(extension_id_sets[1].begin());
-  extension_id_sets[2].erase(extension_id_sets[2].begin(),
-                             ++extension_id_sets[2].begin());
-  for (size_t i = 0; i < arraysize(extension_id_sets); ++i) {
-    default_apps.DidInstallApp(extension_id_sets[i]);
-    EXPECT_TRUE(default_app_ids == *default_apps.GetAppsToInstall());
+  for (size_t i = 0; i < default_app_ids.size() - 1; ++i) {
+    ExtensionIdSet::const_iterator iter = default_app_ids.begin();
+    for (size_t j = 0; j <= i; ++j)
+      ++iter;
+    installed_app_ids.insert(*iter);
+    default_apps.DidInstallApp(installed_app_ids);
     EXPECT_FALSE(default_apps.GetDefaultAppsInstalled());
-    EXPECT_FALSE(default_apps.CheckShouldShowPromo(extension_id_sets[i]));
+    EXPECT_TRUE(default_apps.ShouldInstallDefaultApps(installed_app_ids));
+    EXPECT_FALSE(default_apps.ShouldShowAppLauncher(installed_app_ids));
+    EXPECT_FALSE(default_apps.ShouldShowPromo(installed_app_ids));
   }
 
   // Simulate all the default apps being installed. Now we should stop getting
   // default apps to install.
-  default_apps.DidInstallApp(default_app_ids);
-  EXPECT_EQ(NULL, default_apps.GetAppsToInstall());
+  installed_app_ids = default_app_ids;
+  default_apps.DidInstallApp(installed_app_ids);
   EXPECT_TRUE(default_apps.GetDefaultAppsInstalled());
+  EXPECT_FALSE(default_apps.ShouldInstallDefaultApps(installed_app_ids));
 
-  // And the promo should become available.
-  EXPECT_TRUE(default_apps.CheckShouldShowPromo(default_app_ids));
+  // And the promo and launcher should become available.
+  EXPECT_TRUE(default_apps.ShouldShowAppLauncher(installed_app_ids));
+  EXPECT_TRUE(default_apps.ShouldShowPromo(installed_app_ids));
 
   // The promo should be available up to the max allowed times, then stop.
   for (int i = 0; i < DefaultApps::kAppsPromoCounterMax; ++i) {
-    EXPECT_TRUE(default_apps.CheckShouldShowPromo(default_app_ids));
+    EXPECT_TRUE(default_apps.ShouldShowPromo(installed_app_ids));
     default_apps.DidShowPromo();
     EXPECT_EQ(i + 1, default_apps.GetPromoCounter());
   }
-  EXPECT_FALSE(default_apps.CheckShouldShowPromo(default_app_ids));
+  EXPECT_FALSE(default_apps.ShouldShowPromo(installed_app_ids));
   EXPECT_EQ(DefaultApps::kAppsPromoCounterMax, default_apps.GetPromoCounter());
+
+  // Even if all the apps are subsequently removed, the apps section should
+  // remain.
+  installed_app_ids.clear();
+  EXPECT_FALSE(default_apps.ShouldInstallDefaultApps(installed_app_ids));
+  EXPECT_TRUE(default_apps.ShouldShowAppLauncher(installed_app_ids));
+  EXPECT_FALSE(default_apps.ShouldShowPromo(installed_app_ids));
+}
+
+TEST(ExtensionDefaultApps, UnsupportedLocale) {
+  TestingPrefService pref_service;
+  DefaultApps::RegisterUserPrefs(&pref_service);
+  DefaultApps default_apps(&pref_service, "fr");
+
+  const ExtensionIdSet& default_app_ids = default_apps.default_apps();
+  EXPECT_GT(default_app_ids.size(), 0u);
+
+  // Since the store only supports en-US at the moment, we don't install default
+  // apps or promote the store.
+  ExtensionIdSet installed_ids;
+  EXPECT_FALSE(default_apps.ShouldInstallDefaultApps(installed_ids));
+  EXPECT_FALSE(default_apps.ShouldShowAppLauncher(installed_ids));
+  EXPECT_FALSE(default_apps.ShouldShowPromo(installed_ids));
+
+  // If the user installs an app manually, then we show the apps section, but
+  // no promotion or default apps.
+  installed_ids.insert(*(default_app_ids.begin()));
+  EXPECT_FALSE(default_apps.ShouldInstallDefaultApps(installed_ids));
+  EXPECT_TRUE(default_apps.ShouldShowAppLauncher(installed_ids));
+  EXPECT_FALSE(default_apps.ShouldShowPromo(installed_ids));
+
+  // Even if the user installs the exact set of default apps, we don't show the
+  // promo.
+  installed_ids = default_app_ids;
+  EXPECT_FALSE(default_apps.ShouldInstallDefaultApps(installed_ids));
+  EXPECT_TRUE(default_apps.ShouldShowAppLauncher(installed_ids));
+  EXPECT_FALSE(default_apps.ShouldShowPromo(installed_ids));
+
+  // If the user uninstalls the apps again, we go back to not showing the
+  // apps section.
+  installed_ids.clear();
+  EXPECT_FALSE(default_apps.ShouldInstallDefaultApps(installed_ids));
+  EXPECT_FALSE(default_apps.ShouldShowAppLauncher(installed_ids));
+  EXPECT_FALSE(default_apps.ShouldShowPromo(installed_ids));
 }
 
 TEST(ExtensionDefaultApps, HidePromo) {
   TestingPrefService pref_service;
   DefaultApps::RegisterUserPrefs(&pref_service);
-  DefaultApps default_apps(&pref_service);
+  DefaultApps default_apps(&pref_service, "en-US");
 
-  ExtensionIdSet default_app_ids = *default_apps.GetAppsToInstall();
+  const ExtensionIdSet& default_app_ids = default_apps.default_apps();
   default_apps.DidInstallApp(default_app_ids);
 
-  EXPECT_TRUE(default_apps.CheckShouldShowPromo(default_app_ids));
+  EXPECT_TRUE(default_apps.ShouldShowPromo(default_app_ids));
   default_apps.DidShowPromo();
   EXPECT_EQ(1, default_apps.GetPromoCounter());
 
   default_apps.SetPromoHidden();
-  EXPECT_FALSE(default_apps.CheckShouldShowPromo(default_app_ids));
+  EXPECT_FALSE(default_apps.ShouldShowPromo(default_app_ids));
   EXPECT_EQ(DefaultApps::kAppsPromoCounterMax, default_apps.GetPromoCounter());
 }
 
 TEST(ExtensionDefaultApps, InstallingAnAppHidesPromo) {
   TestingPrefService pref_service;
   DefaultApps::RegisterUserPrefs(&pref_service);
-  DefaultApps default_apps(&pref_service);
+  DefaultApps default_apps(&pref_service, "en-US");
 
-  ExtensionIdSet default_app_ids = *default_apps.GetAppsToInstall();
+  const ExtensionIdSet& default_app_ids = default_apps.default_apps();
   ExtensionIdSet installed_app_ids = default_app_ids;
   default_apps.DidInstallApp(installed_app_ids);
 
-  EXPECT_TRUE(default_apps.CheckShouldShowPromo(installed_app_ids));
+  EXPECT_TRUE(default_apps.ShouldShowPromo(installed_app_ids));
   default_apps.DidShowPromo();
   EXPECT_EQ(1, default_apps.GetPromoCounter());
 
   // Now simulate a new extension being installed. This should cause the promo
   // to be hidden.
   installed_app_ids.insert("foo");
-  EXPECT_FALSE(default_apps.CheckShouldShowPromo(installed_app_ids));
+  EXPECT_FALSE(default_apps.ShouldShowPromo(installed_app_ids));
   EXPECT_EQ(DefaultApps::kAppsPromoCounterMax, default_apps.GetPromoCounter());
 }
 
@@ -111,27 +160,31 @@ TEST(ExtensionDefaultApps, ManualAppInstalledWhileInstallingDefaultApps) {
   // the default ones.
   TestingPrefService pref_service;
   DefaultApps::RegisterUserPrefs(&pref_service);
-  DefaultApps default_apps(&pref_service);
+  DefaultApps default_apps(&pref_service, "en-US");
 
   // Simulate an app getting installed before the complete set of default apps.
-  // This shouldn't affect us installing default apps. We should keep trying.
+  // This should stop the default apps from trying to be installed. The launcher
+  // should also immediately show up.
   ExtensionIdSet installed_ids;
   installed_ids.insert("foo");
-  default_apps.DidInstallApp(installed_ids);
-  EXPECT_FALSE(default_apps.GetDefaultAppsInstalled());
-  EXPECT_TRUE(default_apps.GetAppsToInstall());
-
-  // Now add all the default apps in addition to the extra app. We should stop
-  // trying to install default apps.
-  installed_ids = *default_apps.GetAppsToInstall();
-  installed_ids.insert("foo");
-  default_apps.DidInstallApp(installed_ids);
+  EXPECT_FALSE(default_apps.ShouldInstallDefaultApps(installed_ids));
   EXPECT_TRUE(default_apps.GetDefaultAppsInstalled());
-  EXPECT_FALSE(default_apps.GetAppsToInstall());
+  EXPECT_TRUE(default_apps.ShouldShowAppLauncher(installed_ids));
 
   // The promo shouldn't turn on though, because it would look weird with the
   // user's extra, manually installed extensions.
-  EXPECT_FALSE(default_apps.CheckShouldShowPromo(installed_ids));
+  EXPECT_FALSE(default_apps.ShouldShowPromo(installed_ids));
   EXPECT_EQ(DefaultApps::kAppsPromoCounterMax, default_apps.GetPromoCounter());
+
+  // Going back to a subset of the default apps shouldn't allow the default app
+  // install to continue.
+  installed_ids.clear();
+  EXPECT_FALSE(default_apps.ShouldInstallDefaultApps(installed_ids));
+  EXPECT_TRUE(default_apps.GetDefaultAppsInstalled());
+  EXPECT_TRUE(default_apps.ShouldShowAppLauncher(installed_ids));
+  EXPECT_FALSE(default_apps.ShouldShowPromo(installed_ids));
+
+  // Going to the exact set of default apps shouldn't show the promo.
+  EXPECT_FALSE(default_apps.ShouldShowPromo(default_apps.default_apps()));
 }
 #endif  // OS_CHROMEOS
diff --git a/chrome/browser/extensions/extension_service.cc b/chrome/browser/extensions/extension_service.cc
index 843584c26..8140d2b 100644
--- a/chrome/browser/extensions/extension_service.cc
+++ b/chrome/browser/extensions/extension_service.cc
@@ -553,7 +553,8 @@ ExtensionService::ExtensionService(Profile* profile,
       show_extensions_prompts_(true),
       ready_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(toolbar_model_(this)),
-      default_apps_(profile->GetPrefs()),
+      default_apps_(profile->GetPrefs(),
+                    g_browser_process->GetApplicationLocale()),
       event_routers_initialized_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
diff --git a/chrome/browser/profiles/profile_impl.cc b/chrome/browser/profiles/profile_impl.cc
index a632ac5..34a50fc 100644
--- a/chrome/browser/profiles/profile_impl.cc
+++ b/chrome/browser/profiles/profile_impl.cc
@@ -409,20 +409,16 @@ void ProfileImpl::RegisterComponentExtensions() {
 }
 
 void ProfileImpl::InstallDefaultApps() {
-  // The web store only supports en-US at the moment, so we don't install
-  // default apps in other locales.
-  if (g_browser_process->GetApplicationLocale() != "en-US")
-    return;
+  ExtensionService* extension_service = GetExtensionService();
+  DefaultApps* default_apps = extension_service->default_apps();
 
-  ExtensionService* extensions_service = GetExtensionService();
-  const ExtensionIdSet* app_ids =
-      extensions_service->default_apps()->GetAppsToInstall();
-  if (!app_ids)
+  if (!default_apps->ShouldInstallDefaultApps(extension_service->GetAppIds()))
     return;
 
-  for (ExtensionIdSet::const_iterator iter = app_ids->begin();
-       iter != app_ids->end(); ++iter) {
-    extensions_service->AddPendingExtensionFromDefaultAppList(*iter);
+  const ExtensionIdSet& app_ids = default_apps->default_apps();
+  for (ExtensionIdSet::const_iterator iter = app_ids.begin();
+       iter != app_ids.end(); ++iter) {
+    extension_service->AddPendingExtensionFromDefaultAppList(*iter);
   }
 }