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 242 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& enabled_id = extensions[1]->id();
+
+  ExtensionList disabled_extensions;
+  service.CreateTestExtensions(3, 1, &disabled_extensions, NULL,
+      Extension::INVALID);
+  service.CreateTestExtensions(4, 1, &disabled_extensions, NULL,
+      Extension::INTERNAL);
+  ASSERT_EQ(2u, disabled_extensions.size());
+  const std::string& disabled_id = disabled_extensions[1]->id();

[asargent_no_longer_on_chrome, 2012/03/20 00:24:01]

Since this test ("TestNonAutoUpdateableLocations") is about testing extensions
with an empty update url, it would probably be better to just put your code in a
separate test in this file. Within your separate test, you can have two disabled
extensions, one with and one without an update url. 

[Matt Tytel, 2012/03/20 20:34:28]

Done.

 
   // 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(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(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(
@@ skipping 84 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