Move test_url_fetcher_factory.* from content/ to net/url_request

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/compiler_specific.h"
@@ skipping 24 matching lines @@
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/test/test_browser_thread.h"
-#include "content/public/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/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
 using testing::DoAll;
 using testing::Mock;
 using testing::Return;
@@ skipping 415 matching lines @@
     if (pending) {
       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;
+    net::TestURLFetcherFactory 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);
 
     // Get the url our mock fetcher was asked to fetch.
-    TestURLFetcher* fetcher =
+    net::TestURLFetcher* fetcher =
         factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     const GURL& url = fetcher->GetOriginalURL();
     EXPECT_FALSE(url.is_empty());
     EXPECT_TRUE(url.is_valid());
     EXPECT_TRUE(url.SchemeIs("http"));
     EXPECT_EQ("foo.com", url.host());
     EXPECT_EQ("/bar", url.path());
 
     // Validate the extension request parameters in the query. It should
     // look something like "?x=id%3D<id>%26v%3D<version>%26uc".
@@ skipping 13 matching lines @@
       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;
 
-    TestURLFetcherFactory factory;
+    net::TestURLFetcherFactory 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 =
+    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());
 
@@ skipping 47 matching lines @@
     // Make sure that an update URL data string causes an appropriate ap=
     // option to appear in the x= parameter.
     ManifestFetchData fetch_data(GURL("http://localhost/foo"));
     fetch_data.AddExtension(id, version, &kNeverPingedData, "a=1&b=2&c", "");
     EXPECT_EQ("http://localhost/foo\?x=id%3Daaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
               "%26v%3D1.0%26uc%26ap%3Da%253D1%2526b%253D2%2526c",
               fetch_data.full_url().spec());
   }
 
   void TestUpdateUrlDataFromGallery(const std::string& gallery_url) {
-    TestURLFetcherFactory factory;
+    net::TestURLFetcherFactory factory;
 
     MockService service;
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, service.request_context());
     ExtensionList extensions;
     std::string url(gallery_url);
 
     service.CreateTestExtensions(1, 1, &extensions, &url, Extension::INTERNAL);
 
     const std::string& id = extensions[0]->id();
     EXPECT_CALL(delegate, GetPingDataForExtension(id, _));
 
     downloader.AddExtension(*extensions[0]);
     downloader.StartAllPending();
-    TestURLFetcher* fetcher =
+    net::TestURLFetcher* fetcher =
         factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     ASSERT_TRUE(fetcher);
     // Make sure that extensions that update from the gallery ignore any
     // update URL data.
     const std::string& update_url = fetcher->GetOriginalURL().spec();
     std::string::size_type x = update_url.find("x=");
     EXPECT_NE(std::string::npos, x);
     std::string::size_type ap = update_url.find("ap%3D", x);
     EXPECT_EQ(std::string::npos, ap);
   }
@@ skipping 86 matching lines @@
     std::vector<int> updateable;
     downloader.DetermineUpdates(fetch_data, updates, &updateable);
     // All the apps should be updateable.
     EXPECT_EQ(3u, updateable.size());
     for (std::vector<int>::size_type i = 0; i < updateable.size(); ++i) {
       EXPECT_EQ(static_cast<int>(i), updateable[i]);
     }
   }
 
   void TestMultipleManifestDownloading() {
-    TestURLFetcherFactory factory;
-    TestURLFetcher* fetcher = NULL;
+    net::TestURLFetcherFactory factory;
+    net::TestURLFetcher* fetcher = NULL;
     NotificationsObserver observer;
     MockService service;
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, service.request_context());
 
     GURL kUpdateUrl("http://localhost/manifest1");
 
     ManifestFetchData* fetch1 = new ManifestFetchData(kUpdateUrl);
     ManifestFetchData* fetch2 = new ManifestFetchData(kUpdateUrl);
     ManifestFetchData* fetch3 = new ManifestFetchData(kUpdateUrl);
@@ skipping 91 matching lines @@
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     RunAllPending();
     Mock::VerifyAndClearExpectations(&delegate);
 
     // Verify that the downloader decided to update this extension.
     EXPECT_EQ(1u, observer.UpdatedCount());
     EXPECT_TRUE(observer.Updated("4444"));
   }
 
   void TestSingleExtensionDownloading(bool pending) {
-    TestURLFetcherFactory factory;
-    TestURLFetcher* fetcher = NULL;
+    net::TestURLFetcherFactory factory;
+    net::TestURLFetcher* fetcher = NULL;
     scoped_ptr<ServiceForDownloadTests> service(new ServiceForDownloadTests);
     ExtensionUpdater updater(service.get(), service->extension_prefs(),
                              service->pref_service(),
                              service->profile(),
                              kUpdateFrequencySecs);
     updater.Start();
     ResetDownloader(
         &updater,
         new ExtensionDownloader(&updater, service->request_context()));
 
@@ skipping 35 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());
     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() {
-    TestURLFetcherFactory factory;
-    TestURLFetcher* fetcher = NULL;
+    net::TestURLFetcherFactory factory;
+    net::TestURLFetcher* fetcher = NULL;
     ServiceForBlacklistTests service;
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
     updater.Start();
     ResetDownloader(
         &updater,
         new ExtensionDownloader(&updater, service.request_context()));
     GURL test_url("http://localhost/extension.crx");
 
@@ skipping 26 matching lines @@
 
     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) {
-    TestURLFetcherFactory factory;
-    TestURLFetcher* fetcher = NULL;
+    net::TestURLFetcherFactory factory;
+    net::TestURLFetcher* fetcher = NULL;
     ServiceForDownloadTests service;
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
     updater.Start();
     ResetDownloader(
         &updater,
         new ExtensionDownloader(&updater, service.request_context()));
 
     EXPECT_FALSE(updater.crx_install_is_running_);
@@ skipping 145 matching lines @@
   // Test requests to both a Google server and a non-google server. This allows
   // us to test various combinations of installed (ie roll call) and active
   // (ie app launch) ping scenarios. The invariant is that each type of ping
   // value should be present at most once per day, and can be calculated based
   // 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).
   void TestGalleryRequests(int rollcall_ping_days,
                            int active_ping_days,
                            bool active_bit,
                            bool expect_brand_code) {
-    TestURLFetcherFactory factory;
+    net::TestURLFetcherFactory 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 28 matching lines @@
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
     updater.set_blacklist_checks_enabled(false);
     updater.Start();
     updater.CheckNow();
 
     // Make the updater do manifest fetching, and note the urls it tries to
     // fetch.
     std::vector<GURL> fetched_urls;
-    TestURLFetcher* fetcher =
+    net::TestURLFetcher* fetcher =
       factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     fetched_urls.push_back(fetcher->GetOriginalURL());
 
     fetcher->set_url(fetched_urls[0]);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(500);
     fetcher->SetResponseString("");
     fetcher->delegate()->OnURLFetchComplete(fetcher);
 
@@ skipping 164 matching lines @@
 
 TEST_F(ExtensionUpdaterTest, TestGalleryRequestsWithNonOrganicBrand) {
   TestGalleryRequestsWithBrand(false);
 }
 
 TEST_F(ExtensionUpdaterTest, TestHandleManifestResults) {
   TestHandleManifestResults();
 }
 
 TEST_F(ExtensionUpdaterTest, TestNonAutoUpdateableLocations) {
-  TestURLFetcherFactory factory;
+  net::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);
@@ skipping 10 matching lines @@
   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;
+  net::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);
@@ skipping 17 matching lines @@
   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;
+  net::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.
   std::string id = GenerateId("foo");
   EXPECT_CALL(delegate, GetPingDataForExtension(id, _)).WillOnce(Return(false));
@@ skipping 24 matching lines @@
   EXPECT_EQ(0u, ManifestFetchersCount(downloader.get()));
 
   // Extensions with empty update URLs should have a default one
   // filled in.
   id = GenerateId("foo3");
   EXPECT_CALL(delegate, GetPingDataForExtension(id, _)).WillOnce(Return(false));
   EXPECT_TRUE(downloader->AddPendingExtension(id, GURL()));
   downloader->StartAllPending();
   EXPECT_EQ(1u, ManifestFetchersCount(downloader.get()));
 
-  TestURLFetcher* fetcher =
+  net::TestURLFetcher* fetcher =
       factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
   ASSERT_TRUE(fetcher);
   EXPECT_FALSE(fetcher->GetOriginalURL().is_empty());
 }
 
 TEST_F(ExtensionUpdaterTest, TestStartUpdateCheckMemory) {
-  TestURLFetcherFactory factory;
+  net::TestURLFetcherFactory factory;
   MockService service;
   MockExtensionDownloaderDelegate delegate;
   ExtensionDownloader downloader(&delegate, service.request_context());
 
   StartUpdateCheck(&downloader, new ManifestFetchData(GURL()));
   // This should delete the newly-created ManifestFetchData.
   StartUpdateCheck(&downloader, new ManifestFetchData(GURL()));
   // This should add into |manifests_pending_|.
   StartUpdateCheck(&downloader, new ManifestFetchData(GURL(
       GURL("http://www.google.com"))));
   // The dtor of |downloader| should delete the pending fetchers.
 }
 
 TEST_F(ExtensionUpdaterTest, TestCheckSoon) {
   ServiceForManifestTests service;
-  TestURLFetcherFactory factory;
+  net::TestURLFetcherFactory 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());
   RunAllPending();
   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