Allow autoupdate to update disabled extensions.

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 <map>
 #include <set>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
@@ skipping 243 matching lines @@
 }
 
 class ServiceForManifestTests : public MockService {
  public:
   ServiceForManifestTests() {}
 
   virtual ~ServiceForManifestTests() {}
 
   virtual const Extension* GetExtensionById(
       const std::string& id, bool include_disabled) const OVERRIDE {
-    return extensions_.GetByID(id);
+    const Extension* result = extensions_.GetByID(id);
+    if (result || !include_disabled)
+      return result;
+    return disabled_extensions_.GetByID(id);
   }
 
   virtual const ExtensionSet* extensions() const OVERRIDE {
     return &extensions_;
   }
 
+  virtual const ExtensionSet* disabled_extensions() const OVERRIDE {
+    return &disabled_extensions_;
+  }
+
   virtual PendingExtensionManager* pending_extension_manager() OVERRIDE {
     return &pending_extension_manager_;
   }
 
   void set_extensions(ExtensionList extensions) {
     for (ExtensionList::const_iterator it = extensions.begin();
          it != extensions.end(); ++it) {
       extensions_.Insert(*it);
     }
   }
 
+  void set_disabled_extensions(ExtensionList disabled_extensions) {
+    for (ExtensionList::const_iterator it = disabled_extensions.begin();
+         it != disabled_extensions.end(); ++it) {
+      disabled_extensions_.Insert(*it);
+    }
+  }
+
  private:
   ExtensionSet extensions_;
+  ExtensionSet disabled_extensions_;
 };
 
 class ServiceForDownloadTests : public MockService {
  public:
   ServiceForDownloadTests()
       : MockService() {
   }
 
   // Add a fake crx installer to be returned by a call to UpdateExtension()
   // with a specific ID.  Caller keeps ownership of |crx_installer|.
@@ skipping 1040 matching lines @@
   // |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, Extension::INVALID);
   service.CreateTestExtensions(2, 1, &extensions, NULL, Extension::INTERNAL);
   ASSERT_EQ(2u, extensions.size());
-  const std::string& id = extensions[1]->id();
+  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(id)).WillOnce(Return(""));
-  EXPECT_CALL(delegate, GetPingDataForExtension(id, _));
+  EXPECT_CALL(delegate, GetUpdateUrlData(updateable_id)).WillOnce(Return(""));
+  EXPECT_CALL(delegate, GetPingDataForExtension(updateable_id, _));
 
   service.set_extensions(extensions);
   updater.set_blacklist_checks_enabled(false);
   updater.Start();
   updater.CheckNow();
 }
 
+TEST_F(ExtensionUpdaterTest, TestUpdatingDisabledExtensions) {
+  TestURLFetcherFactory factory;
+  ServiceForManifestTests service;
+  ExtensionUpdater updater(&service, service.extension_prefs(),
+                           service.pref_service(), service.profile(),
+                           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,
+      Extension::INTERNAL);
+  service.CreateTestExtensions(2, 1, &disabled_extensions, NULL,
+      Extension::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);
+  updater.set_blacklist_checks_enabled(false);
+  updater.Start();
+  updater.CheckNow();
+}
+
 TEST_F(ExtensionUpdaterTest, TestManifestFetchesBuilderAddExtension) {
   TestURLFetcherFactory factory;
   MockService service;
   MockExtensionDownloaderDelegate delegate;
   scoped_ptr<ExtensionDownloader> downloader(
       new ExtensionDownloader(&delegate, service.request_context()));
   EXPECT_EQ(0u, ManifestFetchersCount(downloader.get()));
 
   // First, verify that adding valid extensions does invoke the callbacks on
   // the delegate.
@@ skipping 79 matching lines @@
 // -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