Move creation and ownership of ResourceDispatcherHost and PluginService to content. This gives a ...

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"
@@ skipping 321 matching lines @@
       service.CreateTestExtensions(1, 1, &extensions, &update_url,
                                    Extension::INTERNAL);
       service.set_extensions(extensions);
     }
 
     // Set up and start the updater.
     TestURLFetcherFactory factory;
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), 60*60*24);
+    updater.set_use_utility_process_for_testing(false);
     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 =
@@ skipping 32 matching lines @@
     // Setup and start the updater.
     MessageLoop message_loop;
     content::TestBrowserThread ui_thread(BrowserThread::UI, &message_loop);
     content::TestBrowserThread io_thread(BrowserThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), 60*60*24);
+    updater.set_use_utility_process_for_testing(false);
     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 =
         factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
     ASSERT_FALSE(fetcher == NULL);
     const GURL& url = fetcher->GetOriginalURL();
@@ skipping 92 matching lines @@
 
     // Create a set of test extensions
     ServiceForManifestTests service;
     ExtensionList tmp;
     service.CreateTestExtensions(1, 3, &tmp, NULL, Extension::INTERNAL);
     service.set_extensions(tmp);
 
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
+    updater.set_use_utility_process_for_testing(false);
     updater.Start();
 
     // Check passing an empty list of parse results to DetermineUpdates
     ManifestFetchData fetch_data(GURL("http://localhost/foo"));
     UpdateManifest::Results updates;
     std::vector<int> updateable = updater.DetermineUpdates(fetch_data,
                                                            updates);
     EXPECT_TRUE(updateable.empty());
 
     // Create two updates - expect that DetermineUpdates will return the first
@@ skipping 21 matching lines @@
     ServiceForManifestTests service;
     PendingExtensionManager* pending_extension_manager =
         service.pending_extension_manager();
     SetupPendingExtensionManagerForTest(3, GURL(), pending_extension_manager);
 
     MessageLoop message_loop;
     content::TestBrowserThread ui_thread(BrowserThread::UI, &message_loop);
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
+    updater.set_use_utility_process_for_testing(false);
     updater.Start();
 
     ManifestFetchData fetch_data(GURL("http://localhost/foo"));
     UpdateManifest::Results updates;
     PendingExtensionManager::const_iterator it;
     for (it = pending_extension_manager->begin();
          it != pending_extension_manager->end(); ++it) {
       fetch_data.AddExtension(it->first, "1.0.0.0",
                               kNeverPingedData,
                               kEmptyUpdateUrlData);
@@ skipping 18 matching lines @@
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     TestURLFetcher* fetcher = NULL;
     scoped_ptr<ServiceForDownloadTests> service(new ServiceForDownloadTests);
     ExtensionUpdater updater(service.get(),
                              service->extension_prefs(),
                              service->pref_service(),
                              service->profile(),
                              kUpdateFrequencySecs);
+    updater.set_use_utility_process_for_testing(false);
     updater.Start();
 
     GURL url1("http://localhost/manifest1");
     GURL url2("http://localhost/manifest2");
 
     // Request 2 update checks - the first should begin immediately and the
     // second one should be queued up.
     ManifestFetchData* fetch1 = new ManifestFetchData(url1);
     ManifestFetchData* fetch2 = new ManifestFetchData(url2);
     ManifestFetchData::PingData zeroDays(0, 0);
@@ skipping 58 matching lines @@
     content::TestBrowserThread io_thread(BrowserThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     TestURLFetcher* fetcher = NULL;
     scoped_ptr<ServiceForDownloadTests> service(new ServiceForDownloadTests);
     ExtensionUpdater updater(service.get(), service->extension_prefs(),
                              service->pref_service(),
                              service->profile(),
                              kUpdateFrequencySecs);
+    updater.set_use_utility_process_for_testing(false);
     updater.Start();
 
     GURL test_url("http://localhost/extension.crx");
 
     std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     std::string hash = "";
     scoped_ptr<Version> version(Version::GetVersionFromString("0.0.1"));
     ASSERT_TRUE(version.get());
     updater.FetchUpdatedExtension(id, test_url, hash, version->GetString());
 
@@ skipping 44 matching lines @@
     content::TestBrowserThread file_thread(BrowserThread::FILE, &message_loop);
     content::TestBrowserThread io_thread(BrowserThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     TestURLFetcher* fetcher = NULL;
     ServiceForBlacklistTests service;
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
+    updater.set_use_utility_process_for_testing(false);
     updater.Start();
     GURL test_url("http://localhost/extension.crx");
 
     std::string id = "com.google.crx.blacklist";
 
     std::string hash =
         "2CE109E9D0FAF820B2434E166297934E6177B65AB9951DBC3E204CAD4689B39C";
 
     std::string version = "0.0.1";
     updater.FetchUpdatedExtension(id, test_url, hash, version);
@@ skipping 31 matching lines @@
     content::TestBrowserThread file_thread(BrowserThread::FILE, &message_loop);
     content::TestBrowserThread io_thread(BrowserThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     TestURLFetcher* fetcher = NULL;
     ServiceForDownloadTests service;
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
+    updater.set_use_utility_process_for_testing(false);
     updater.Start();
 
     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 181 matching lines @@
                                   TimeDelta::FromDays(active_ping_days) -
                                   TimeDelta::FromSeconds(15);
       prefs->SetLastActivePingDay(id, last_active_ping_day);
     }
     if (active_bit)
       prefs->SetActiveBit(id, true);
 
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
+    updater.set_use_utility_process_for_testing(false);
     updater.Start();
     updater.set_blacklist_checks_enabled(false);
 
     // Make the updater do manifest fetching, and note the urls it tries to
     // fetch.
     std::vector<GURL> fetched_urls;
     updater.CheckNow();
     TestURLFetcher* fetcher =
       factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
@@ skipping 67 matching lines @@
   // of a <daystart> tag from a manifest fetch in one of two cases: 1) This is
   // the first time we fetched the extension, or 2) We sent a ping value of
   // >= 1 day for the extension.
   static void TestHandleManifestResults() {
     ServiceForManifestTests service;
     MessageLoop message_loop;
     content::TestBrowserThread ui_thread(BrowserThread::UI, &message_loop);
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
+    updater.set_use_utility_process_for_testing(false);
     updater.Start();
 
     GURL update_url("http://www.google.com/manifest");
     ExtensionList tmp;
     service.CreateTestExtensions(1, 1, &tmp, &update_url.spec(),
                                  Extension::INTERNAL);
     service.set_extensions(tmp);
 
     ManifestFetchData fetch_data(update_url);
     const Extension* extension = tmp[0];
@@ skipping 136 matching lines @@
 TEST_F(ExtensionUpdaterTest, TestStartUpdateCheckMemory) {
     MessageLoop message_loop;
     content::TestBrowserThread ui_thread(BrowserThread::UI, &message_loop);
     content::TestBrowserThread file_thread(BrowserThread::FILE, &message_loop);
 
     ServiceForManifestTests service;
     TestURLFetcherFactory factory;
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
+    updater.set_use_utility_process_for_testing(false);
     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_F(ExtensionUpdaterTest, TestCheckSoon) {
     MessageLoop message_loop;
     content::TestBrowserThread ui_thread(BrowserThread::UI, &message_loop);
     content::TestBrowserThread file_thread(BrowserThread::FILE, &message_loop);
 
     ServiceForManifestTests service;
     TestURLFetcherFactory factory;
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
+    updater.set_use_utility_process_for_testing(false);
     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