Delete the omahaproxy-backed extension blacklist and clear its entries from the

chrome/browser/extensions/updater/extension_updater_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 <list>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/version.h"
 #include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/extensions/blacklist.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_sync_data.h"
 #include "chrome/browser/extensions/extension_system.h"
-#include "chrome/browser/extensions/test_blacklist.h"
 #include "chrome/browser/extensions/test_extension_prefs.h"
 #include "chrome/browser/extensions/test_extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/extensions/updater/extension_downloader.h"
 #include "chrome/browser/extensions/updater/extension_downloader_delegate.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/extensions/updater/manifest_fetch_data.h"
 #include "chrome/browser/extensions/updater/request_queue_impl.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
@@ skipping 84 matching lines @@
   MOCK_METHOD4(OnExtensionDownloadFailed, void(const std::string&,
                                                Error,
                                                const PingResult&,
                                                const std::set<int>&));
   MOCK_METHOD6(OnExtensionDownloadFinished, void(const std::string&,
                                                  const base::FilePath&,
                                                  const GURL&,
                                                  const std::string&,
                                                  const PingResult&,
                                                  const std::set<int>&));
-  MOCK_METHOD5(OnBlacklistDownloadFinished, void(const std::string&,
-                                                 const std::string&,
-                                                 const std::string&,
-                                                 const PingResult&,
-                                                 const std::set<int>&));
   MOCK_METHOD2(GetPingDataForExtension,
                bool(const std::string&, ManifestFetchData::PingData*));
   MOCK_METHOD1(GetUpdateUrlData, std::string(const std::string&));
   MOCK_METHOD1(IsExtensionPending, bool(const std::string&));
   MOCK_METHOD2(GetExtensionExistingVersion,
                bool(const std::string&, std::string*));
 
   void Wait() {
     scoped_refptr<content::MessageLoopRunner> runner =
         new content::MessageLoopRunner;
@@ skipping 77 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(NotificationsObserver);
 };
 
 }  // namespace
 
 // Base class for further specialized test classes.
 class MockService : public TestExtensionService {
  public:
   explicit MockService(TestExtensionPrefs* prefs)
-      : prefs_(prefs),
-        pending_extension_manager_(*this),
-        blacklist_(prefs_->prefs()) {
+      : prefs_(prefs), pending_extension_manager_(*this) {
   }
 
   virtual ~MockService() {}
 
   virtual PendingExtensionManager* pending_extension_manager() OVERRIDE {
     ADD_FAILURE() << "Subclass should override this if it will "
                   << "be accessed by a test.";
     return &pending_extension_manager_;
   }
 
   Profile* profile() { return &profile_; }
 
   net::URLRequestContextGetter* request_context() {
     return profile_.GetRequestContext();
   }
 
   ExtensionPrefs* extension_prefs() { return prefs_->prefs(); }
 
   PrefService* pref_service() { return prefs_->pref_service(); }
 
-  Blacklist* blacklist() { return &blacklist_; }
-
   // Creates test extensions and inserts them into list. The name and
   // version are all based on their index. If |update_url| is non-null, it
   // will be used as the update_url for each extension.
   // The |id| is used to distinguish extension names and make sure that
   // no two extensions share the same name.
   void CreateTestExtensions(int id, int count, ExtensionList *list,
                             const std::string* update_url,
                             Manifest::Location location) {
     for (int i = 1; i <= count; i++) {
       DictionaryValue manifest;
       manifest.SetString(manifest_keys::kVersion,
                          base::StringPrintf("%d.0.0.0", i));
       manifest.SetString(manifest_keys::kName,
                          base::StringPrintf("Extension %d.%d", id, i));
       if (update_url)
         manifest.SetString(manifest_keys::kUpdateURL, *update_url);
       scoped_refptr<Extension> e =
           prefs_->AddExtensionWithManifest(manifest, location);
       ASSERT_TRUE(e.get() != NULL);
       list->push_back(e);
     }
   }
 
  protected:
   TestExtensionPrefs* const prefs_;
   PendingExtensionManager pending_extension_manager_;
   TestingProfile profile_;
-  Blacklist blacklist_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockService);
 };
 
 
 bool ShouldInstallExtensionsOnly(const Extension* extension) {
   return extension->GetType() == Manifest::TYPE_EXTENSION;
 }
 
@@ skipping 266 matching lines @@
     } else {
       service.CreateTestExtensions(1, 1, &extensions, &update_url,
                                    Manifest::INTERNAL);
       service.set_extensions(extensions);
     }
 
     // Set up and start the updater.
     net::TestURLFetcherFactory factory;
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
-        service.profile(), service.blacklist(), 60*60*24);
+        service.profile(), 60*60*24);
     updater.Start();
-    // Disable blacklist checks (tested elsewhere) so that we only see the
-    // update HTTP request.
-    ExtensionUpdater::CheckParams check_params;
-    check_params.check_blacklist = false;
-    updater.set_default_check_params(check_params);
 
     // Tell the update that it's time to do update checks.
     EXPECT_EQ(0u, observer.StartedCount());
     SimulateTimerFired(&updater);
     EXPECT_EQ(1u, observer.StartedCount());
 
     // Get the url our mock fetcher was asked to fetch.
     net::TestURLFetcher* fetcher =
         factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     const GURL& url = fetcher->GetOriginalURL();
@@ skipping 11 matching lines @@
     if (pending) {
       EXPECT_TRUE(pending_extension_manager->IsIdPending(params["id"]));
       EXPECT_EQ("0.0.0.0", params["v"]);
     } else {
       EXPECT_EQ(extensions[0]->id(), params["id"]);
       EXPECT_EQ(extensions[0]->VersionString(), params["v"]);
     }
     EXPECT_EQ("", params["uc"]);
   }
 
-  void TestBlacklistUpdateCheckRequests() {
-    // Setup and start the updater.
-    ServiceForManifestTests service(prefs_.get());
-    NotificationsObserver observer;
-
-    net::TestURLFetcherFactory factory;
-    ExtensionUpdater updater(
-        &service, service.extension_prefs(), service.pref_service(),
-        service.profile(), service.blacklist(), 60*60*24);
-    updater.Start();
-
-    // Tell the updater that it's time to do update checks.
-    EXPECT_EQ(0u, observer.StartedCount());
-    SimulateTimerFired(&updater);
-    EXPECT_EQ(1u, observer.StartedCount());
-
-    // Get the url our mock fetcher was asked to fetch.
-    net::TestURLFetcher* fetcher =
-        factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
-    ASSERT_FALSE(fetcher == NULL);
-    const GURL& url = fetcher->GetOriginalURL();
-
-    EXPECT_FALSE(url.is_empty());
-    EXPECT_TRUE(url.is_valid());
-    EXPECT_TRUE(url.SchemeIs("https"));
-    EXPECT_EQ("clients2.google.com", url.host());
-    EXPECT_EQ("/service/update2/crx", url.path());
-
-    // Validate the extension request parameters in the query. It should
-    // look something like "x=id%3D<id>%26v%3D<version>%26uc".
-    EXPECT_TRUE(url.has_query());
-    std::map<std::string, std::string> params;
-    VerifyQueryAndExtractParameters(url.query(), &params);
-    EXPECT_EQ("com.google.crx.blacklist", params["id"]);
-    EXPECT_EQ("0", params["v"]);
-    EXPECT_EQ("", params["uc"]);
-    EXPECT_TRUE(ContainsKey(params, "ping"));
-  }
-
   void TestUpdateUrlDataEmpty() {
     const std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     const std::string version = "1.0";
 
     // Make sure that an empty update URL data string does not cause a ap=
     // option to appear in the x= parameter.
     ManifestFetchData fetch_data(GURL("http://localhost/foo"), 0);
     fetch_data.AddExtension(
         id, version, &kNeverPingedData, std::string(), std::string());
 
@@ skipping 356 matching lines @@
   }
 
   void TestSingleExtensionDownloading(bool pending, bool retry) {
     net::TestURLFetcherFactory factory;
     net::TestURLFetcher* fetcher = NULL;
     scoped_ptr<ServiceForDownloadTests> service(
         new ServiceForDownloadTests(prefs_.get()));
     ExtensionUpdater updater(service.get(), service->extension_prefs(),
                              service->pref_service(),
                              service->profile(),
-                             service->blacklist(),
                              kUpdateFrequencySecs);
     updater.Start();
     ResetDownloader(
         &updater,
         new ExtensionDownloader(&updater, service->request_context()));
     updater.downloader_->extensions_queue_.set_backoff_policy(
         &kNoBackoffPolicy);
 
     GURL test_url("http://localhost/extension.crx");
 
@@ skipping 49 matching lines @@
 
     // Expect that ExtensionUpdater asked the mock extensions service to install
     // a file with the test data for the right id.
     EXPECT_EQ(id, service->extension_id());
     base::FilePath tmpfile_path = service->install_path();
     EXPECT_FALSE(tmpfile_path.empty());
     EXPECT_EQ(test_url, service->download_url());
     EXPECT_EQ(extension_file_path, tmpfile_path);
   }
 
-  void TestBlacklistDownloading() {
-    net::TestURLFetcherFactory factory;
-    net::TestURLFetcher* fetcher = NULL;
-    MockService service(prefs_.get());
-    TestBlacklist blacklist(service.blacklist());
-    ExtensionUpdater updater(
-        &service, service.extension_prefs(), service.pref_service(),
-        service.profile(), blacklist.blacklist(), kUpdateFrequencySecs);
-    updater.Start();
-    ResetDownloader(
-        &updater,
-        new ExtensionDownloader(&updater, service.request_context()));
-    updater.downloader_->extensions_queue_.set_backoff_policy(
-        &kNoBackoffPolicy);
-
-    GURL test_url("http://localhost/extension.crx");
-
-    std::string id = "com.google.crx.blacklist";
-
-    std::string hash =
-        "CCEA231D3CD30A348DA1383ED311EAC11E82360773CB2BA4E2C3A5FF16E337CC";
-
-    std::string version = "0.0.1";
-    std::set<int> requests;
-    requests.insert(0);
-    scoped_ptr<ExtensionDownloader::ExtensionFetch> fetch(
-        new ExtensionDownloader::ExtensionFetch(
-            id, test_url, hash, version, requests));
-    updater.downloader_->FetchUpdatedExtension(fetch.Pass());
-
-    // Call back the ExtensionUpdater with a 200 response and some test data.
-    std::string extension_data("aaaabbbbcccceeeeaaaabbbbcccceeee");
-    EXPECT_FALSE(blacklist.IsBlacklisted(extension_data));
-
-    fetcher = factory.GetFetcherByID(ExtensionDownloader::kExtensionFetcherId);
-    EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
-    EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
-
-    fetcher->set_url(test_url);
-    fetcher->set_status(net::URLRequestStatus());
-    fetcher->set_response_code(200);
-    fetcher->SetResponseString(extension_data);
-    fetcher->delegate()->OnURLFetchComplete(fetcher);
-
-    RunUntilIdle();
-
-    EXPECT_TRUE(blacklist.IsBlacklisted(extension_data));
-
-    EXPECT_EQ(version, service.pref_service()->
-      GetString(prefs::kExtensionBlacklistUpdateVersion));
-  }
-
   // Two extensions are updated.  If |updates_start_running| is true, the
   // mock extensions service has UpdateExtension(...) return true, and
   // the test is responsible for creating fake CrxInstallers.  Otherwise,
   // UpdateExtension() returns false, signaling install failures.
   void TestMultipleExtensionDownloading(bool updates_start_running) {
     net::TestURLFetcherFactory factory;
     net::TestURLFetcher* fetcher = NULL;
     ServiceForDownloadTests service(prefs_.get());
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
-        service.profile(), service.blacklist(), kUpdateFrequencySecs);
+        service.profile(), kUpdateFrequencySecs);
     updater.Start();
     ResetDownloader(
         &updater,
         new ExtensionDownloader(&updater, service.request_context()));
     updater.downloader_->extensions_queue_.set_backoff_policy(
         &kNoBackoffPolicy);
 
     EXPECT_FALSE(updater.crx_install_is_running_);
 
     GURL url1("http://localhost/extension1.crx");
@@ skipping 193 matching lines @@
       Time last_active_ping_day = now -
                                   TimeDelta::FromDays(active_ping_days) -
                                   TimeDelta::FromSeconds(15);
       prefs->SetLastActivePingDay(id, last_active_ping_day);
     }
     if (active_bit)
       prefs->SetActiveBit(id, true);
 
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
-        service.profile(), service.blacklist(), kUpdateFrequencySecs);
+        service.profile(), kUpdateFrequencySecs);
     ExtensionUpdater::CheckParams params;
-    params.check_blacklist = false;
     updater.Start();
     updater.CheckNow(params);
 
     // Make the updater do manifest fetching, and note the urls it tries to
     // fetch.
     std::vector<GURL> fetched_urls;
     net::TestURLFetcher* fetcher =
       factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     fetched_urls.push_back(fetcher->GetOriginalURL());
@@ skipping 71 matching lines @@
   void TestHandleManifestResults() {
     ServiceForManifestTests service(prefs_.get());
     GURL update_url("http://www.google.com/manifest");
     ExtensionList tmp;
     service.CreateTestExtensions(1, 1, &tmp, &update_url.spec(),
                                  Manifest::INTERNAL);
     service.set_extensions(tmp);
 
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
-        service.profile(), service.blacklist(), kUpdateFrequencySecs);
+        service.profile(), kUpdateFrequencySecs);
     updater.Start();
     ResetDownloader(
         &updater,
         new ExtensionDownloader(&updater, service.request_context()));
 
     ManifestFetchData fetch_data(update_url, 0);
     const Extension* extension = tmp[0].get();
     fetch_data.AddExtension(extension->id(),
                             extension->VersionString(),
                             &kNeverPingedData,
@@ skipping 28 matching lines @@
 // subclasses where friendship with ExtenionUpdater is not inherited.
 
 TEST_F(ExtensionUpdaterTest, TestExtensionUpdateCheckRequests) {
   TestExtensionUpdateCheckRequests(false);
 }
 
 TEST_F(ExtensionUpdaterTest, TestExtensionUpdateCheckRequestsPending) {
   TestExtensionUpdateCheckRequests(true);
 }
 
-TEST_F(ExtensionUpdaterTest, TestBlacklistUpdateCheckRequests) {
-  TestBlacklistUpdateCheckRequests();
-}
-
 TEST_F(ExtensionUpdaterTest, TestUpdateUrlData) {
   TestUpdateUrlDataEmpty();
   TestUpdateUrlDataSimple();
   TestUpdateUrlDataCompound();
   TestUpdateUrlDataFromGallery(
       extension_urls::GetWebstoreUpdateUrl().spec());
 }
 
 TEST_F(ExtensionUpdaterTest, TestInstallSource) {
   TestInstallSource();
@@ skipping 20 matching lines @@
 }
 
 TEST_F(ExtensionUpdaterTest, TestSingleExtensionDownloadingWithRetry) {
   TestSingleExtensionDownloading(false, true);
 }
 
 TEST_F(ExtensionUpdaterTest, TestSingleExtensionDownloadingPendingWithRetry) {
   TestSingleExtensionDownloading(true, true);
 }
 
-TEST_F(ExtensionUpdaterTest, TestBlacklistDownloading) {
-  TestBlacklistDownloading();
-}
-
 TEST_F(ExtensionUpdaterTest, TestMultipleExtensionDownloadingUpdatesFail) {
   TestMultipleExtensionDownloading(false);
 }
 TEST_F(ExtensionUpdaterTest, TestMultipleExtensionDownloadingUpdatesSucceed) {
   TestMultipleExtensionDownloading(true);
 }
 
 TEST_F(ExtensionUpdaterTest, TestManifestRetryDownloading) {
   TestManifestRetryDownloading();
 }
 
 TEST_F(ExtensionUpdaterTest, TestGalleryRequestsWithOrganicBrand) {
   TestGalleryRequestsWithBrand(true);
 }
 
 TEST_F(ExtensionUpdaterTest, TestGalleryRequestsWithNonOrganicBrand) {
   TestGalleryRequestsWithBrand(false);
 }
 
 TEST_F(ExtensionUpdaterTest, TestHandleManifestResults) {
   TestHandleManifestResults();
 }
 
 TEST_F(ExtensionUpdaterTest, TestNonAutoUpdateableLocations) {
   net::TestURLFetcherFactory factory;
   ServiceForManifestTests service(prefs_.get());
   ExtensionUpdater updater(&service, service.extension_prefs(),
                            service.pref_service(), service.profile(),
-                           service.blacklist(), kUpdateFrequencySecs);
+                           kUpdateFrequencySecs);
   MockExtensionDownloaderDelegate delegate;
   // Set the downloader directly, so that all its events end up in the mock
   // |delegate|.
   ExtensionDownloader* downloader =
       new ExtensionDownloader(&delegate, service.request_context());
   ResetDownloader(&updater, downloader);
 
   // Non-internal non-external extensions should be rejected.
   ExtensionList extensions;
   service.CreateTestExtensions(1, 1, &extensions, NULL,
                                Manifest::INVALID_LOCATION);
   service.CreateTestExtensions(2, 1, &extensions, NULL, Manifest::INTERNAL);
   ASSERT_EQ(2u, extensions.size());
   const std::string& updateable_id = extensions[1]->id();
 
   // These expectations fail if the delegate's methods are invoked for the
   // first extension, which has a non-matching id.
   EXPECT_CALL(delegate, GetUpdateUrlData(updateable_id)).WillOnce(Return(""));
   EXPECT_CALL(delegate, GetPingDataForExtension(updateable_id, _));
 
   service.set_extensions(extensions);
   ExtensionUpdater::CheckParams params;
-  params.check_blacklist = false;
   updater.Start();
   updater.CheckNow(params);
 }
 
 TEST_F(ExtensionUpdaterTest, TestUpdatingDisabledExtensions) {
   net::TestURLFetcherFactory factory;
   ServiceForManifestTests service(prefs_.get());
   ExtensionUpdater updater(&service, service.extension_prefs(),
                            service.pref_service(), service.profile(),
-                           service.blacklist(), kUpdateFrequencySecs);
+                           kUpdateFrequencySecs);
   MockExtensionDownloaderDelegate delegate;
   // Set the downloader directly, so that all its events end up in the mock
   // |delegate|.
   ExtensionDownloader* downloader =
       new ExtensionDownloader(&delegate, service.request_context());
   ResetDownloader(&updater, downloader);
 
   // Non-internal non-external extensions should be rejected.
   ExtensionList enabled_extensions;
   ExtensionList disabled_extensions;
   service.CreateTestExtensions(1, 1, &enabled_extensions, NULL,
       Manifest::INTERNAL);
   service.CreateTestExtensions(2, 1, &disabled_extensions, NULL,
       Manifest::INTERNAL);
   ASSERT_EQ(1u, enabled_extensions.size());
   ASSERT_EQ(1u, disabled_extensions.size());
   const std::string& enabled_id = enabled_extensions[0]->id();
   const std::string& disabled_id = disabled_extensions[0]->id();
 
   // We expect that both enabled and disabled extensions are auto-updated.
   EXPECT_CALL(delegate, GetUpdateUrlData(enabled_id)).WillOnce(Return(""));
   EXPECT_CALL(delegate, GetPingDataForExtension(enabled_id, _));
   EXPECT_CALL(delegate, GetUpdateUrlData(disabled_id)).WillOnce(Return(""));
   EXPECT_CALL(delegate, GetPingDataForExtension(disabled_id, _));
 
   service.set_extensions(enabled_extensions);
   service.set_disabled_extensions(disabled_extensions);
   ExtensionUpdater::CheckParams params;
-  params.check_blacklist = false;
   updater.Start();
   updater.CheckNow(params);
 }
 
 TEST_F(ExtensionUpdaterTest, TestManifestFetchesBuilderAddExtension) {
   net::TestURLFetcherFactory factory;
   MockService service(prefs_.get());
   MockExtensionDownloaderDelegate delegate;
   scoped_ptr<ExtensionDownloader> downloader(
       new ExtensionDownloader(&delegate, service.request_context()));
@@ skipping 57 matching lines @@
   StartUpdateCheck(&downloader, new ManifestFetchData(GURL(
       GURL("http://www.google.com")), 0));
   // The dtor of |downloader| should delete the pending fetchers.
 }
 
 TEST_F(ExtensionUpdaterTest, TestCheckSoon) {
   ServiceForManifestTests service(prefs_.get());
   net::TestURLFetcherFactory factory;
   ExtensionUpdater updater(
       &service, service.extension_prefs(), service.pref_service(),
-      service.profile(), service.blacklist(), kUpdateFrequencySecs);
+      service.profile(), kUpdateFrequencySecs);
   EXPECT_FALSE(updater.WillCheckSoon());
   updater.Start();
   EXPECT_FALSE(updater.WillCheckSoon());
   updater.CheckSoon();
   EXPECT_TRUE(updater.WillCheckSoon());
   updater.CheckSoon();
   EXPECT_TRUE(updater.WillCheckSoon());
   RunUntilIdle();
   EXPECT_FALSE(updater.WillCheckSoon());
   updater.CheckSoon();
   EXPECT_TRUE(updater.WillCheckSoon());
   updater.Stop();
   EXPECT_FALSE(updater.WillCheckSoon());
 }
 
 // TODO(asargent) - (http://crbug.com/12780) add tests for:
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -malformed update url (empty, file://, has query, has a # fragment, etc.)
 // -An extension gets uninstalled while updates are in progress (so it doesn't
 //  "come back from the dead")
 // -An extension gets manually updated to v3 while we're downloading v2 (ie
 //  you don't get downgraded accidentally)
 // -An update manifest mentions multiple updates
 
 }  // namespace extensions