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

chrome/common/net/url_fetcher_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 "base/message_loop_proxy.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "chrome/common/net/url_fetcher.h"
 #include "net/http/http_response_headers.h"
 #include "net/test/test_server.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "net/url_request/url_request_throttler_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(USE_NSS)
 #include "net/ocsp/nss_ocsp.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 
 // TODO(eroman): Add a regression test for http://crbug.com/40505.
 
 namespace {
 
 const FilePath::CharType kDocRoot[] = FILE_PATH_LITERAL("chrome/test/data");
+const std::string kTestServerFilePrefix = "files/";
 
 class CurriedTask : public Task {
  public:
   CurriedTask(Task* task, MessageLoop* target_loop)
       : task_(task),
         target_loop_(target_loop) {}
 
   virtual void Run() {
     target_loop_->PostTask(FROM_HERE, task_);
   }
@@ skipping 259 matching lines @@
   virtual void OnURLFetchComplete(const URLFetcher* source,
                                   const GURL& url,
                                   const net::URLRequestStatus& status,
                                   int response_code,
                                   const net::ResponseCookies& cookies,
                                   const std::string& data);
  private:
   std::string data_;
 };
 
+class URLFetcherTempFileTest : public URLFetcherTest {
+ public:
+  URLFetcherTempFileTest()
+      : take_ownership_of_temp_file_(false) {
+  }
+
+  // URLFetcher::Delegate
+  virtual void OnURLFetchComplete(const URLFetcher* source);
+
+  virtual void CreateFetcher(const GURL& url);
+
+ protected:
+  FilePath expected_file_;
+  FilePath temp_file_;
+
+  // Set by the test. Used in OnURLFetchComplete() to decide if
+  // the URLFetcher should own the temp file, so that we can test
+  // disowning prevents the file from being deleted.
+  bool take_ownership_of_temp_file_;
+};
+
+void URLFetcherTempFileTest::CreateFetcher(const GURL& url) {
+  fetcher_ = new URLFetcher(url, URLFetcher::GET, this);
+  fetcher_->set_request_context(new TestURLRequestContextGetter(
+      io_message_loop_proxy()));
+
+  // Use the IO message loop to do the file operations in this test.
+  fetcher_->SaveResponseToTemporaryFile(io_message_loop_proxy());
+  fetcher_->Start();
+}
+
+TEST_F(URLFetcherTempFileTest, SmallGet) {
+  net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  // Get a small file.
+  const char* kFileToFetch = "simple.html";
+  expected_file_ = test_server.document_root().AppendASCII(kFileToFetch);
+  CreateFetcher(test_server.GetURL(kTestServerFilePrefix + kFileToFetch));
+
+  MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
+
+  ASSERT_TRUE(file_util::PathExists(temp_file_))
+      << temp_file_.value() << " not found.";
+
+  // Deleting the fetcher should remove the file.
+  delete fetcher_;
+
+  MessageLoop::current()->RunAllPending();
+  ASSERT_FALSE(file_util::PathExists(temp_file_))
+      << temp_file_.value() << " not removed.";
+}
+
+TEST_F(URLFetcherTempFileTest, LargeGet) {
+  net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  // Get a file large enough to require more than one read into
+  // URLFetcher::Core's IOBuffer.
+  const char* kFileToFetch = "animate1.gif";
+  expected_file_ = test_server.document_root().AppendASCII(kFileToFetch);
+  CreateFetcher(test_server.GetURL(kTestServerFilePrefix + kFileToFetch));
+
+  MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
+}
+
+TEST_F(URLFetcherTempFileTest, CanTakeOwnershipOfFile) {
+  net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath(kDocRoot));
+  ASSERT_TRUE(test_server.Start());
+
+  // Get a small file.
+  const char* kFileToFetch = "simple.html";
+  expected_file_ = test_server.document_root().AppendASCII(kFileToFetch);
+  CreateFetcher(test_server.GetURL(kTestServerFilePrefix + kFileToFetch));
+
+  MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
+
+  ASSERT_TRUE(file_util::PathExists(temp_file_))
+      << temp_file_.value() << " not found.";
+
+  // Deleting the fetcher should remove the file.
+  delete fetcher_;
+
+  MessageLoop::current()->RunAllPending();
+  ASSERT_FALSE(file_util::PathExists(temp_file_))
+      << temp_file_.value() << " not removed.";
+}
+
 // Wrapper that lets us call CreateFetcher() on a thread of our choice.  We
 // could make URLFetcherTest refcounted and use PostTask(FROM_HERE.. ) to call
 // CreateFetcher() directly, but the ownership of the URLFetcherTest is a bit
 // confusing in that case because GTest doesn't know about the refcounting.
 // It's less confusing to just do it this way.
 class FetcherWrapperTask : public Task {
  public:
   FetcherWrapperTask(URLFetcherTest* test, const GURL& url)
       : test_(test), url_(url) { }
   virtual void Run() {
@@ skipping 214 matching lines @@
     delete fetcher_;  // Have to delete this here and not in the destructor,
                       // because the destructor won't necessarily run on the
                       // same thread that CreateFetcher() did.
 
     io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
     // If the current message loop is not the IO loop, it will be shut down when
     // the main loop returns and this thread subsequently goes out of scope.
   }
 }
 
+void URLFetcherTempFileTest::OnURLFetchComplete(const URLFetcher* source) {
+  EXPECT_TRUE(source->status().is_success());
+  EXPECT_EQ(source->response_code(), 200);
+
+  EXPECT_TRUE(source->GetResponseAsFilePath(
+      take_ownership_of_temp_file_, &temp_file_));
+
+  EXPECT_TRUE(file_util::ContentsEqual(expected_file_, temp_file_));
+
+  io_message_loop_proxy()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+}
+
 TEST_F(URLFetcherTest, SameThreadsTest) {
   net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   // Create the fetcher on the main thread.  Since IO will happen on the main
   // thread, this will test URLFetcher's ability to do everything on one
   // thread.
   CreateFetcher(test_server.GetURL("defaultresponse"));
 
   MessageLoop::current()->Run();
@@ skipping 146 matching lines @@
 TEST_F(URLFetcherCancelTest, DISABLED_ReleasesContext) {
 #else
 TEST_F(URLFetcherCancelTest, ReleasesContext) {
 #endif
   net::TestServer test_server(net::TestServer::TYPE_HTTP, FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   GURL url(test_server.GetURL("files/server-unavailable.html"));
 
   // Registers an entry for test url. The backoff time is calculated by:
-  //     new_backoff = 2.0 * old_backoff + 0
+  //     new_backoff = 2.0 * old_backoff +0
   // The initial backoff is 2 seconds and maximum backoff is 4 seconds.
   // Maximum retries allowed is set to 2.
   net::URLRequestThrottlerManager* manager =
       net::URLRequestThrottlerManager::GetInstance();
   scoped_refptr<net::URLRequestThrottlerEntry> entry(
       new net::URLRequestThrottlerEntry(
           manager, 200, 3, 2000, 2.0, 0.0, 4000));
   manager->OverrideEntryForTests(url, entry);
 
   // Create a separate thread that will create the URLFetcher.  The current
@@ skipping 64 matching lines @@
       FROM_HERE,
       new CurriedTask(new MessageLoop::QuitTask(), MessageLoop::current()));
   MessageLoop::current()->Run();
   EXPECT_EQ(1, GetNumFetcherCores());
   URLFetcher::CancelAll();
   EXPECT_EQ(0, GetNumFetcherCores());
   delete fetcher_;
 }
 
 }  // namespace.