Garbage Collect the Storage directory on next profile start after an extension uninstall.

chrome/browser/extensions/extension_prefs_unittest.cc

 // Copyright (c) 2012 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 "extension_prefs_unittest.h"
 
 #include "base/basictypes.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/prefs/public/pref_change_registrar.h"
@@ skipping 576 matching lines @@
       EXPECT_TRUE(prefs()->GetBrowserActionVisibility(*iter));
     }
   }
 
  private:
   ExtensionList extensions_;
 };
 TEST_F(ExtensionPrefsHidingBrowserActions, ForceHide) {}
 
 // Tests the idle install information functions.
-class ExtensionPrefsIdleInstallInfo : public ExtensionPrefsTest {
+class ExtensionPrefsDelayedInstallInfo : public ExtensionPrefsTest {
  public:
   // Sets idle install information for one test extension.
   void SetIdleInfo(std::string id, int num) {
     DictionaryValue manifest;
     manifest.SetString(extension_manifest_keys::kName, "test");
     manifest.SetString(extension_manifest_keys::kVersion,
                        "1." + base::IntToString(num));
     FilePath path = prefs_.extensions_dir().AppendASCII(base::IntToString(num));
     std::string errors;
     scoped_refptr<Extension> extension = Extension::Create(
         path, Extension::INTERNAL, manifest, Extension::NO_FLAGS, id, &errors);
     ASSERT_TRUE(extension) << errors;
     ASSERT_EQ(id, extension->id());
-    prefs()->SetIdleInstallInfo(extension.get(), Extension::ENABLED,
-                                syncer::StringOrdinal());
+    prefs()->SetDelayedInstallInfo(extension.get(), Extension::ENABLED,
+                                   syncer::StringOrdinal());
   }
 
   // Verifies that we get back expected idle install information previously
   // set by SetIdleInfo.
   void VerifyIdleInfo(std::string id, int num) {
-    scoped_ptr<ExtensionInfo> info(prefs()->GetIdleInstallInfo(id));
+    scoped_ptr<ExtensionInfo> info(prefs()->GetDelayedInstallInfo(id));
     ASSERT_TRUE(info);
     std::string version;
     ASSERT_TRUE(info->extension_manifest->GetString("version", &version));
     ASSERT_EQ("1." + base::IntToString(num), version);
     ASSERT_EQ(base::IntToString(num),
               info->extension_path.BaseName().MaybeAsASCII());
   }
 
   bool HasInfoForId(extensions::ExtensionPrefs::ExtensionsInfo* info,
                     const std::string& id) {
@@ skipping 11 matching lines @@
     id2_ = prefs_.AddExtensionAndReturnId("2");
     id3_ = prefs_.AddExtensionAndReturnId("3");
     id4_ = prefs_.AddExtensionAndReturnId("4");
 
     // Set info for two extensions, then remove it.
     SetIdleInfo(id1_, 1);
     SetIdleInfo(id2_, 2);
     VerifyIdleInfo(id1_, 1);
     VerifyIdleInfo(id2_, 2);
     scoped_ptr<extensions::ExtensionPrefs::ExtensionsInfo> info(
-        prefs()->GetAllIdleInstallInfo());
+        prefs()->GetAllDelayedInstallInfo());
     EXPECT_EQ(2u, info->size());
     EXPECT_TRUE(HasInfoForId(info.get(), id1_));
     EXPECT_TRUE(HasInfoForId(info.get(), id2_));
-    prefs()->RemoveIdleInstallInfo(id1_);
-    prefs()->RemoveIdleInstallInfo(id2_);
-    info = prefs()->GetAllIdleInstallInfo();
+    prefs()->RemoveDelayedInstallInfo(id1_);
+    prefs()->RemoveDelayedInstallInfo(id2_);
+    info = prefs()->GetAllDelayedInstallInfo();
     EXPECT_TRUE(info->empty());
 
     // Try getting/removing info for an id that used to have info set.
-    EXPECT_FALSE(prefs()->GetIdleInstallInfo(id1_));
-    EXPECT_FALSE(prefs()->RemoveIdleInstallInfo(id1_));
+    EXPECT_FALSE(prefs()->GetDelayedInstallInfo(id1_));
+    EXPECT_FALSE(prefs()->RemoveDelayedInstallInfo(id1_));
 
     // Try getting/removing info for an id that has not yet had any info set.
-    EXPECT_FALSE(prefs()->GetIdleInstallInfo(id3_));
-    EXPECT_FALSE(prefs()->RemoveIdleInstallInfo(id3_));
+    EXPECT_FALSE(prefs()->GetDelayedInstallInfo(id3_));
+    EXPECT_FALSE(prefs()->RemoveDelayedInstallInfo(id3_));
 
     // Set info for 4 extensions, then remove for one of them.
     SetIdleInfo(id1_, 1);
     SetIdleInfo(id2_, 2);
     SetIdleInfo(id3_, 3);
     SetIdleInfo(id4_, 4);
     VerifyIdleInfo(id1_, 1);
     VerifyIdleInfo(id2_, 2);
     VerifyIdleInfo(id3_, 3);
     VerifyIdleInfo(id4_, 4);
-    prefs()->RemoveIdleInstallInfo(id3_);
+    prefs()->RemoveDelayedInstallInfo(id3_);
   }
 
   virtual void Verify() {
     // Make sure the info for the 3 extensions we expect is present.
     scoped_ptr<extensions::ExtensionPrefs::ExtensionsInfo> info(
-        prefs()->GetAllIdleInstallInfo());
+        prefs()->GetAllDelayedInstallInfo());
     EXPECT_EQ(3u, info->size());
     EXPECT_TRUE(HasInfoForId(info.get(), id1_));
     EXPECT_TRUE(HasInfoForId(info.get(), id2_));
     EXPECT_TRUE(HasInfoForId(info.get(), id4_));
     VerifyIdleInfo(id1_, 1);
     VerifyIdleInfo(id2_, 2);
     VerifyIdleInfo(id4_, 4);
 
     // Make sure there isn't info the for the one extension id we removed.
-    EXPECT_FALSE(prefs()->GetIdleInstallInfo(id3_));
+    EXPECT_FALSE(prefs()->GetDelayedInstallInfo(id3_));
   }
 
  protected:
   Time now_;
   FilePath basedir_;
   std::string id1_;
   std::string id2_;
   std::string id3_;
   std::string id4_;
 };
-TEST_F(ExtensionPrefsIdleInstallInfo, IdleInstallInfo) {}
+TEST_F(ExtensionPrefsDelayedInstallInfo, DelayedInstallInfo) {}
 
 class ExtensionPrefsOnExtensionInstalled : public ExtensionPrefsTest {
  public:
   virtual void Initialize() {
     extension_ = prefs_.AddExtension("on_extension_installed");
     EXPECT_FALSE(prefs()->IsExtensionDisabled(extension_->id()));
     prefs()->OnExtensionInstalled(
         extension_.get(), Extension::DISABLED,
         syncer::StringOrdinal());
   }
@@ skipping 548 matching lines @@
 
  private:
   scoped_refptr<const Extension> extension_a_;
   scoped_refptr<const Extension> extension_b_;
   scoped_refptr<const Extension> extension_c_;
 };
 TEST_F(ExtensionPrefsBlacklistedExtensions,
        ExtensionPrefsBlacklistedExtensions) {}
 
 }  // namespace extensions