Windows: When an app is updated and its name changes, recreate shortcuts.

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 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/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 603 matching lines @@
           return;
         loaded_.erase(i);
         break;
       }
       case chrome::NOTIFICATION_EXTENSION_INSTALLED: {
         const extensions::InstalledExtensionInfo* installed_info =
             content::Details<const extensions::InstalledExtensionInfo>(details)
                 .ptr();
         installed_ = installed_info->extension;
         was_update_ = installed_info->is_update;
+        old_name_ = installed_info->old_name;
         break;
       }
 
       default:
         DCHECK(false);
     }
   }
 
   void AddMockExternalProvider(
       extensions::ExternalProviderInterface* provider) {
@@ skipping 72 matching lines @@
     return PackAndInstallCRX(dir_path, pem_path, install_state,
                              Extension::NO_FLAGS);
   }
 
   const Extension* PackAndInstallCRX(const base::FilePath& dir_path,
                                      InstallState install_state) {
     return PackAndInstallCRX(dir_path, base::FilePath(), install_state,
                              Extension::NO_FLAGS);
   }
 
+  // Attempts to install an extension. Use INSTALL_FAILED if the installation
+  // is expected to fail.
+  // If |install_state| is INSTALL_UPDATED, and |expect_old_name| is non-empty,
+  // expects that the existing extension's title was |expect_old_name|.
+  const Extension* InstallCRX(const base::FilePath& path,
+                              InstallState install_state,
+                              int creation_flags,
+                              const std::string& expect_old_name) {
+    StartCRXInstall(path, creation_flags);
+    return WaitForCrxInstall(path, install_state, expect_old_name);
+  }
+
+  // Attempts to install an extension. Use INSTALL_FAILED if the installation
+  // is expected to fail.
   const Extension* InstallCRX(const base::FilePath& path,
                               InstallState install_state,
                               int creation_flags) {
-    StartCRXInstall(path, creation_flags);
-    return WaitForCrxInstall(path, install_state);
+    return InstallCRX(path, install_state, creation_flags, "");
   }
 
   // Attempts to install an extension. Use INSTALL_FAILED if the installation
   // is expected to fail.
   const Extension* InstallCRX(const base::FilePath& path,
                               InstallState install_state) {
     return InstallCRX(path, install_state, Extension::NO_FLAGS);
   }
 
   const Extension* InstallCRXFromWebStore(const base::FilePath& path,
@@ skipping 13 matching lines @@
     installer->InstallCrx(crx_path);
 
     return WaitForCrxInstall(crx_path, install_state);
   }
 
   // Wait for a CrxInstaller to finish. Used by InstallCRX. Set the
   // |install_state| to INSTALL_FAILED if the installation is expected to fail.
   // Returns an Extension pointer if the install succeeded, NULL otherwise.
   const Extension* WaitForCrxInstall(const base::FilePath& path,
                                      InstallState install_state) {
+    return WaitForCrxInstall(path, install_state, "");
+  }
+
+  // Wait for a CrxInstaller to finish. Used by InstallCRX. Set the
+  // |install_state| to INSTALL_FAILED if the installation is expected to fail.
+  // If |install_state| is INSTALL_UPDATED, and |expect_old_name| is non-empty,
+  // expects that the existing extension's title was |expect_old_name|.
+  // Returns an Extension pointer if the install succeeded, NULL otherwise.
+  const Extension* WaitForCrxInstall(const base::FilePath& path,
+                                     InstallState install_state,
+                                     const std::string& expect_old_name) {
     loop_.RunUntilIdle();
     std::vector<string16> errors = GetErrors();
     const Extension* extension = NULL;
     if (install_state != INSTALL_FAILED) {
       if (install_state == INSTALL_NEW)
         ++expected_extensions_count_;
 
       EXPECT_TRUE(installed_) << path.value();
       // If and only if INSTALL_UPDATED, it should have the is_update flag.
       EXPECT_EQ(install_state == INSTALL_UPDATED, was_update_)
           << path.value();
+      // If INSTALL_UPDATED, old_name_ should match the given string.
+      if (install_state == INSTALL_UPDATED && !expect_old_name.empty())
+        EXPECT_EQ(expect_old_name, old_name_);
       EXPECT_EQ(0u, errors.size()) << path.value();
 
       if (install_state == INSTALL_WITHOUT_LOAD) {
         EXPECT_EQ(0u, loaded_.size()) << path.value();
       } else {
         EXPECT_EQ(1u, loaded_.size()) << path.value();
         EXPECT_EQ(expected_extensions_count_, service_->extensions()->size()) <<
             path.value();
         extension = loaded_[0];
         EXPECT_TRUE(service_->GetExtensionById(extension->id(), false)) <<
             path.value();
       }
 
       for (std::vector<string16>::iterator err = errors.begin();
         err != errors.end(); ++err) {
         LOG(ERROR) << *err;
       }
     } else {
       EXPECT_FALSE(installed_) << path.value();
       EXPECT_EQ(0u, loaded_.size()) << path.value();
       EXPECT_EQ(1u, errors.size()) << path.value();
     }
 
     installed_ = NULL;
     was_update_ = false;
+    old_name_ = "";
     loaded_.clear();
     ExtensionErrorReporter::GetInstance()->ClearErrors();
     return extension;
   }
 
   enum UpdateState {
     FAILED_SILENTLY,
     FAILED,
     UPDATED,
     INSTALLED,
@@ skipping 280 matching lines @@
 #if defined(ENABLE_PLUGINS)
     PluginService::GetInstance()->Init();
 #endif
   }
 
  protected:
   extensions::ExtensionList loaded_;
   std::string unloaded_id_;
   const Extension* installed_;
   bool was_update_;
+  std::string old_name_;
   FeatureSwitch::ScopedOverride override_external_install_prompt_;
 
  private:
   content::NotificationRegistrar registrar_;
 };
 
 // Receives notifications from a PackExtensionJob, indicating either that
 // packing succeeded or that there was some error.
 class PackExtensionTestClient : public extensions::PackExtensionJob::Client {
  public:
@@ skipping 1408 matching lines @@
 TEST_F(ExtensionServiceTest, UpgradeSignedGood) {
   InitializeEmptyExtensionService();
 
   base::FilePath path = data_dir_.AppendASCII("good.crx");
   const Extension* extension = InstallCRX(path, INSTALL_NEW);
   std::string id = extension->id();
 
   ASSERT_EQ("1.0.0.0", extension->version()->GetString());
   ASSERT_EQ(0u, GetErrors().size());
 
-  // Upgrade to version 1.0.0.1
+  // Upgrade to version 1.0.0.1.
+  // Also test that the extension's old and new title are correctly retrieved.
   path = data_dir_.AppendASCII("good2.crx");
-  InstallCRX(path, INSTALL_UPDATED);
+  InstallCRX(path, INSTALL_UPDATED, Extension::NO_FLAGS, "My extension 1");
   extension = service_->GetExtensionById(id, false);
 
   ASSERT_EQ("1.0.0.1", extension->version()->GetString());
+  ASSERT_EQ("My updated extension 1", extension->name());
   ASSERT_EQ(0u, GetErrors().size());
 }
 
 // Test upgrading a signed extension with a bad signature.
 TEST_F(ExtensionServiceTest, UpgradeSignedBad) {
   InitializeEmptyExtensionService();
 
   base::FilePath path = data_dir_.AppendASCII("good.crx");
   InstallCRX(path, INSTALL_NEW);
 
@@ skipping 3426 matching lines @@
       new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
   AddMockExternalProvider(provider);
   provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
 
   service_->CheckForExternalUpdates();
   loop_.RunUntilIdle();
   EXPECT_TRUE(extensions::HasExternalInstallError(service_));
   EXPECT_FALSE(extensions::HasExternalInstallBubble(service_));
   EXPECT_FALSE(service_->IsExtensionEnabled(updates_from_webstore));
 }