Get rid of the extension's "Current Version" file.

chrome/browser/extensions/extension_file_util_unittest.cc

 // Copyright (c) 2009 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_file_util.h"
 
 #include "base/file_util.h"
 #include "base/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 43 matching lines @@
   ASSERT_TRUE(extension_file_util::MoveDirSafely(src_path, dest_path));
   ASSERT_TRUE(file_util::DirectoryExists(dest_path));
 
   data_out.clear();
   ASSERT_TRUE(file_util::ReadFileToString(dest_path.AppendASCII("data"),
                                           &data_out));
   ASSERT_EQ(data, data_out);
   ASSERT_FALSE(file_util::PathExists(src_path));
 }
 
-TEST(ExtensionFileUtil, SetCurrentVersion) {
-  // Create an empty test directory.
-  ScopedTempDir temp;
-  ASSERT_TRUE(temp.CreateUniqueTempDir());
-
-  // Set its version.
-  std::string error;
-  std::string version = "1.0";
-  ASSERT_TRUE(extension_file_util::SetCurrentVersion(temp.path(), version,
-                                                     &error));
-
-  // Test the result.
-  std::string version_out;
-  ASSERT_TRUE(file_util::ReadFileToString(
-      temp.path().AppendASCII(extension_file_util::kCurrentVersionFileName),
-      &version_out));
-  ASSERT_EQ(version, version_out);
-
-  // Try again, overwriting the old value.
-  version = "2.0";
-  version_out.clear();
-  ASSERT_TRUE(extension_file_util::SetCurrentVersion(temp.path(), version,
-                                                     &error));
-  ASSERT_TRUE(file_util::ReadFileToString(
-      temp.path().AppendASCII(extension_file_util::kCurrentVersionFileName),
-      &version_out));
-  ASSERT_EQ(version, version_out);
-}
-
-TEST(ExtensionFileUtil, ReadCurrentVersion) {
-  // Read the version from a valid extension.
-  FilePath extension_path;
-  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extension_path));
-  extension_path = extension_path.AppendASCII("extensions")
-      .AppendASCII("good")
-      .AppendASCII("Extensions")
-      .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj");
-
-  std::string version;
-  ASSERT_TRUE(extension_file_util::ReadCurrentVersion(extension_path,
-                                                      &version));
-  ASSERT_EQ("1.0.0.0", version);
-
-  // Create an invalid extension and read its current version.
-  ScopedTempDir temp;
-  ASSERT_TRUE(temp.CreateUniqueTempDir());
-  ASSERT_FALSE(extension_file_util::ReadCurrentVersion(temp.path(), &version));
-}
-
 TEST(ExtensionFileUtil, CompareToInstalledVersion) {
   // Compare to an existing extension.
-  FilePath install_directory;
-  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_directory));
-  install_directory = install_directory.AppendASCII("extensions")
+  FilePath install_dir;
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_dir));
+  install_dir = install_dir.AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions");
 
-  std::string id = "behllobkkfkfnphdnhnkndlbkcpglgmj";
-  std::string version = "1.0.0.0";
-  std::string version_out;
+  const std::string kId = "behllobkkfkfnphdnhnkndlbkcpglgmj";
+  const std::string kCurrentVersion = "1.0.0.0";
 
-  ASSERT_EQ(Extension::UPGRADE, extension_file_util::CompareToInstalledVersion(
-    install_directory, id, "1.0.0.1", &version_out));
-  ASSERT_EQ(version, version_out);
+  FilePath version_dir;
 
-  version_out.clear();
+  ASSERT_EQ(Extension::UPGRADE,
+            extension_file_util::CompareToInstalledVersion(
+                install_dir, kId, kCurrentVersion, "1.0.0.1", &version_dir));
+
   ASSERT_EQ(Extension::REINSTALL,
             extension_file_util::CompareToInstalledVersion(
-                install_directory, id, "1.0.0.0", &version_out));
-  ASSERT_EQ(version, version_out);
+                install_dir, kId, kCurrentVersion, "1.0.0.0", &version_dir));
 
-  version_out.clear();
   ASSERT_EQ(Extension::REINSTALL,
             extension_file_util::CompareToInstalledVersion(
-                install_directory, id, "1.0.0", &version_out));
-  ASSERT_EQ(version, version_out);
+                install_dir, kId, kCurrentVersion, "1.0.0", &version_dir));
 
-  version_out.clear();
   ASSERT_EQ(Extension::DOWNGRADE,
             extension_file_util::CompareToInstalledVersion(
-                install_directory, id, "0.0.1.0", &version_out));
-  ASSERT_EQ(version, version_out);
+                install_dir, kId, kCurrentVersion, "0.0.1.0", &version_dir));
 
-  // Compare to an extension that is missing its Current Version file.
+  // Compare to an extension that is missing its manifest file.
   ScopedTempDir temp;
   ASSERT_TRUE(temp.CreateUniqueTempDir());
-  FilePath src = install_directory.AppendASCII(id).AppendASCII(version);
-  FilePath dest = temp.path().AppendASCII(id).AppendASCII(version);
+  FilePath src = install_dir.AppendASCII(kId).AppendASCII(kCurrentVersion);
+  FilePath dest = temp.path().AppendASCII(kId).AppendASCII(kCurrentVersion);
   ASSERT_TRUE(file_util::CreateDirectory(dest.DirName()));
   ASSERT_TRUE(file_util::CopyDirectory(src, dest, true));
+  ASSERT_TRUE(file_util::Delete(dest.AppendASCII("manifest.json"), false));
 
-  version_out.clear();
   ASSERT_EQ(Extension::NEW_INSTALL,
             extension_file_util::CompareToInstalledVersion(
-                temp.path(), id, "0.0.1.0", &version_out));
-  ASSERT_EQ("", version_out);
+                temp.path(), kId, kCurrentVersion, "1.0.0", &version_dir));
 
-  // Compare to a completely non-existent extension.
-  version_out.clear();
+  // Compare to a non-existent extension.
+  const std::string kMissingVersion = "";
+  const std::string kBadId = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
   ASSERT_EQ(Extension::NEW_INSTALL,
             extension_file_util::CompareToInstalledVersion(
-                temp.path(), "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", "0.0.1.0",
-                &version_out));
-  ASSERT_EQ("", version_out);
+                temp.path(), kBadId, kMissingVersion, "1.0.0", &version_dir));
 }
 
 // Creates minimal manifest, with or without default_locale section.
 bool CreateMinimalManifest(const std::string& locale,
                            const FilePath& manifest_path) {
   DictionaryValue manifest;
 
   manifest.SetString(keys::kVersion, "1.0.0.0");
   manifest.SetString(keys::kName, "my extension");
   if (!locale.empty()) {
@@ skipping 89 matching lines @@
   ASSERT_TRUE(file_util::CreateDirectory(src_path));
 
   std::string error;
   EXPECT_FALSE(extension_file_util::CheckForIllegalFilenames(temp.path(),
                                                              &error));
 }
 
 // TODO(aa): More tests as motivation allows. Maybe steal some from
 // ExtensionsService? Many of them could probably be tested here without the
 // MessageLoop shenanigans.