ImportantFileWriter: check return value of PostTask...

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/file_util.h"
 #include "base/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
@@ skipping 297 matching lines @@
       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);
   }
 
   static void TestExtensionUpdateCheckRequests(bool pending) {
+    MessageLoop message_loop;
+    BrowserThread file_thread(BrowserThread::FILE, &message_loop);
+    BrowserThread io_thread(BrowserThread::IO);
+    io_thread.Start();
+
     // Create an extension with an update_url.
     ServiceForManifestTests service;
     std::string update_url("http://foo.com/bar");
     ExtensionList extensions;
     PendingExtensionMap pending_extensions;
     if (pending) {
       CreateTestPendingExtensions(1, GURL(update_url), &pending_extensions);
       service.set_pending_extensions(pending_extensions);
     } else {
       service.CreateTestExtensions(1, 1, &extensions, &update_url,
                                    Extension::INTERNAL);
       service.set_extensions(extensions);
     }
 
-    // Setup and start the updater.
-    MessageLoop message_loop;
-    BrowserThread io_thread(BrowserThread::IO);
-    io_thread.Start();
-
+    // Set up and start the updater.
     TestURLFetcherFactory factory;
     URLFetcher::set_factory(&factory);
     scoped_refptr<ExtensionUpdater> updater(
         new ExtensionUpdater(&service, service.pref_service(), 60*60*24));
     updater->Start();
 
     // Tell the update that it's time to do update checks.
     SimulateTimerFired(updater.get());
 
     // Get the url our mock fetcher was asked to fetch.
@@ skipping 139 matching lines @@
     // Make sure that extensions that update from the gallery ignore any
     // update URL data.
     const std::string& update_url = fetch->full_url().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);
   }
 
   static void TestDetermineUpdates() {
+    MessageLoop message_loop;
+    BrowserThread file_thread(BrowserThread::FILE, &message_loop);
+
     // Create a set of test extensions
     ServiceForManifestTests service;
     ExtensionList tmp;
     service.CreateTestExtensions(1, 3, &tmp, NULL, Extension::INTERNAL);
     service.set_extensions(tmp);
 
-    MessageLoop message_loop;
     scoped_refptr<ExtensionUpdater> updater(
         new ExtensionUpdater(&service, service.pref_service(),
                              kUpdateFrequencySecs));
     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);
@@ skipping 55 matching lines @@
     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);
-    ServiceForDownloadTests service;
+    scoped_ptr<ServiceForDownloadTests> service(new ServiceForDownloadTests);
     scoped_refptr<ExtensionUpdater> updater(
-        new ExtensionUpdater(&service, service.pref_service(),
+        new ExtensionUpdater(service.get(), service->pref_service(),
                              kUpdateFrequencySecs));
     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);
@@ skipping 29 matching lines @@
     fetcher->delegate()->OnURLFetchComplete(
         fetcher, url2, net::URLRequestStatus(), 200, ResponseCookies(),
         kValidXml);
 
     // This should run the manifest parsing, then we want to make sure that our
     // service was called with GetExtensionById with the matching id from
     // kValidXml.
     file_thread.Stop();
     io_thread.Stop();
     ui_loop.RunAllPending();
-    EXPECT_EQ("12345", service.last_inquired_extension_id());
+    EXPECT_EQ("12345", service->last_inquired_extension_id());
     xmlCleanupGlobals();
+
+    // The FILE thread is needed for |service|'s cleanup,
+    // because of ImportantFileWriter.
+    file_thread.Start();
+    service.reset();
   }
 
   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);
-    ServiceForDownloadTests service;
+    scoped_ptr<ServiceForDownloadTests> service(new ServiceForDownloadTests);
     scoped_refptr<ExtensionUpdater> updater(
-        new ExtensionUpdater(&service, service.pref_service(),
+        new ExtensionUpdater(service.get(), service->pref_service(),
                              kUpdateFrequencySecs));
     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());
 
     if (pending) {
       const bool kIsFromSync = true;
       const bool kInstallSilently = true;
       const Extension::State kInitialState = Extension::ENABLED;
       const bool kInitialIncognitoEnabled = false;
       PendingExtensionMap pending_extensions;
       pending_extensions[id] =
           PendingExtensionInfo(test_url, &ShouldAlwaysInstall, kIsFromSync,
                                kInstallSilently, kInitialState,
                                kInitialIncognitoEnabled, Extension::INTERNAL);
-      service.set_pending_extensions(pending_extensions);
+      service->set_pending_extensions(pending_extensions);
     }
 
     // Call back the ExtensionUpdater with a 200 response and some test data
     std::string extension_data("whatever");
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
     fetcher->delegate()->OnURLFetchComplete(
         fetcher, test_url, net::URLRequestStatus(), 200, ResponseCookies(),
         extension_data);
 
     file_thread.Stop();
     ui_loop.RunAllPending();
 
     // 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_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(test_url, service->download_url());
     std::string file_contents;
     EXPECT_TRUE(file_util::ReadFileToString(tmpfile_path, &file_contents));
     EXPECT_TRUE(extension_data == file_contents);
 
+    // The FILE thread is needed for |service|'s cleanup,
+    // because of ImportantFileWriter.
+    file_thread.Start();
+    service.reset();
+
     file_util::Delete(tmpfile_path, false);
     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;
     scoped_refptr<ExtensionUpdater> updater(
         new ExtensionUpdater(&service, service.pref_service(),
                              kUpdateFrequencySecs));
@@ skipping 102 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).
   static void TestGalleryRequests(int rollcall_ping_days,
                                   int active_ping_days,
                                   bool active_bit) {
+    MessageLoop 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(),
@@ skipping 20 matching lines @@
       prefs->SetLastActivePingDay(id, now - TimeDelta::FromSeconds(15));
     } else if (active_ping_days > 0) {
       Time last_active_ping_day = now -
                                   TimeDelta::FromDays(active_ping_days) -
                                   TimeDelta::FromSeconds(15);
       prefs->SetLastActivePingDay(id, last_active_ping_day);
     }
     if (active_bit)
       prefs->SetActiveBit(id, true);
 
-    MessageLoop message_loop;
     scoped_refptr<ExtensionUpdater> updater(
       new ExtensionUpdater(&service, service.pref_service(),
                            kUpdateFrequencySecs));
     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();
@@ skipping 91 matching lines @@
 TEST(ExtensionUpdaterTest, TestExtensionUpdateCheckRequestsPending) {
   ExtensionUpdaterTest::TestExtensionUpdateCheckRequests(true);
 }
 
 // This test is disabled on Mac, see http://crbug.com/26035.
 TEST(ExtensionUpdaterTest, TestBlacklistUpdateCheckRequests) {
   ExtensionUpdaterTest::TestBlacklistUpdateCheckRequests();
 }
 
 TEST(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) {
@@ skipping 52 matching lines @@
       }
     }
   }
 }
 
 TEST(ExtensionUpdaterTest, TestHandleManifestResults) {
   ExtensionUpdaterTest::TestHandleManifestResults();
 }
 
 TEST(ExtensionUpdaterTest, TestManifestFetchesBuilderAddExtension) {
+  MessageLoop message_loop;
+  BrowserThread file_thread(BrowserThread::FILE, &message_loop);
+
   MockService service;
   ManifestFetchesBuilder builder(&service);
 
   // Non-internal non-external extensions should be rejected.
   {
     ExtensionList extensions;
     service.CreateTestExtensions(1, 1, &extensions, NULL, Extension::INVALID);
     ASSERT_FALSE(extensions.empty());
     builder.AddExtension(*extensions[0]);
     EXPECT_TRUE(builder.GetFetches().empty());
@@ skipping 27 matching lines @@
   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) {
     MessageLoop message_loop;
+    BrowserThread file_thread(BrowserThread::FILE, &message_loop);
+
     ServiceForManifestTests service;
     TestURLFetcherFactory factory;
     URLFetcher::set_factory(&factory);
     scoped_refptr<ExtensionUpdater> updater(
         new ExtensionUpdater(&service, service.pref_service(),
                              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, TestAfterStopBehavior) {
     MessageLoop message_loop;
+    BrowserThread file_thread(BrowserThread::FILE, &message_loop);
+
     ServiceForManifestTests service;
     scoped_refptr<ExtensionUpdater> updater(
         new ExtensionUpdater(&service, service.pref_service(),
                              kUpdateFrequencySecs));
     updater->Start();
     updater->Stop();
     // All the below functions should do nothing.
     updater->OnCRXFileWritten("", FilePath(), GURL());
     GURL dummy_gurl;
     ManifestFetchData dummy_manifest_fetch_data(dummy_gurl);
     updater->HandleManifestResults(dummy_manifest_fetch_data,
                                    UpdateManifest::Results());
 }
 
 // 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