ExtensionUpdater: Abstract ExtensionDownloader creation

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"
@@ skipping 109 matching lines @@
 
 const char kAuthUserQueryKey[] = "authuser";
 
 int kExpectedLoadFlags =
     net::LOAD_DO_NOT_SEND_COOKIES |
     net::LOAD_DO_NOT_SAVE_COOKIES |
     net::LOAD_DISABLE_CACHE;
 
 int kExpectedLoadFlagsForDownloadWithCookies = net::LOAD_DISABLE_CACHE;
 
+// Fake authentication constants
+const char kFakeAccountId[] = "bobloblaw@lawblog.example.com";
+const char kFakeOAuth2Token[] = "ce n'est pas un jeton";
+
 const ManifestFetchData::PingData kNeverPingedData(
     ManifestFetchData::kNeverPinged, ManifestFetchData::kNeverPinged, true);
 
 class MockExtensionDownloaderDelegate : public ExtensionDownloaderDelegate {
  public:
   MOCK_METHOD4(OnExtensionDownloadFailed, void(const std::string&,
                                                Error,
                                                const PingResult&,
                                                const std::set<int>&));
   MOCK_METHOD7(OnExtensionDownloadFinished, void(const std::string&,
@@ skipping 133 matching lines @@
   }
   return 0;
 }
 
 }  // namespace
 
 // Base class for further specialized test classes.
 class MockService : public TestExtensionService {
  public:
   explicit MockService(TestExtensionPrefs* prefs)
-      : prefs_(prefs), pending_extension_manager_(&profile_) {}
+      : prefs_(prefs),
+        pending_extension_manager_(&profile_),
+        downloader_delegate_override_(NULL) {
+  }
 
   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(); }
 
+  FakeOAuth2TokenService* fake_token_service() {
+    return fake_token_service_.get();
+  }
+
   // 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++) {
       base::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);
     }
   }
 
+  ExtensionDownloader::Factory GetDownloaderFactory() {
+    return base::Bind(&MockService::CreateExtensionDownloader,
+                      base::Unretained(this));
+  }
+
+  ExtensionDownloader::Factory GetAuthenticatedDownloaderFactory() {
+    return base::Bind(&MockService::CreateExtensionDownloaderWithIdentity,
+                      base::Unretained(this));
+  }
+
+  void OverrideDownloaderDelegate(ExtensionDownloaderDelegate* delegate) {
+    downloader_delegate_override_ = delegate;
+  }
+
  protected:
   TestExtensionPrefs* const prefs_;
   TestingProfile profile_;
   PendingExtensionManager pending_extension_manager_;
 
  private:
+  scoped_ptr<ExtensionDownloader> CreateExtensionDownloader(
+      ExtensionDownloaderDelegate* delegate) {
+    return make_scoped_ptr(new ExtensionDownloader(
+        downloader_delegate_override_ ? downloader_delegate_override_
+            : delegate,
+        request_context()));
+  }
+
+  scoped_ptr<ExtensionDownloader> CreateExtensionDownloaderWithIdentity(
+      ExtensionDownloaderDelegate* delegate) {
+    scoped_ptr<FakeIdentityProvider> fake_identity_provider;
+    fake_token_service_.reset(new FakeOAuth2TokenService());
+    fake_identity_provider.reset(new FakeIdentityProvider(
+          fake_token_service_.get()));
+    fake_identity_provider->LogIn(kFakeAccountId);
+    fake_token_service_->AddAccount(kFakeAccountId);
+
+    scoped_ptr<ExtensionDownloader> downloader(
+        CreateExtensionDownloader(delegate));
+    downloader->SetWebstoreIdentityProvider(
+        fake_identity_provider.PassAs<IdentityProvider>());
+    return downloader.Pass();
+  }
+
+  scoped_ptr<FakeOAuth2TokenService> fake_token_service_;
+
+  ExtensionDownloaderDelegate* downloader_delegate_override_;
+
   DISALLOW_COPY_AND_ASSIGN(MockService);
 };
 
 
 bool ShouldInstallExtensionsOnly(const Extension* extension) {
   return extension->GetType() == Manifest::TYPE_EXTENSION;
 }
 
 bool ShouldInstallThemesOnly(const Extension* extension) {
   return extension->is_theme();
@@ skipping 28 matching lines @@
                              Manifest::INTERNAL,
                              Extension::NO_FLAGS,
                              kMarkAcknowledged,
                              kRemoteInstall));
   }
 }
 
 class ServiceForManifestTests : public MockService {
  public:
   explicit ServiceForManifestTests(TestExtensionPrefs* prefs)
-      : MockService(prefs), registry_(ExtensionRegistry::Get(profile())) {}
+      : MockService(prefs),
+        registry_(ExtensionRegistry::Get(profile())) {
+  }
 
   virtual ~ServiceForManifestTests() {}
 
   virtual const Extension* GetExtensionById(
       const std::string& id, bool include_disabled) const OVERRIDE {
     const Extension* result = registry_->enabled_extensions().GetByID(id);
     if (result || !include_disabled)
       return result;
     return registry_->disabled_extensions().GetByID(id);
   }
@@ skipping 173 matching lines @@
                       const std::string& version,
                       const std::string& url,
                       UpdateManifest::Results* results) {
     UpdateManifest::Result result;
     result.extension_id = id;
     result.version = version;
     result.crx_url = GURL(url);
     results->list.push_back(result);
   }
 
-  void ResetDownloader(ExtensionUpdater* updater,
-                       ExtensionDownloader* downloader) {
-    EXPECT_FALSE(updater->downloader_.get());
-    updater->downloader_.reset(downloader);
-  }
-
   void StartUpdateCheck(ExtensionDownloader* downloader,
                         ManifestFetchData* fetch_data) {
     downloader->StartUpdateCheck(scoped_ptr<ManifestFetchData>(fetch_data));
   }
 
   size_t ManifestFetchersCount(ExtensionDownloader* downloader) {
     return downloader->manifests_queue_.size() +
            (downloader->manifest_fetcher_.get() ? 1 : 0);
   }
 
@@ skipping 15 matching lines @@
     }
 
     // Set up and start the updater.
     net::TestURLFetcherFactory factory;
     ExtensionUpdater updater(&service,
                              service.extension_prefs(),
                              service.pref_service(),
                              service.profile(),
                              60 * 60 * 24,
                              NULL,
-                             make_scoped_ptr<IdentityProvider>(NULL));
+                             service.GetDownloaderFactory());
     updater.Start();
 
     // 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);
@@ skipping 66 matching lines @@
     EXPECT_EQ(id, params["id"]);
     EXPECT_EQ(version, params["v"]);
     EXPECT_EQ("a%3D1%26b%3D2%26c", params["ap"]);
   }
 
   void TestUpdateUrlDataFromGallery(const std::string& gallery_url) {
     net::TestURLFetcherFactory factory;
 
     MockService service(prefs_.get());
     MockExtensionDownloaderDelegate delegate;
-    ExtensionDownloader downloader(&delegate, service.request_context(), NULL);
+    ExtensionDownloader downloader(&delegate, service.request_context());
     ExtensionList extensions;
     std::string url(gallery_url);
 
     service.CreateTestExtensions(1, 1, &extensions, &url, Manifest::INTERNAL);
 
     const std::string& id = extensions[0]->id();
     EXPECT_CALL(delegate, GetPingDataForExtension(id, _));
 
     downloader.AddExtension(*extensions[0].get(), 0);
     downloader.StartAllPending(NULL);
@@ skipping 21 matching lines @@
     std::map<std::string, std::string> params;
     VerifyQueryAndExtractParameters(fetch_data.full_url().query(), &params);
     EXPECT_EQ(id, params["id"]);
     EXPECT_EQ(version, params["v"]);
     EXPECT_EQ(install_source, params["installsource"]);
   }
 
   void TestDetermineUpdates() {
     TestingProfile profile;
     MockExtensionDownloaderDelegate delegate;
-    ExtensionDownloader downloader(
-        &delegate, profile.GetRequestContext(), NULL);
+    ExtensionDownloader downloader(&delegate, profile.GetRequestContext());
 
     // Check passing an empty list of parse results to DetermineUpdates
     ManifestFetchData fetch_data(GURL("http://localhost/foo"), 0);
     UpdateManifest::Results updates;
     std::vector<int> updateable;
     downloader.DetermineUpdates(fetch_data, updates, &updateable);
     EXPECT_TRUE(updateable.empty());
 
     // Create two updates - expect that DetermineUpdates will return the first
     // one (v1.0 installed, v1.1 available) but not the second one (both
@@ skipping 22 matching lines @@
 
   void TestDetermineUpdatesPending() {
     // Create a set of test extensions
     ServiceForManifestTests service(prefs_.get());
     PendingExtensionManager* pending_extension_manager =
         service.pending_extension_manager();
     SetupPendingExtensionManagerForTest(3, GURL(), pending_extension_manager);
 
     TestingProfile profile;
     MockExtensionDownloaderDelegate delegate;
-    ExtensionDownloader downloader(
-        &delegate, profile.GetRequestContext(), NULL);
+    ExtensionDownloader downloader(&delegate, profile.GetRequestContext());
 
     ManifestFetchData fetch_data(GURL("http://localhost/foo"), 0);
     UpdateManifest::Results updates;
 
     std::list<std::string> ids_for_update_check;
     pending_extension_manager->GetPendingIdsForUpdateCheck(
         &ids_for_update_check);
 
     std::list<std::string>::const_iterator it;
     for (it = ids_for_update_check.begin();
@@ skipping 18 matching lines @@
       EXPECT_EQ(static_cast<int>(i), updateable[i]);
     }
   }
 
   void TestMultipleManifestDownloading() {
     net::TestURLFetcherFactory factory;
     factory.set_remove_fetcher_on_delete(true);
     net::TestURLFetcher* fetcher = NULL;
     MockService service(prefs_.get());
     MockExtensionDownloaderDelegate delegate;
-    ExtensionDownloader downloader(&delegate, service.request_context(), NULL);
+    ExtensionDownloader downloader(&delegate, service.request_context());
     downloader.manifests_queue_.set_backoff_policy(&kNoBackoffPolicy);
 
     GURL kUpdateUrl("http://localhost/manifest1");
 
     scoped_ptr<ManifestFetchData> fetch1(new ManifestFetchData(kUpdateUrl, 0));
     scoped_ptr<ManifestFetchData> fetch2(new ManifestFetchData(kUpdateUrl, 0));
     scoped_ptr<ManifestFetchData> fetch3(new ManifestFetchData(kUpdateUrl, 0));
     scoped_ptr<ManifestFetchData> fetch4(new ManifestFetchData(kUpdateUrl, 0));
     ManifestFetchData::PingData zeroDays(0, 0, true);
     fetch1->AddExtension(
@@ skipping 119 matching lines @@
     if (fetcher)
       ADD_FAILURE() << "Unexpected fetch: " << fetcher->GetOriginalURL();
   }
 
   void TestManifestRetryDownloading() {
     net::TestURLFetcherFactory factory;
     net::TestURLFetcher* fetcher = NULL;
     NotificationsObserver observer;
     MockService service(prefs_.get());
     MockExtensionDownloaderDelegate delegate;
-    ExtensionDownloader downloader(&delegate, service.request_context(), NULL);
+    ExtensionDownloader downloader(&delegate, service.request_context());
     downloader.manifests_queue_.set_backoff_policy(&kNoBackoffPolicy);
 
     GURL kUpdateUrl("http://localhost/manifest1");
 
     scoped_ptr<ManifestFetchData> fetch(new ManifestFetchData(kUpdateUrl, 0));
     ManifestFetchData::PingData zeroDays(0, 0, true);
     fetch->AddExtension(
         "1111", "1.0", &zeroDays, kEmptyUpdateUrlData, std::string());
 
     // This will start the first fetcher.
@@ skipping 58 matching lines @@
     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(),
                              kUpdateFrequencySecs,
                              NULL,
-                             make_scoped_ptr<IdentityProvider>(NULL));
-    updater.Start();
+                             service->GetDownloaderFactory());
     MockExtensionDownloaderDelegate delegate;
     delegate.DelegateTo(&updater);
-    ResetDownloader(
-        &updater,
-        new ExtensionDownloader(&delegate, service->request_context(), NULL));
+    service->OverrideDownloaderDelegate(&delegate);
+    updater.Start();
+    updater.EnsureDownloaderCreated();
     updater.downloader_->extensions_queue_.set_backoff_policy(
         &kNoBackoffPolicy);
 
     GURL test_url("http://localhost/extension.crx");
 
     std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     std::string hash;
     Version version("0.0.1");
     std::set<int> requests;
     requests.insert(0);
@@ skipping 75 matching lines @@
   // initially responds with a 403 status. If |identity_provider| is not NULL,
   // this will first expect a request which includes an Authorization header
   // with an OAuth2 bearer token; otherwise, or if OAuth2 failure is simulated,
   // this expects the downloader to fall back onto cookie-based credentials.
   void TestProtectedDownload(
       const std::string& url_prefix,
       bool enable_oauth2,
       bool succeed_with_oauth2,
       int valid_authuser,
       int max_authuser) {
-    const char kFakeAccountId[] = "bobloblaw@lawblog.example.com";
-    const char kFakeOAuth2Token[] = "ce n'est pas un jeton";
-
     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(),
-                             kUpdateFrequencySecs,
-                             NULL,
-                             make_scoped_ptr<IdentityProvider>(NULL));
+    const ExtensionDownloader::Factory& downloader_factory =
+        enable_oauth2 ? service->GetAuthenticatedDownloaderFactory()
+            : service->GetDownloaderFactory();
+    ExtensionUpdater updater(
+        service.get(),
+        service->extension_prefs(),
+        service->pref_service(),
+        service->profile(),
+        kUpdateFrequencySecs,
+        NULL,
+        downloader_factory);
     updater.Start();
-
-    scoped_ptr<FakeOAuth2TokenService> fake_token_service;
-    scoped_ptr<FakeIdentityProvider> fake_identity_provider;
-    if (enable_oauth2) {
-      fake_token_service.reset(new FakeOAuth2TokenService());
-      fake_identity_provider.reset(new FakeIdentityProvider(
-          fake_token_service.get()));
-      fake_identity_provider->LogIn(kFakeAccountId);
-      fake_token_service->AddAccount(kFakeAccountId);
-    }
-
-    ResetDownloader(
-        &updater,
-        new ExtensionDownloader(&updater,
-                                service->request_context(),
-                                fake_identity_provider.get()));
+    updater.EnsureDownloaderCreated();
     updater.downloader_->extensions_queue_.set_backoff_policy(
         &kNoBackoffPolicy);
 
     GURL test_url(base::StringPrintf("%s/extension.crx", url_prefix.c_str()));
     std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     std::string hash;
-    Version version("0.0.1");
+  Version version("0.0.1");
     std::set<int> requests;
     requests.insert(0);
     scoped_ptr<ExtensionDownloader::ExtensionFetch> fetch(
         new ExtensionDownloader::ExtensionFetch(
             id, test_url, hash, version.GetString(), requests));
     updater.downloader_->FetchUpdatedExtension(fetch.Pass());
 
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_EQ(kExpectedLoadFlags, fetcher->GetLoadFlags());
 
     // Fake a 403 response.
     fetcher->set_url(test_url);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(403);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
-    if (fake_token_service) {
-      fake_token_service->IssueAllTokensForAccount(
+
+    if (service->fake_token_service()) {
+      service->fake_token_service()->IssueAllTokensForAccount(
           kFakeAccountId, kFakeOAuth2Token, base::Time::Now());
     }
     RunUntilIdle();
 
     bool using_oauth2 = false;
     int expected_load_flags = kExpectedLoadFlags;
     // Verify that the fetch has had its credentials properly incremented.
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     net::HttpRequestHeaders fetch_headers;
@@ skipping 131 matching lines @@
   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(),
                              kUpdateFrequencySecs,
                              NULL,
-                             make_scoped_ptr<IdentityProvider>(NULL));
+                             service.GetDownloaderFactory());
     updater.Start();
-    ResetDownloader(
-        &updater,
-        new ExtensionDownloader(&updater, service.request_context(), NULL));
+    updater.EnsureDownloaderCreated();
     updater.downloader_->extensions_queue_.set_backoff_policy(
         &kNoBackoffPolicy);
 
     EXPECT_FALSE(updater.crx_install_is_running_);
 
     GURL url1("http://localhost/extension1.crx");
     GURL url2("http://localhost/extension2.crx");
 
     std::string id1 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     std::string id2 = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
@@ skipping 190 matching lines @@
     }
     if (active_bit)
       prefs->SetActiveBit(id, true);
 
     ExtensionUpdater updater(&service,
                              service.extension_prefs(),
                              service.pref_service(),
                              service.profile(),
                              kUpdateFrequencySecs,
                              NULL,
-                             make_scoped_ptr<IdentityProvider>(NULL));
+                             service.GetDownloaderFactory());
     ExtensionUpdater::CheckParams params;
     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);
@@ skipping 76 matching lines @@
     service.CreateTestExtensions(1, 1, &tmp, &update_url.spec(),
                                  Manifest::INTERNAL);
     service.set_extensions(tmp, ExtensionList());
 
     ExtensionUpdater updater(&service,
                              service.extension_prefs(),
                              service.pref_service(),
                              service.profile(),
                              kUpdateFrequencySecs,
                              NULL,
-                             make_scoped_ptr<IdentityProvider>(NULL));
+                             service.GetDownloaderFactory());
     updater.Start();
-    ResetDownloader(
-        &updater,
-        new ExtensionDownloader(&updater, service.request_context(), NULL));
+    updater.EnsureDownloaderCreated();
 
     ManifestFetchData fetch_data(update_url, 0);
     const Extension* extension = tmp[0].get();
     fetch_data.AddExtension(extension->id(),
                             extension->VersionString(),
                             &kNeverPingedData,
                             kEmptyUpdateUrlData,
                             std::string());
     UpdateManifest::Results results;
     results.daystart_elapsed_seconds = 750;
@@ skipping 163 matching lines @@
 
 TEST_F(ExtensionUpdaterTest, TestNonAutoUpdateableLocations) {
   net::TestURLFetcherFactory factory;
   ServiceForManifestTests service(prefs_.get());
   ExtensionUpdater updater(&service,
                            service.extension_prefs(),
                            service.pref_service(),
                            service.profile(),
                            kUpdateFrequencySecs,
                            NULL,
-                           make_scoped_ptr<IdentityProvider>(NULL));
+                           service.GetDownloaderFactory());
   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(), NULL);
-  ResetDownloader(&updater, downloader);
+  service.OverrideDownloaderDelegate(&delegate);
 
   // 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,
+              GetUpdateUrlData(updateable_id)).WillOnce(Return(""));
   EXPECT_CALL(delegate, GetPingDataForExtension(updateable_id, _));
 
   service.set_extensions(extensions, ExtensionList());
   ExtensionUpdater::CheckParams params;
   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(),
                            kUpdateFrequencySecs,
                            NULL,
-                           make_scoped_ptr<IdentityProvider>(NULL));
+                           service.GetDownloaderFactory());
   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(), NULL);
-  ResetDownloader(&updater, downloader);
+  service.OverrideDownloaderDelegate(&delegate);
 
   // 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,
+              GetUpdateUrlData(disabled_id)).WillOnce(Return(""));
   EXPECT_CALL(delegate, GetPingDataForExtension(disabled_id, _));
 
   service.set_extensions(enabled_extensions, disabled_extensions);
   ExtensionUpdater::CheckParams params;
   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(), NULL));
+      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.
   std::string id = id_util::GenerateId("foo");
   EXPECT_CALL(delegate, GetPingDataForExtension(id, _)).WillOnce(Return(false));
   EXPECT_TRUE(
       downloader->AddPendingExtension(id, GURL("http://example.com/update"),
                                       0));
   downloader->StartAllPending(NULL);
@@ skipping 10 matching lines @@
   // Extensions with empty IDs should be rejected.
   EXPECT_FALSE(downloader->AddPendingExtension(std::string(), GURL(), 0));
   downloader->StartAllPending(NULL);
   EXPECT_EQ(1u, ManifestFetchersCount(downloader.get()));
 
   // TODO(akalin): Test that extensions with empty update URLs
   // converted from user scripts are rejected.
 
   // Reset the ExtensionDownloader so that it drops the current fetcher.
   downloader.reset(
-      new ExtensionDownloader(&delegate, service.request_context(), NULL));
+      new ExtensionDownloader(&delegate, service.request_context()));
   EXPECT_EQ(0u, ManifestFetchersCount(downloader.get()));
 
   // Extensions with empty update URLs should have a default one
   // filled in.
   id = id_util::GenerateId("foo3");
   EXPECT_CALL(delegate, GetPingDataForExtension(id, _)).WillOnce(Return(false));
   EXPECT_TRUE(downloader->AddPendingExtension(id, GURL(), 0));
   downloader->StartAllPending(NULL);
   EXPECT_EQ(1u, ManifestFetchersCount(downloader.get()));
 
   net::TestURLFetcher* fetcher =
       factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
   ASSERT_TRUE(fetcher);
   EXPECT_FALSE(fetcher->GetOriginalURL().is_empty());
 }
 
 TEST_F(ExtensionUpdaterTest, TestStartUpdateCheckMemory) {
   net::TestURLFetcherFactory factory;
   MockService service(prefs_.get());
   MockExtensionDownloaderDelegate delegate;
-  ExtensionDownloader downloader(&delegate, service.request_context(), NULL);
+  ExtensionDownloader downloader(&delegate, service.request_context());
 
   StartUpdateCheck(&downloader, new ManifestFetchData(GURL(), 0));
   // This should delete the newly-created ManifestFetchData.
   StartUpdateCheck(&downloader, new ManifestFetchData(GURL(), 0));
   // This should add into |manifests_pending_|.
   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(),
                            kUpdateFrequencySecs,
                            NULL,
-                           make_scoped_ptr<IdentityProvider>(NULL));
+                           service.GetDownloaderFactory());
   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