Decouple killbit testing from external extension providers

chrome/browser/extensions/extensions_service_unittest.cc

 // Copyright (c) 2010 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/extensions_service_unittest.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 122 matching lines @@
                             const std::string& version,
                             const FilePath& path) {
     extension_map_[id] = std::make_pair(version, path);
   }
 
   void RemoveExtension(const std::string& id) {
     extension_map_.erase(id);
   }
 
   // ExternalExtensionProvider implementation:
-  virtual void VisitRegisteredExtension(
-      Visitor* visitor, const std::set<std::string>& ids_to_ignore) const {
+  virtual void VisitRegisteredExtension(Visitor* visitor) const {
     visit_count_++;
     for (DataMap::const_iterator i = extension_map_.begin();
          i != extension_map_.end(); ++i) {
-      if (ids_to_ignore.find(i->first) != ids_to_ignore.end())
-        continue;
       scoped_ptr<Version> version;
       version.reset(Version::GetVersionFromString(i->second.first));
 
       visitor->OnExternalExtensionFileFound(
           i->first, version.get(), i->second.second, location_);
     }
   }
 
   virtual bool HasExtension(const std::string& id) const {
     return extension_map_.find(id) != extension_map_.end();
@@ skipping 31 matching lines @@
   mutable int visit_count_;
 
   DISALLOW_COPY_AND_ASSIGN(MockExtensionProvider);
 };
 
 class MockProviderVisitor : public ExternalExtensionProvider::Visitor {
  public:
   MockProviderVisitor() : ids_found_(0) {
   }
 
-  int Visit(const std::string& json_data,
-            const std::set<std::string>& ignore_list) {
+  int Visit(const std::string& json_data) {
     // Give the test json file to the provider for parsing.
     provider_.reset(new ExternalPrefExtensionProvider());
     provider_->SetPreferencesForTesting(json_data);
 
     // We also parse the file into a dictionary to compare what we get back
     // from the provider.
     JSONStringValueSerializer serializer(json_data);
     Value* json_value = serializer.Deserialize(NULL, NULL);
 
     if (!json_value || !json_value->IsType(Value::TYPE_DICTIONARY)) {
       NOTREACHED() << "Unable to deserialize json data";
       return -1;
     } else {
       DictionaryValue* external_extensions =
           static_cast<DictionaryValue*>(json_value);
       prefs_.reset(external_extensions);
     }
 
     // Reset our counter.
     ids_found_ = 0;
-    // Ask the provider to look up all extensions (and return the ones
-    // found (that are not on the ignore list).
-    provider_->VisitRegisteredExtension(this, ignore_list);
+    // Ask the provider to look up all extensions and return them.
+    provider_->VisitRegisteredExtension(this);
 
     return ids_found_;
   }
 
   virtual void OnExternalExtensionFileFound(const std::string& id,
                                             const Version* version,
                                             const FilePath& path,
                                             Extension::Location unused) {
     ++ids_found_;
     DictionaryValue* pref;
@@ skipping 819 matching lines @@
   // class of validation that we do to the directory structure of the extension.
   // We did not used to handle this correctly for installation.
   path = extensions_path.AppendASCII("bad_underscore.crx");
   InstallExtension(path, false);
   ValidatePrefKeyCount(pref_count);
 
   // TODO(erikkay): add more tests for many of the failure cases.
   // TODO(erikkay): add tests for upgrade cases.
 }
 
+// Test the handling of killed extensions.
+TEST_F(ExtensionsServiceTest, KilledExtensions) {
+  InitializeEmptyExtensionsService();
+
+  FilePath extensions_path;
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
+  extensions_path = extensions_path.AppendASCII("extensions");
+  FilePath path = extensions_path.AppendASCII("good.crx");
+  set_extensions_enabled(true);
+
+  // Install an external extension.
+  service_->OnExternalExtensionFileFound(good_crx, "1.0.0.0",
+                                         path, Extension::EXTERNAL_PREF);
+  loop_.RunAllPending();
+  ASSERT_TRUE(NULL != service_->GetExtensionById(good_crx, false));
+
+  // Uninstall it and check that its killbit gets set.
+  service_->UninstallExtension(good_crx, false);
+  loop_.RunAllPending();
+  ValidateIntegerPref(good_crx, "location", Extension::KILLBIT);
+
+  // Try to re-install it externally. This should fail because of the killbit.
+  service_->OnExternalExtensionFileFound(good_crx, "1.0.0.0",
+                                         path, Extension::EXTERNAL_PREF);
+  loop_.RunAllPending();
+  ASSERT_TRUE(NULL == service_->GetExtensionById(good_crx, false));
+  ValidateIntegerPref(good_crx, "location", Extension::KILLBIT);
+
+  // Repeat the same thing with a newer version of the extension.
+  path = extensions_path.AppendASCII("good2.crx");
+  service_->OnExternalExtensionFileFound(good_crx, "1.0.0.1",
+                                         path, Extension::EXTERNAL_PREF);
+  loop_.RunAllPending();
+  ASSERT_TRUE(NULL == service_->GetExtensionById(good_crx, false));
+  ValidateIntegerPref(good_crx, "location", Extension::KILLBIT);
+
+  // Try adding the same extension from an external update URL.
+  service_->AddPendingExtensionFromExternalUpdateUrl(
+      good_crx,
+      GURL("http:://fake.update/url"),
+      Extension::EXTERNAL_PREF_DOWNLOAD);
+  const PendingExtensionMap& pending_extensions =
+      service_->pending_extensions();
+  ASSERT_TRUE(pending_extensions.find(good_crx) == pending_extensions.end());
+}
+
 // Install a user script (they get converted automatically to an extension)
 TEST_F(ExtensionsServiceTest, InstallUserScript) {
   // The details of script conversion are tested elsewhere, this just tests
   // integration with ExtensionsService.
   InitializeEmptyExtensionsService();
 
   FilePath path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path));
   path = path.AppendASCII("extensions")
              .AppendASCII("user_script_basic.user.js");
@@ skipping 1789 matching lines @@
       "  \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\": {"
       "    \"external_crx\": \"RandomExtension2.crx\","
       "    \"external_version\": \"2.0\""
       "  },"
       "  \"cccccccccccccccccccccccccccccccc\": {"
       "    \"external_update_url\": \"http:\\\\foo.com/update\""
       "  }"
       "}";
 
   MockProviderVisitor visitor;
-  std::set<std::string> ignore_list;
-  EXPECT_EQ(3, visitor.Visit(json_data, ignore_list));
-  ignore_list.insert("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
-  EXPECT_EQ(2, visitor.Visit(json_data, ignore_list));
-  ignore_list.insert("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
-  EXPECT_EQ(1, visitor.Visit(json_data, ignore_list));
-  ignore_list.insert("cccccccccccccccccccccccccccccccc");
-  EXPECT_EQ(0, visitor.Visit(json_data, ignore_list));
 
   // Simulate an external_extensions.json file that contains seven invalid
   // extensions:
   // - One that is missing the 'external_crx' key.
   // - One that is missing the 'external_version' key.
   // - One that is specifying .. in the path.
   // - One that specifies both a file and update URL.
   // - One that specifies no file or update URL.
   // - One that has an update URL that is not well formed.
   // - One that contains a malformed version.
@@ skipping 23 matching lines @@
       "  },"
       "  \"gggggggggggggggggggggggggggggggg\": {"
       "    \"external_crx\": \"RandomExtension3.crx\","
       "    \"external_version\": \"This is not a valid version!\""
       "  },"
       "  \"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\": {"
       "    \"external_crx\": \"RandomValidExtension.crx\","
       "    \"external_version\": \"1.0\""
       "  }"
       "}";
-  ignore_list.clear();
-  EXPECT_EQ(1, visitor.Visit(json_data, ignore_list));
+  EXPECT_EQ(1, visitor.Visit(json_data));
 }
 
 // Test loading good extensions from the profile directory.
 TEST_F(ExtensionsServiceTest, LoadAndRelocalizeExtensions) {
   // Initialize the test dir with a good Preferences/extensions.
   FilePath source_install_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_install_dir));
   source_install_dir = source_install_dir
       .AppendASCII("extensions")
       .AppendASCII("l10n");
@@ skipping 204 matching lines @@
   // Component extensions shouldn't get recourded in the prefs.
   ValidatePrefKeyCount(0);
 
   // Reload all extensions, and make sure it comes back.
   std::string extension_id = service_->extensions()->at(0)->id();
   loaded_.clear();
   service_->ReloadExtensions();
   ASSERT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ(extension_id, service_->extensions()->at(0)->id());
 }