Add a scoper object for URLFetcher::Factory

chrome/browser/extensions/extension_updater_unittest.cc

 // Copyright (c) 2011 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 "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/version.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_updater.h"
 #include "chrome/browser/extensions/test_extension_prefs.h"
 #include "chrome/browser/extensions/test_extension_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/testing_profile.h"
 #include "content/browser/browser_thread.h"
-#include "content/common/test_url_fetcher_factory.h"
+#include "content/test/test_url_fetcher_factory.h"
 #include "libxml/globals.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
 
 namespace {
@@ skipping 289 matching lines @@
       SetupPendingExtensionManagerForTest(1, GURL(update_url),
                                           pending_extension_manager);
     } else {
       service.CreateTestExtensions(1, 1, &extensions, &update_url,
                                    Extension::INTERNAL);
       service.set_extensions(extensions);
     }
 
     // Set up and start the updater.
     TestURLFetcherFactory factory;
-    URLFetcher::set_factory(&factory);
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), 60*60*24);
     updater.Start();
     // Disable blacklist checks (tested elsewhere) so that we only see the
     // update HTTP request.
     updater.set_blacklist_checks_enabled(false);
 
     // Tell the update that it's time to do update checks.
     SimulateTimerFired(&updater);
@@ skipping 32 matching lines @@
   static void TestBlacklistUpdateCheckRequests() {
     ServiceForManifestTests service;
 
     // Setup and start the updater.
     MessageLoop message_loop;
     BrowserThread ui_thread(BrowserThread::UI, &message_loop);
     BrowserThread io_thread(BrowserThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
-    URLFetcher::set_factory(&factory);
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), 60*60*24);
     updater.Start();
 
     // Tell the updater that it's time to do update checks.
     SimulateTimerFired(&updater);
 
     // Get the url our mock fetcher was asked to fetch.
     TestURLFetcher* fetcher =
@@ skipping 168 matching lines @@
   static void TestMultipleManifestDownloading() {
     MessageLoop ui_loop;
     BrowserThread ui_thread(BrowserThread::UI, &ui_loop);
     BrowserThread file_thread(BrowserThread::FILE);
     file_thread.Start();
     BrowserThread io_thread(BrowserThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     TestURLFetcher* fetcher = NULL;
-    URLFetcher::set_factory(&factory);
     scoped_ptr<ServiceForDownloadTests> service(new ServiceForDownloadTests);
     ExtensionUpdater updater(service.get(),
                              service->extension_prefs(),
                              service->pref_service(),
                              service->profile(),
                              kUpdateFrequencySecs);
     updater.Start();
 
     GURL url1("http://localhost/manifest1");
     GURL url2("http://localhost/manifest2");
@@ skipping 59 matching lines @@
   static void TestSingleExtensionDownloading(bool pending) {
     MessageLoop ui_loop;
     BrowserThread ui_thread(BrowserThread::UI, &ui_loop);
     BrowserThread file_thread(BrowserThread::FILE);
     file_thread.Start();
     BrowserThread io_thread(BrowserThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     TestURLFetcher* fetcher = NULL;
-    URLFetcher::set_factory(&factory);
     scoped_ptr<ServiceForDownloadTests> service(new ServiceForDownloadTests);
     ExtensionUpdater updater(service.get(), service->extension_prefs(),
                              service->pref_service(),
                              service->profile(),
                              kUpdateFrequencySecs);
     updater.Start();
 
     GURL test_url("http://localhost/extension.crx");
 
     std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
@@ skipping 34 matching lines @@
     EXPECT_EQ(id, service->extension_id());
     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);
 
     // The FILE thread is needed for |service|'s cleanup,
     // because of ImportantFileWriter.
     file_thread.Start();
     service.reset();
-
-    URLFetcher::set_factory(NULL);
   }
 
   static void TestBlacklistDownloading() {
     MessageLoop message_loop;
     BrowserThread ui_thread(BrowserThread::UI, &message_loop);
     BrowserThread file_thread(BrowserThread::FILE, &message_loop);
     BrowserThread io_thread(BrowserThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     TestURLFetcher* fetcher = NULL;
-    URLFetcher::set_factory(&factory);
     ServiceForBlacklistTests service;
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
     updater.Start();
     GURL test_url("http://localhost/extension.crx");
 
     std::string id = "com.google.crx.blacklist";
 
     std::string hash =
@@ skipping 16 matching lines @@
     fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     message_loop.RunAllPending();
 
     // The updater should have called extension service to process the
     // blacklist.
     EXPECT_TRUE(service.processed_blacklist());
 
     EXPECT_EQ(version, service.pref_service()->
       GetString(prefs::kExtensionBlacklistUpdateVersion));
-
-    URLFetcher::set_factory(NULL);
   }
 
   // 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.
   static void TestMultipleExtensionDownloading(bool updates_start_running) {
     MessageLoopForUI message_loop;
     BrowserThread ui_thread(BrowserThread::UI, &message_loop);
     BrowserThread file_thread(BrowserThread::FILE, &message_loop);
     BrowserThread io_thread(BrowserThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     TestURLFetcher* fetcher = NULL;
-    URLFetcher::set_factory(&factory);
     ServiceForDownloadTests service;
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
     updater.Start();
 
     EXPECT_FALSE(updater.crx_install_is_running_);
 
     GURL url1("http://localhost/extension1.crx");
     GURL url2("http://localhost/extension2.crx");
@@ skipping 109 matching lines @@
   // on the delta between now and the last ping time (or in the case of active
   // pings, that delta plus whether the app has been active).
   static void TestGalleryRequests(int rollcall_ping_days,
                                   int active_ping_days,
                                   bool active_bit) {
     MessageLoop message_loop;
     BrowserThread ui_thread(BrowserThread::UI, &message_loop);
     BrowserThread file_thread(BrowserThread::FILE, &message_loop);
 
     TestURLFetcherFactory factory;
-    URLFetcher::set_factory(&factory);
 
     // Set up 2 mock extensions, one with a google.com update url and one
     // without.
     ServiceForManifestTests service;
     ExtensionList tmp;
     GURL url1("http://clients2.google.com/service/update2/crx");
     GURL url2("http://www.somewebsite.com");
     service.CreateTestExtensions(1, 1, &tmp, &url1.possibly_invalid_spec(),
                                  Extension::INTERNAL);
     service.CreateTestExtensions(2, 1, &tmp, &url2.possibly_invalid_spec(),
@@ skipping 266 matching lines @@
   EXPECT_FALSE(fetch->full_url().is_empty());
 }
 
 TEST(ExtensionUpdaterTest, TestStartUpdateCheckMemory) {
     MessageLoop message_loop;
     BrowserThread ui_thread(BrowserThread::UI, &message_loop);
     BrowserThread file_thread(BrowserThread::FILE, &message_loop);
 
     ServiceForManifestTests service;
     TestURLFetcherFactory factory;
-    URLFetcher::set_factory(&factory);
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
     updater.Start();
     updater.StartUpdateCheck(new ManifestFetchData(GURL()));
     // This should delete the newly-created ManifestFetchData.
     updater.StartUpdateCheck(new ManifestFetchData(GURL()));
     // This should add into |manifests_pending_|.
     updater.StartUpdateCheck(new ManifestFetchData(
         GURL("http://www.google.com")));
     // This should clear out |manifests_pending_|.
     updater.Stop();
 }
 
 TEST(ExtensionUpdaterTest, TestCheckSoon) {
     MessageLoop message_loop;
     BrowserThread ui_thread(BrowserThread::UI, &message_loop);
     BrowserThread file_thread(BrowserThread::FILE, &message_loop);
 
     ServiceForManifestTests service;
     TestURLFetcherFactory factory;
-    URLFetcher::set_factory(&factory);
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         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());
     ExtensionUpdaterTest::SimulateCheckSoon(updater, &message_loop);
     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