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 2584 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());
 }