Allow URLFetcher to save results in a file. Have CRX updates use this capability.

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/stl_util-inl.h"
@@ skipping 559 matching lines @@
     fetch1->AddExtension("1111", "1.0", zeroDays, kEmptyUpdateUrlData);
     fetch2->AddExtension("12345", "2.0", kNeverPingedData,
                          kEmptyUpdateUrlData);
     updater.StartUpdateCheck(fetch1);
     updater.StartUpdateCheck(fetch2);
 
     std::string invalid_xml = "invalid xml";
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
-    fetcher->delegate()->OnURLFetchComplete(
-        fetcher, url1, net::URLRequestStatus(), 200, net::ResponseCookies(),
-        invalid_xml);
+
+    fetcher->set_url(url1);
+    fetcher->set_status(net::URLRequestStatus());
+    fetcher->set_response_code(200);
+    fetcher->SetResponseString(invalid_xml);
+    fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     // Now that the first request is complete, make sure the second one has
     // been started.
     const std::string kValidXml =
         "<?xml version='1.0' encoding='UTF-8'?>"
         "<gupdate xmlns='http://www.google.com/update2/response'"
         "                protocol='2.0'>"
         " <app appid='12345'>"
         "  <updatecheck codebase='http://example.com/extension_1.2.3.4.crx'"
         "               version='1.2.3.4' prodversionmin='2.0.143.0' />"
         " </app>"
         "</gupdate>";
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
-    fetcher->delegate()->OnURLFetchComplete(
-        fetcher, url2, net::URLRequestStatus(), 200, net::ResponseCookies(),
-        kValidXml);
+
+    fetcher->set_url(url2);
+    fetcher->set_status(net::URLRequestStatus());
+    fetcher->set_response_code(200);
+    fetcher->SetResponseString(kValidXml);
+    fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     // 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());
     xmlCleanupGlobals();
 
@@ skipping 35 matching lines @@
       PendingExtensionManager* pending_extension_manager =
           service->pending_extension_manager();
       pending_extension_manager->AddForTesting(
           id,
           PendingExtensionInfo(test_url, &ShouldAlwaysInstall, kIsFromSync,
                                kInstallSilently,
                                Extension::INTERNAL));
     }
 
     // Call back the ExtensionUpdater with a 200 response and some test data
-    std::string extension_data("whatever");
+    FilePath extension_file_path(FILE_PATH_LITERAL("/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, net::ResponseCookies(),
-        extension_data);
+
+    fetcher->set_url(test_url);
+    fetcher->set_status(net::URLRequestStatus());
+    fetcher->set_response_code(200);
+    fetcher->SetResponseFilePath(extension_file_path);
+    fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     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_FALSE(tmpfile_path.empty());
     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);
+    EXPECT_EQ(extension_file_path, tmpfile_path);
 
     // 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;
     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 =
-      "2CE109E9D0FAF820B2434E166297934E6177B65AB9951DBC3E204CAD4689B39C";
+        "2CE109E9D0FAF820B2434E166297934E6177B65AB9951DBC3E204CAD4689B39C";
 
     std::string version = "0.0.1";
     updater.FetchUpdatedExtension(id, test_url, hash, version);
 
-    // Call back the ExtensionUpdater with a 200 response and some test data
+    // Call back the ExtensionUpdater with a 200 response and some test data.
     std::string extension_data("aaabbb");
+
     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, net::ResponseCookies(),
-        extension_data);
+
+    fetcher->set_url(test_url);
+    fetcher->set_status(net::URLRequestStatus());
+    fetcher->set_response_code(200);
+    fetcher->SetResponseString(extension_data);
+    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));
 
@@ skipping 25 matching lines @@
     std::string hash1 = "";
     std::string hash2 = "";
 
     std::string version1 = "0.1";
     std::string version2 = "0.1";
     // Start two fetches
     updater.FetchUpdatedExtension(id1, url1, hash1, version1);
     updater.FetchUpdatedExtension(id2, url2, hash2, version2);
 
     // Make the first fetch complete.
-    std::string extension_data1("whatever");
+    FilePath extension_file_path(FILE_PATH_LITERAL("/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, url1, net::URLRequestStatus(), 200, net::ResponseCookies(),
-        extension_data1);
+
+    fetcher->set_url(url1);
+    fetcher->set_status(net::URLRequestStatus());
+    fetcher->set_response_code(200);
+    fetcher->SetResponseFilePath(extension_file_path);
+    fetcher->delegate()->OnURLFetchComplete(fetcher);
+
     message_loop.RunAllPending();
 
     // Expect that the service was asked to do an install with the right data.
     FilePath tmpfile_path = service.install_path();
     EXPECT_FALSE(tmpfile_path.empty());
     EXPECT_EQ(id1, service.extension_id());
     EXPECT_EQ(url1, service.download_url());
     message_loop.RunAllPending();
-    file_util::Delete(tmpfile_path, false);
 
     // Make sure the second fetch finished and asked the service to do an
     // update.
-    std::string extension_data2("whatever2");
+    FilePath extension_file_path2(FILE_PATH_LITERAL("/whatever2"));
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
-    fetcher->delegate()->OnURLFetchComplete(
-        fetcher, url2, net::URLRequestStatus(), 200, net::ResponseCookies(),
-        extension_data2);
+
+    fetcher->set_url(url2);
+    fetcher->set_status(net::URLRequestStatus());
+    fetcher->set_response_code(200);
+    fetcher->SetResponseFilePath(extension_file_path2);
+    fetcher->delegate()->OnURLFetchComplete(fetcher);
     message_loop.RunAllPending();
     EXPECT_EQ(id2, service.extension_id());
     EXPECT_EQ(url2, service.download_url());
     EXPECT_FALSE(service.install_path().empty());
 
     // Make sure the correct crx contents were passed for the update call.
-    std::string file_contents;
-    EXPECT_TRUE(file_util::ReadFileToString(service.install_path(),
-                                            &file_contents));
-    EXPECT_TRUE(extension_data2 == file_contents);
-    file_util::Delete(service.install_path(), false);
+    EXPECT_EQ(extension_file_path2, service.install_path());
   }
 
   // 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,
@@ skipping 49 matching lines @@
     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);
     fetched_urls.push_back(fetcher->original_url());
-    fetcher->delegate()->OnURLFetchComplete(
-      fetcher, fetched_urls[0], net::URLRequestStatus(), 500,
-      net::ResponseCookies(), "");
-    fetcher =
-      factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
+
+    fetcher->set_url(fetched_urls[0]);
+    fetcher->set_status(net::URLRequestStatus());
+    fetcher->set_response_code(500);
+    fetcher->SetResponseString("");
+    fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+    fetcher = factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
     fetched_urls.push_back(fetcher->original_url());
 
     // The urls could have been fetched in either order, so use the host to
     // tell them apart and note the query each used.
     std::string url1_query;
     std::string url2_query;
     if (fetched_urls[0].host() == url1.host()) {
       url1_query = fetched_urls[0].query();
       url2_query = fetched_urls[1].query();
     } else if (fetched_urls[0].host() == url2.host()) {
@@ skipping 253 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