GTTF: Use a fresh TestingBrowserProcess for each test, part #4

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/base/testing_profile.h"
+#include "chrome/test/testing_browser_process_test.h"
 #include "content/browser/browser_thread.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;
@@ skipping 240 matching lines @@
       EXPECT_TRUE(result->find(key) == result->end());
       (*result)[key] = (key_val.size() == 2) ? key_val[1] : "";
     } else {
       NOTREACHED();
     }
   }
 }
 
 // All of our tests that need to use private APIs of ExtensionUpdater live
 // inside this class (which is a friend to ExtensionUpdater).
-class ExtensionUpdaterTest : public testing::Test {
+class ExtensionUpdaterTest : public TestingBrowserProcessTest {
  public:
   static void SimulateTimerFired(ExtensionUpdater* updater) {
     EXPECT_TRUE(updater->timer_.IsRunning());
     updater->timer_.Stop();
     updater->TimerFired();
   }
 
   static void SimulateCheckSoon(const ExtensionUpdater& updater,
                                 MessageLoop* message_loop) {
     EXPECT_TRUE(updater.will_check_soon_);
@@ skipping 733 matching lines @@
     EXPECT_FALSE(last_ping_day.is_null());
     int64 seconds_diff = (Time::Now() - last_ping_day).InSeconds();
     EXPECT_LT(seconds_diff - results.daystart_elapsed_seconds, 5);
   }
 };
 
 // Because we test some private methods of ExtensionUpdater, it's easer for the
 // actual test code to live in ExtenionUpdaterTest methods instead of TEST_F
 // subclasses where friendship with ExtenionUpdater is not inherited.
 
-TEST(ExtensionUpdaterTest, TestExtensionUpdateCheckRequests) {
+TEST_F(ExtensionUpdaterTest, TestExtensionUpdateCheckRequests) {
   ExtensionUpdaterTest::TestExtensionUpdateCheckRequests(false);
 }
 
-TEST(ExtensionUpdaterTest, TestExtensionUpdateCheckRequestsPending) {
+TEST_F(ExtensionUpdaterTest, TestExtensionUpdateCheckRequestsPending) {
   ExtensionUpdaterTest::TestExtensionUpdateCheckRequests(true);
 }
 
-// This test is disabled on Mac, see http://crbug.com/26035.
-TEST(ExtensionUpdaterTest, TestBlacklistUpdateCheckRequests) {
+TEST_F(ExtensionUpdaterTest, TestBlacklistUpdateCheckRequests) {
   ExtensionUpdaterTest::TestBlacklistUpdateCheckRequests();
 }
 
-TEST(ExtensionUpdaterTest, TestUpdateUrlData) {
+TEST_F(ExtensionUpdaterTest, TestUpdateUrlData) {
   MessageLoop message_loop;
   BrowserThread file_thread(BrowserThread::FILE, &message_loop);
 
   ExtensionUpdaterTest::TestUpdateUrlDataEmpty();
   ExtensionUpdaterTest::TestUpdateUrlDataSimple();
   ExtensionUpdaterTest::TestUpdateUrlDataCompound();
   ExtensionUpdaterTest::TestUpdateUrlDataFromGallery(
       Extension::GalleryUpdateUrl(false).spec());
   ExtensionUpdaterTest::TestUpdateUrlDataFromGallery(
       Extension::GalleryUpdateUrl(true).spec());
 }
 
-TEST(ExtensionUpdaterTest, TestDetermineUpdates) {
+TEST_F(ExtensionUpdaterTest, TestDetermineUpdates) {
   ExtensionUpdaterTest::TestDetermineUpdates();
 }
 
-TEST(ExtensionUpdaterTest, TestDetermineUpdatesPending) {
+TEST_F(ExtensionUpdaterTest, TestDetermineUpdatesPending) {
   ExtensionUpdaterTest::TestDetermineUpdatesPending();
 }
 
-TEST(ExtensionUpdaterTest, TestMultipleManifestDownloading) {
+TEST_F(ExtensionUpdaterTest, TestMultipleManifestDownloading) {
   ExtensionUpdaterTest::TestMultipleManifestDownloading();
 }
 
-TEST(ExtensionUpdaterTest, TestSingleExtensionDownloading) {
+TEST_F(ExtensionUpdaterTest, TestSingleExtensionDownloading) {
   ExtensionUpdaterTest::TestSingleExtensionDownloading(false);
 }
 
-TEST(ExtensionUpdaterTest, TestSingleExtensionDownloadingPending) {
+TEST_F(ExtensionUpdaterTest, TestSingleExtensionDownloadingPending) {
   ExtensionUpdaterTest::TestSingleExtensionDownloading(true);
 }
 
-// This test is disabled on Mac, see http://crbug.com/26035.
-TEST(ExtensionUpdaterTest, TestBlacklistDownloading) {
+TEST_F(ExtensionUpdaterTest, TestBlacklistDownloading) {
   ExtensionUpdaterTest::TestBlacklistDownloading();
 }
 
-TEST(ExtensionUpdaterTest, TestMultipleExtensionDownloadingUpdatesFail) {
+TEST_F(ExtensionUpdaterTest, TestMultipleExtensionDownloadingUpdatesFail) {
   ExtensionUpdaterTest::TestMultipleExtensionDownloading(false);
 }
-TEST(ExtensionUpdaterTest, TestMultipleExtensionDownloadingUpdatesSucceed) {
+TEST_F(ExtensionUpdaterTest, TestMultipleExtensionDownloadingUpdatesSucceed) {
   ExtensionUpdaterTest::TestMultipleExtensionDownloading(true);
 }
 
-TEST(ExtensionUpdaterTest, TestGalleryRequests) {
+TEST_F(ExtensionUpdaterTest, TestGalleryRequests) {
   // We want to test a variety of combinations of expected ping conditions for
   // rollcall and active pings.
   int ping_cases[] = { ManifestFetchData::kNeverPinged, 0, 1, 5 };
 
   for (size_t i = 0; i < arraysize(ping_cases); i++) {
     for (size_t j = 0; j < arraysize(ping_cases); j++) {
       for (size_t k = 0; k < 2; k++) {
         int rollcall_ping_days = ping_cases[i];
         int active_ping_days = ping_cases[j];
         // Skip cases where rollcall_ping_days == -1, but active_ping_days > 0,
         // because rollcall_ping_days == -1 means the app was just installed and
         // this is the first update check after installation.
         if (rollcall_ping_days == ManifestFetchData::kNeverPinged &&
             active_ping_days > 0)
           continue;
 
         bool active_bit = k > 0;
         ExtensionUpdaterTest::TestGalleryRequests(
             rollcall_ping_days, active_ping_days, active_bit);
         ASSERT_FALSE(HasFailure()) <<
           " rollcall_ping_days=" << ping_cases[i] <<
           " active_ping_days=" << ping_cases[j] <<
           " active_bit=" << active_bit;
       }
     }
   }
 }
 
-TEST(ExtensionUpdaterTest, TestHandleManifestResults) {
+TEST_F(ExtensionUpdaterTest, TestHandleManifestResults) {
   ExtensionUpdaterTest::TestHandleManifestResults();
 }
 
-TEST(ExtensionUpdaterTest, TestManifestFetchesBuilderAddExtension) {
+TEST_F(ExtensionUpdaterTest, TestManifestFetchesBuilderAddExtension) {
   MessageLoop message_loop;
   BrowserThread file_thread(BrowserThread::FILE, &message_loop);
 
   MockService service;
   ManifestFetchesBuilder builder(&service, service.extension_prefs());
 
   // Non-internal non-external extensions should be rejected.
   {
     ExtensionList extensions;
     service.CreateTestExtensions(1, 1, &extensions, NULL, Extension::INVALID);
@@ skipping 28 matching lines @@
                                               false, false,
                                               Extension::INTERNAL));
   std::vector<ManifestFetchData*> fetches = builder.GetFetches();
   ASSERT_EQ(1u, fetches.size());
   scoped_ptr<ManifestFetchData> fetch(fetches[0]);
   fetches.clear();
   EXPECT_FALSE(fetch->base_url().is_empty());
   EXPECT_FALSE(fetch->full_url().is_empty());
 }
 
-TEST(ExtensionUpdaterTest, TestStartUpdateCheckMemory) {
+TEST_F(ExtensionUpdaterTest, TestStartUpdateCheckMemory) {
     MessageLoop message_loop;
     BrowserThread ui_thread(BrowserThread::UI, &message_loop);
     BrowserThread file_thread(BrowserThread::FILE, &message_loop);
 
     ServiceForManifestTests service;
     TestURLFetcherFactory 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) {
+TEST_F(ExtensionUpdaterTest, TestCheckSoon) {
     MessageLoop message_loop;
     BrowserThread ui_thread(BrowserThread::UI, &message_loop);
     BrowserThread file_thread(BrowserThread::FILE, &message_loop);
 
     ServiceForManifestTests service;
     TestURLFetcherFactory factory;
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
     EXPECT_FALSE(updater.WillCheckSoon());
@@ skipping 13 matching lines @@
 
 // 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